Реферат: Разработка программы контроля изделий и подготовка программной документации

--PAGE_BREAK--При выпуске новой версии модуля, тег “name” в соответствующем теге “module” дополняется датой выпуска следующей версии. Затем создается новый тег “module” с наименованием модуля и обновленными значениями версий в теге “version”.
Структура TXT-файла “corrections.txt” Если есть необходимость проверить прибор с более ранними версиями каких-либо модулей, входящих в его состав, составляется файл поправок “corrections.txt”. Структура файла “corrections.txt” по п.  REF _Ref202681050 \n \h  \* MERGEFORMAT 0.
Если в папке с программой содержится файл “corrections.txt”, то программа производит обработку этого файла.
В процессе обработки заполняется массив поправок, содержащих два наименования модулей: с поздней версией и с более ранней версией.
Файл “corrections.txt” предназначен для внесения поправок в работу программы.
Файл состоит из записей вида:
<name>=<new_name>;
Здесь “name” – наименование модуля, который необходимо проверить с особыми значениями версий; “new_name” – наименование модуля в файле “module_list.txt” с особыми значениями версий.

Заключение В ходе преддипломной практики (в период с 15 декабря 2008 по 15 февраля <metricconverter productid=«2009 г» w:st=«on»>2009 г.) мною были выполнены поставленные предварительно задачи:
— получены практические навыки работы в коллективе инженеров,
— разработана программа проверки версий компонент изделий,
— подготовлена к выпуску программная документация.

Приложение 1 – Исходные тексты программы //--------------------------------------------------------------
#ifndef Unit2H
#define Unit2H
//--------------------------------------------------------------#include <Classes.hpp>
//--------------------------------------------------------------class Executing: public TThread
{
private:
protected:
void __fastcall Execute();
public:
bool            end;
__fastcall Executing(bool CreateSuspended);
};
//--------------------------------------------------------------#endif
//--------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include «Unit1.h»
#include «Unit2.h»
#include <stdio.h>
#include «ProgExchCl_b.h»
#include «Udevices.h»
#define SecondLevelNodeAccess Form1->XMLDocument1->DocumentElement->ChildNodes
#define ThirdLevelNodeAccess(a) Form1->XMLDocument1->DocumentElement->ChildNodes->GetNode(a)->ChildNodes

#define FourthLevelNodeAccess(a, b) Form1->XMLDocument1->DocumentElement->ChildNodes->GetNode(a)->ChildNodes->GetNode(b)->ChildNodes
char            received_data[255];
PModule              Module;                         // массив модулей
PCorrection Correction; // массив исправлений
HANDLE            m_Disp = NULL; // для монитора
int               wrtd, // для функции mWrite
cor_count; // количество исправлений
TCom*                ComPort; // порт
//--------------------------------------------------------------
void __fastcall msg(char *str)//сообщение для монитора
{
if(!mWrite(m_Disp, (AnsiString(str)+AnsiString("\n\r")).c_str(), strlen(str)+2, &wrtd));
}
void __fastcall logmsg(AnsiString mes)//сообщение в поле мемо
{
Form1->LogText->Lines->Add(mes);
}
//--------------------------------------------------------------char __fastcall DeviceOrModule(AnsiString Parameter, int* item_index) // определить что было передано с начальными параметрами: прибор или модуль и выдать порядковый номер нужного тега.
{
int i, all_nodes;
// ищем прибор
all_nodes = SecondLevelNodeAccess->GetCount(); // количество тегов второго уровня
for (i = 0; i < all_nodes; i++) {
if(AnsiString(SecondLevelNodeAccess->GetNode(i)->Attributes[WideString(«name»)] ) == Parameter){
*item_index = i;
return 1;
}
}
// если прибор не найден, ищем модуль в теге default
all_nodes = SecondLevelNodeAccess->FindNode(«default»)->ChildNodes->GetCount(); // количество тегов третьего уровня в теге default
for (i = 0; i < all_nodes; i++) {
if(AnsiString(SecondLevelNodeAccess->FindNode(«default»)->ChildNodes->GetNode(i)->Text) == Parameter){
*item_index = i;
return 2;
}
}
return 0;
}
//--------------------------------------------------------------
void __fastcall GetModuleList(AnsiString Parameter, PModule* ModuleList, int item_index, int* modules_counter) // получение списка модулей входящих в состав прибора
{
int               i, j, k, p, all_modules, version_count;
AnsiString  mes;
*modules_counter = ThirdLevelNodeAccess(item_index)->GetCount(); // количество модулей в приборе
*ModuleList = new TModule[*modules_counter]; // выделяем память под массив модулей

for (i = 0; i < *modules_counter; i++) { // заполняем поля name и baseaddress
if(cor_count)
{
for(j = 0; j < cor_count; j++) {
if (AnsiString(ThirdLevelNodeAccess(item_index)->GetNode(i)->GetNodeValue()) == Correction[j].name) {
(*ModuleList)[i].name = Correction[j].new_name;
break;
}
else (*ModuleList)[i].name = AnsiString(ThirdLevelNodeAccess(item_index)->GetNode(i)->GetNodeValue());
}
}
else (*ModuleList)[i].name = AnsiString(ThirdLevelNodeAccess(item_index)->GetNode(i)->GetNodeValue());
(*ModuleList)[i].baseaddress = StrToInt(ThirdLevelNodeAccess(item_index)->GetNode(i)->Attributes[WideString(«baseaddress»)]);
}
//       LOG->Add(AnsiString());
// активизация dll со списком модулей
Form1->XMLDocument1->FileName = «module_list.xml»;
Form1->XMLDocument1->Active = true;
all_modules = SecondLevelNodeAccess->GetCount(); // сколько всего модулей в базе
for (i = 0; i < *modules_counter; i++) {
for (j = 0; j <= all_modules; j++) { // заполняем поля version
if (j >= all_modules) { // не нашли модуль (ошибка в файле с исправлениями)
mes = AnsiString(«Не найден модуль „) + (*ModuleList)[i].name;
MessageBox(NULL, mes.c_str(), “Ошибка», MB_ICONERROR | MB_OK );
break;
}
if ((*ModuleList)[i].name == AnsiString(ThirdLevelNodeAccess(j)->GetNode(0)->GetNodeValue())) {
(*ModuleList)[i].version_count = ThirdLevelNodeAccess(j)->GetCount() — 1;
for (k = 0; k < (*ModuleList)[i].version_count; k++) {
(*ModuleList)[i].version[k] = new TVersion;
(*ModuleList)[i].version[k]->address = StrToInt(FourthLevelNodeAccess(j, k+1)->GetNode(0)->NodeValue);
(*ModuleList)[i].version[k]->value = StrToInt(FourthLevelNodeAccess(j, k+1)->GetNode(1)->NodeValue);
(*ModuleList)[i].version[k]->type = StrToInt(FourthLevelNodeAccess(j, k+1)->GetNode(2)->NodeValue);
(*ModuleList)[i].version[k]->description = AnsiString(ThirdLevelNodeAccess(j)->GetNode(k+1)->Attributes[WideString(«description»)]);
}
break;
}
}
//                 LOG->Add(ModuleList[i].name + AnsiString(" ") + ModuleList[i].baseaddress);
}
}
//--------------------------------------------------------------

void __fastcall GetModule(AnsiString Parameter, PModule* ModuleList, int item_index) // получаем информацию для одного модуля
{
int i, j, all_modules;
*ModuleList = new (TModule);
(*ModuleList)[0].name = AnsiString(Form1->XMLDocument1->DocumentElement->ChildNodes->FindNode(«default»)->ChildNodes->GetNode(item_index)->GetNodeValue());
(*ModuleList)[0].baseaddress = StrToInt(Form1->XMLDocument1->DocumentElement->ChildNodes->FindNode(«default»)->ChildNodes->GetNode(item_index)->Attributes[WideString(«baseaddress»)]);
Form1->XMLDocument1->FileName = «module_list.xml»;
Form1->XMLDocument1->Active = true;
all_modules = SecondLevelNodeAccess->GetCount();
for (i = 0; i <= all_modules; i++) {
if (i >= all_modules) {
MessageBox(NULL, «Модуль не был найден. Версия недоступна», «Error», MB_ICONERROR | MB_OK );
break;
}
if ((*ModuleList)[0].name == AnsiString(ThirdLevelNodeAccess(i)->GetNode(0)->GetNodeValue())) {
(*ModuleList)[0].version_count = ThirdLevelNodeAccess(i)->GetCount() — 1;
for (j = 0; j < (*ModuleList)[0].version_count; j++) {
(*ModuleList)[0].version[j] = new TVersion;
(*ModuleList)[0].version[j]->address = StrToInt(FourthLevelNodeAccess(i, j+1)->GetNode(0)->NodeValue);
(*ModuleList)[0].version[j]->value = StrToInt(FourthLevelNodeAccess(i, j+1)->GetNode(1)->NodeValue);
(*ModuleList)[0].version[j]->type = StrToInt(FourthLevelNodeAccess(i, j+1)->GetNode(2)->NodeValue);
(*ModuleList)[0].version[j]->description = AnsiString(ThirdLevelNodeAccess(i)->GetNode(j+1)->Attributes[WideString(«description»)]);
}
break;
}
}
/*       LOG->Add((*ModuleList)[0].name + AnsiString(" ") + (*ModuleList)[0].baseaddress);
for (i = 0; i < (*ModuleList)[0].version_count; i++) {
LOG->Add((*ModuleList)[0].version[i]->address);
LOG->Add((*ModuleList)[0].version[i]->value);
LOG->Add((*ModuleList)[0].version[i]->type);
}  */
}
//--------------------------------------------------------------
unsigned int _fastcall get_version(unsigned int BaseAddress, unsigned int type) // считываем версию с модуля
{
unsigned short i, j;
unsigned short SHsum; // контрольная сумма
unsigned char* pTarget = new unsigned char[10];
unsigned char* pReceived;
unsigned short MessageSize = 6;
unsigned int version;
ComPort = new TCom(«COM2», 115200);
i = ComPort->link_on();
if(i) {
MessageBox(NULL, AnsiString(i).c_str(), «Ошибка инициализации порта», MB_OK);
return 0;
}
pTarget[0]= 0x31;
pTarget[1]=(unsigned char)(MessageSize); //младший байт
pTarget[2]=(unsigned char)(MessageSize>>8); //старший байт
pTarget[3] = 0x04;
pTarget[4] = (unsigned char) type;
*(int*)(pTarget + 0x05) = BaseAddress;
version = 0;
SHsum=0x0;
for ( i=3; i<=8; i++ ){SHsum+=pTarget[i];}       //подсчёт КС
//       MessageBox(NULL, AnsiString(SHsum).c_str(), «Контрольная сумма», MB_OK);
pTarget[9]=(unsigned char)(SHsum);//младший байт
pTarget[10]=(unsigned char)(SHsum>>8);//старший байт
ComPort->write(pTarget, 3+MessageSize+2);
delete [] pTarget;
Sleep(100);
i = ComPort->read();
if(i>0)
{
//                 MessageBox(NULL, AnsiString(i).c_str(), «Принято байт», MB_OK);
pReceived = ComPort->get_receiver_ptr(); //считываем полученное значение
if ( pReceived[0] != 0x55 || pReceived[1] != 0xAA) {
MessageBox(NULL, pReceived, «Ошибка», MB_OK);
return 0;
}
// наложение масок
switch (type) {
case 1:
version = (unsigned int) (*( char* )(pReceived + 5))&0x000000FF;
break;
case 2:
version = (unsigned int) (*( short* )(pReceived + 5))&0x0000FFFF;
break;
case 4:
version = (unsigned int) *( int* )(pReceived + 5);
break;
default:
version = (unsigned int) (*( short* )(pReceived + 5))&0x0000FFFF;
break;
}
}
ComPort->link_off();
return version;
}
__fastcall Executing::Executing(bool CreateSuspended)// конструктор
: TThread(CreateSuspended)
{
end = false; // метка окончания = ложно
}
//--------------------------------------------------------------
int __fastcall get_correction(PCorrection* CorrectionList) // обработка файла исправлений
{
int     i = 0;
int     j = 0;
int               n = 0;
int     correction_counter = 0; // количество исправлений
FILE*         CorrectFilePtr; // файл с исправлениями
char   tempchar = ' ';
char* tempFile;    //массив под файл с сиправлениями
char   control_buff[20]; // массив знаков препинания
if ((CorrectFilePtr = fopen(«corrections.txt»,«r»)) == NULL) {
return 0;
}
// узнаем размер файла и выделяем временный массив под файл
fseek(CorrectFilePtr,0L,SEEK_END);
n = ftell(CorrectFilePtr);
fseek(CorrectFilePtr,0L,SEEK_SET);
tempFile = new char[n];
//исправляем возможные ошибки пунктуации
while(tempchar == '\n' || tempchar == ' '){
tempchar = fgetc(CorrectFilePtr);
}
tempFile[0] = tempchar;
i = 1;
while (1){
tempchar = fgetc(CorrectFilePtr);
if(tempchar == '\n'){
continue;
}
if(tempchar == ' '){
continue;
}
if(tempchar == '='){
control_buff[j] = tempchar;
j++;
}
if(tempchar == ';'){
control_buff[j] = tempchar;
correction_counter++;
j++;
}
if(tempchar == EOF){
tempFile[i] = tempchar;
control_buff[j] = tempchar;
break;
}
tempFile[i] = tempchar;
i++;
}
//правильно ли расставлены знаки припенания
for (i = 0; i <= j; i++){
if(control_buff[i] == '='){
if(control_buff[i+1] != ';'){
logmsg(«В файле корректировки обнаружена ошибка. Корректировки учтены не будут33»);
return 0;
}
}
if(control_buff[i] == ';'){
if(!(control_buff[i+1] == '=' || control_buff[i+1] == EOF)){
logmsg(«В файле корректировки обнаружена ошибка. Корректировки учтены не будут331»);
return 0;
}
}
}
//       MessageBox(NULL, tempFile,«Пpочитано»,MB_OK);
*CorrectionList = new TCorrection[correction_counter];
//заполянем массив исправлений
tempchar = 0;
i = 0;
n = 0;
while (tempchar != EOF) {
while(tempFile[i] != '=') {
(*CorrectionList)[n].name += tempFile[i++];
}
//                 (*CorrectionList)[n].name[j] = '\0';
i++;
while(tempFile[i] != ';') {
(*CorrectionList)[n].new_name += tempFile[i++];
}
//                 (*CorrectionList)[n].new_name[j] = '\0';
n++;
tempchar = tempFile[++i];
}
/*       for (j = 0; j < correction_counter; j++) {
MessageBox(NULL, (*CorrectionList)[j].name,"",MB_OK);
MessageBox(NULL, (*CorrectionList)[j].new_name,"",MB_OK);
} */
delete [] tempFile;
fclose(CorrectFilePtr);
return correction_counter;
}
//--------------------------------------------------------------void __fastcall Executing::Execute()
{
CoInitialize(NULL);
char                     item_type;
DWORD                       res;
char                     received_data[255];
unsigned int         received_version = 0;
AnsiString           mes;
int                        i, j, index, modules_counter, all_modules, p, param_num;
int                        error = 0;
if(!FileExists(«device_list.xml»)){
MessageBox(NULL, «Файл device_list.xml не был найден », «Ошибка», MB_ICONERROR | MB_OK );
PostMessage(Form1->Handle, WM_CLOSE, 0,0);
return;
}
if(!FileExists(«module_list.xml»)){
MessageBox(NULL, «Файл module_list.xml не был найден », «Ошибка», MB_ICONERROR | MB_OK );
PostMessage(Form1->Handle, WM_CLOSE, 0,0);
return;
}
//       обработка входных параметров
if (ParamCount() == 0) {
MessageBox(NULL, «Не было передано ни одного параметра!», «Ошибка», MB_ICONERROR | MB_OK );
PostMessage(Form1->Handle, WM_CLOSE, 0,0);
return;
}
// получить управление над функциями библиотеки ProgExchCl.dll
res = ProgExchCl_LoadLibrary();
if(res != 0x0)
{
sprintf(received_data, «Ошибка %d при обращении к библиотеке \»ProgExchCl.dll\".", res);
MessageBox(NULL, received_data, «Ошибка», MB_OK);
}
//открытие канала выдачи данных на экран
sprintf(received_data, «PipeDisplay%d», GetCurrentProcessId());
res = mOpen(received_data, &m_Disp);
if(res == 0x0)
{
// перевести вывод в режим отладочной (0x01 0x02) или отчетной (0x01 0x01) информации
received_data[0] = 0x01; received_data[1] = 0x01;
res = mWrite(m_Disp, received_data, 2, &wrtd);
if(res != 0x0)
{
sprintf(received_data, «Ошибка %d при переводе вывода в режим отладочной информации», res);
MessageBox(NULL, received_data, «Ошибка», MB_OK);
logmsg(received_data);
}
Form1->WindowState = wsMinimized;
}
else {
sprintf(received_data, «Ошибка %d при открытии канала выдачи данных на экран», res);
logmsg(AnsiString(received_data));
logmsg(AnsiString(«Режим автономной работы»));
Form1->WindowState = wsNormal;
}
cor_count = get_correction(&Correction);
// открытие XML-файла
Form1->XMLDocument1->FileName = «device_list.xml»;
Form1->XMLDocument1->Active = true;
item_type = DeviceOrModule(ParamStr(1), &index);
// получение списка модулей входящих в состав прибора
    продолжение
--PAGE_BREAK--