БАЛТИЙСКИЙ ГОСУДАРСТВЕННЫЙ ТЕХНИЧЕСКИЙУНИВЕРСИТЕТ «ВОЕНМЕХ»
им. Д.Ф. УСТИНОВА
Отчет
О прохождении преддипломной практики
«Программная документация»
САНКТ-ПЕТЕРБУРГ, 2009 г
Содержание
Цель
Техническое задание
Общие сведения о предприятии
Общие сведения о разработанной программе
Алгоритм программы
Режимы работы программы
Результаты тестирования
Входные параметры
Заключение
Приложение 1 – Исходные текстыпрограммы
Цель
Целью прохождения производственной практики является:подготовка к написанию дипломной работы, сбор материалов к данной работе иполучение практических навыков.
Практические навыки играют определяющую роль впрофессиональной деятельности любого специалиста. Чем больший опыт накопленчеловеком по практическому использованию своих теоретических знаний, темэффективнее работа такого сотрудника.
Подготовка к написанию дипломной работыпредусматривает изучение темы будущей работы, знакомство со всеми ее тонкостямии нюансами. Необходимо составить наиболее полное представление о предметеработы и хорошо ориентироваться в данном вопросе.
На этом этапе также ставится задача ознакомиться соспецификой предприятия, составить базу будущей работы, состоящую из собственныхнаблюдений, материалов и информации, используемых в работе организации.
Техническое задание
Требуется разработать программу контроля версийкомпонент изделий и подготовить к выпуску программную документацию.
Программная документация должна быть выполнена всоответствии с ГОСТ 19.105-78 (ЕСПД. Общие требования к программнымдокументам).
Комплект программного обеспечения должен содержатьописание программы, текст программы и исполняемый модуль.
Программа предназначена для автоматизированнойпроверки версий всех компонентов изделия (модуля или прибора). Программа должнаобеспечивать контроль версии, как отдельных модулей, так и приборов в различнойкомплектации.
Программа должна запускаться с помощью программы MonU«Монитор для сдачи работ» 643.0691.00249-01. Вывод информации долженосуществляться в окно монитора по каналу межпроцессного обмена. Программавзаимодействует с прибором через интерфейс RS-232. Программа может содержатьчасть, исполняемую на приборе, а может взаимодействовать со «Служебнойпрограммой для модуля М207» 643.0691.00255-01. Эталонные значения версийкомпонентов изделий должны храниться в текстовом файле в виде, удобном длячтения и редактирования в текстовом редакторе.
Общий алгоритм работы программы:
1. Программа запускается с помощью скриптапрограммы MonU. Изделие, версии компонентов которого требуется проверить,определяется параметрами командной строки.
2. Программа получает доступ к COM порту (или киному интерфейсу связи с изделием).
3. Подключается к MonU используя каналмежпроцессного обмена.
4. Открывает файл, содержащий эталонные версиикомпонентов изделий.
5. Читает версии из изделия и сравнивает сэталонными. В случае различия, версии выводятся с помощью программы MonU. Вслучае, если версии всех компонентов изделия совпали, программа выводит«Контроль версий произведён. Результат: НОРМА». В случае, если имелиместо расхождения: «Контроль версий произведён. Результат: НЕНОРМА».
6. Программа должна возвращать код результата. 0– НОРМА, -1 – НЕНОРМА.
Входные параметры, пример:
ver_verify.exe M207
ver_verify.exe ПОТОК-3VSBX7
ver_verify.exe БЦВМб134
ver_verify.exe БС12 Общие сведения о предприятии
Акционерное общество «ГРАНИТ-ВТ» было образовано в1992 году на базе коллектива сотрудников научно-исследовательского отдела ЦНИИ«ГРАНИТ».
Основным видом деятельности предприятия были иостаются разработка, производство и поддержка эксплуатации вычислительных ипериферийных электронных модулей и систем на их основе. Основной сферойприменения разрабатываемой аппаратуры являются системы, эксплуатируемые втяжелых условиях, таких как широкий диапазон рабочих температур, повышеннаявлажность окружающей среды, прочие неблагоприятные климатические факторы, атакже повышенные уровни механических воздействий.
Удачным примером работы компании может служитьразработка в 1993-94гг. при содействии сотрудников российского представительствакомпании Intel® вычислительного модуля КРЕДО-486, используемого в настоящиймомент в ряде железнодорожных и авиационных систем.
Отдельным этапом деятельности стала организация в 1994 г. совместно с АО «Гамма» (ныне ООО «Гамма Плюс») и при содействии представительства Intel®регионального центра поддержки разработок на основе элементов программируемойлогики. В рамках этой деятельности более 40 предприятий (в основном –северо-западного региона России) были снабжены начальной версией САПР дляразработки схем на основе программируемой логики, комплектом переводнойлитературы, возможностью программирования базовых PLD-схем, техническимиконсультациями. Со многими участниками работы регионального центра ЗАО«ГРАНИТ-ВТ» поддерживает технические контакты и коммерческую кооперацию и посей день.
В активе предприятия:
— разработка, производство и поддержка в эксплуатацииряда совместимых комплектов электронных модулей на основе магистралей ISA, VMEи CompactPCI;
— разработка локомотивной информационно-управляющейсистемы повышения безопасности движения для модернизации локомотивовОктябрьской железной дороги;
— участие в разработке комплексной бесплатформеннойнавигационной системы для модернизации авионики самолетов гражданской авиации;
— разработка поездной информационно-управляющейсистемы с функцией обеспечения автоведения для высокоскоростной магистралиМосква-Санкт-Петербург.
ЗАО «ГРАНИТ-ВТ» предлагает потребителю рядвычислительных модулей общего назначения, модулей расширения памяти,интерфейсных и системозависимых модулей. Особенно рекомендуются модулирасширения разработки ФГУП ЦНИИ «Гранит» и источники вторичного питанияпроизводства ООО «Авионика-Вист».
Помимо представленной серийно выпускаемой продукциипредприятие радо предложить услуги в области проектирования и производства какэлектронных систем управления любой степени сложности, так и любых их составныхчастей – приборов, модулей, критичного программного обеспечения,контрольно-проверочной аппаратуры.
Можно заказать разработку специализированных модулей«под ключ» или любую составную часть такой разработки:
— разработку схемотехнических решений;
— проектирование логических функций в заданном базисе(программируемые логические микросхемы);
— разработку топологии печатных плат любой степенисложности с организацией при необходимости их производства;
— автоматический и ручной монтаж и ремонт электронныхмодулей практически без ограничений по типу корпусов;
— нанесение полипараксилиленового влагозащитного покрытияна изделия заказчика;
— разработку тестового и функционального программногообеспечения;
— разработку специализированного стендовогооборудования.
За долгие годы разработки специальной управляющейтехники коллектив ЗАО «ГРАНИТ-ВТ» приобрел глубокий опыт созданиявычислительных модулей, приборов и систем, предназначенных для управленияподвижными объектами в реальном времени в тяжелых эксплуатационных условиях(климатические и механические воздействия). Основная предлагаемая ЗАО«ГРАНИТ-ВТ» продукция, в первую очередь, флагманская линия вычислительных ипериферийных модулей, предназначена именно для этого сегмента рынка. Сфераприменения диктует основные технические принципы, которых, на наш взгляд,следует придерживаться при разработке высоконадежной аппаратуры дляответственных применений и которые являются основой технической политики ЗАО«ГРАНИТ-ВТ»:
— ориентация на промышленные стандарты в части общейвычислительной архитектуры, внутренних и внешних интерфейсов, конструкторскихрешений, общего программного обеспечения, стендового оборудования,технологических процессов;
— открытость технических решений, что подразумеваетвозможность, при необходимости, предоставления потребителю всей техническойинформации (схемотехническая и конструкторская документация, исходные текстывстроенного, инструментального и тестового программного обеспечения собственнойразработки). Открытость документации позволяет пользователю провестисертификацию конечной продукции;
— использование элементной базы, удовлетворяющей условиямэксплуатации конечной аппаратуры. Как правило, это компоненты в индустриальномисполнении, в расширенном температурном исполнении, в отдельных обоснованныхслучаях – компоненты, выполненные по военным нормам;
— долгосрочная поддержка воспроизводства(возможность выпуска идентичной аппаратуры в течении длительного срокаэксплуатации систем). Основывается на преимущественном использованиикомпонентов, обладающих долгосрочной поддержкой производителя (long-lifesupport) или являющихся де-факто промышленным стандартом и выпускаемыхнесколькими производителями;
— минимизация энергопотребления за счет использованияпреимущественно микромощных компонентов, постепенного перехода на пониженныеуровни напряжения электропитания, внутримодульного формирования нестандартныхноминалов напряжений электропитания.
— обеспечение гарантированного теплосъема путемиспользования теплопроводящих прокладок, сплошных утолщенных металлизированныхслоев в многослойных печатных платах, кондуктивного отвода тепла на несущиеконструкции через металлические теплостоки и клиновые замки;
— использование влагозащитного покрытия на основеполипараксилилена, обеспечивающего отсутствие “воздушных подушек” подSMD-компонентами и, как следствие, отсутствие открытого конденсата на поверхностипечатной платы и компонентах при термоциклировании;
— использование технических решений, гарантирующихтребуемую устойчивость к механическим воздействиям, – использованиепреимущественно легких компонентов в корпусах для поверхностного монтажа, закреплениекомпонентов при необходимости, отсутствие механически нестойких элементов(панелей под микросхемы, соединителей-джамперов, кнопок, механическихконтакторов и пр.);
— использование ремонтопригодных технологий,обеспечение долгосрочного гарантийного и послегарантийного обслуживания;
— дифференцированный подход к встроенному системному ифункциональному программному обеспечению: возможность разработкиспециализированных программных комплексов для ответственных критичных повремени применений в управляющих системах реального времени, обеспечивающихрестартуемость (восстановление прерванного хода вычислительного процесса)вычислительного процесса при кратковременных отказах электропитания ифункциональных сбоях с сохранением интегральных величин; возможность разработкиминимального программного обрамления для обеспечения программированияфункциональных задач на языке высокого уровня; совместимость с универсальнымиОС реального времени типа VxWorks™, QNX™, ОС2000 и др., подтвержденная опытнымиработами. Общие сведения о разработанной программе
Наименование программы — “Программа проверки версий изделий”.
Обозначение исполняемого файла программы – Version-verifier.exe.
Программа написана на языке C++ – CBuilderверсии 10.0 фирмы Borland Software Corporation для ОС Windows.
Программа производит проверку версий отдельного модуля или версиймодулей входящих в состав прибора по усмотрению пользователя.
Программа располагается и исполняется настендовой ЭВМ.
База эталонов версий создается и хранится вфайлах “device_list.xml” и “module_list.xml”.
Вызов программы осуществляется запускомисполняемого модуля программы средствами операционной системы, либо изкомандной строки с параметрами командной строки.
У программы есть один параметр команднойстроки – наименование изделия.
Пример:
C:\Version-verifier.exe BS12
Или
C:\Version-verifier.exeM207
Черезпараметр командной строки в программу вводится наименование изделия,подлежащего проверке. Так же наименование изделия можно передать через скрипт“Сервисной программы монитор для сдачи работ” 643.0691.00249-01. Подробнее оскриптах “Сервисной программы монитор для сдачи работ” можно прочитать вруководстве программиста 643.0691.00249-01 33 01.
Информацию омодулях программа получает из XML-файлов “device_list.xml”и “module_list.xml”.
Поправки в работу программы можно внести спомощью файла “corrections.txt”.
Программа может быть запущена через“Сервисную программу монитор для сдачи работ” 643.0691.00249-01. В этом случаерезультаты работы программы будут выводиться в окне “Сервисной программымонитор для сдачи работ”. О запуске приложений через “Сервисную программумонитор для сдачи работ” можно прочитать в руководстве программиста643.0691.00249-01 33 01./>/> Алгоритм программы
Параметром командной строки в программупередается наименование изделия, которое необходимо проверить.
Производится поиск наименования изделий вфайле “device_list.xml”. Сначала производится поиск среди тегов “device” (список приборов), если изделие не обнаружено, топоиск продолжается в теге “default” среди тегов “module”(список модулей).
Если изделие найдено, то программа получаеттип изделия (прибор или модуль). Если изделие не найдено, то выводитсясообщение об ошибке.
Если с входными параметрами было полученонаименование модуля, то программа считывает из файла “device_list.xml” базовый адрес модуля поумолчанию.
Затем из файла “module_list.xml” считываются адресарегистров версий, значения версий и разрядность версий соответствующего модуля.
Затем программа считывает фактическиезначения версий модуля и сравнивает их со значениями, считанными из файла “module_list.xml”.При совпадении этих значений программа выдает норму, при несовпадении –ненорму.
Если с входными параметрами было полученонаименование прибора, то программа считывает из файла “device_list.xml” базовые адреса всехмодулей, входящих в состав прибора.
Затем из файла “module_list.xml” считываются адресарегистров версий, значения версий и разрядность версий для каждого модуля,входящего в состав прибора.
Затем программа считывает фактическиезначения версий модулей, входящих в состав прибора, и сравнивает их созначениями, считанными из файла “module_list.xml”. При совпадении этихзначений для каждого модуля программа выдает норму, при несовпадении хотя быдля одного модуля – ненорму./>/>/>/>/>/>/>/>Режимы работы программы
Если программа была запущена “Сервиснойпрограммой монитор для сдачи работ” 643.0691.00249-01, то она будет свернута, ився информация будет выводиться в окне “Сервисной программы монитор для сдачиработ”. После выполнения проверки, программа будет завершена самостоятельно.
Если программа была запущена из команднойстроки независимо от “Сервисной программы монитор для сдачи работ”, то всяинформация будет выводиться в текстовом поле окна программы. После выполненияпроверки, программа останется открытой./>Результатытестирования
При проверкеверсий прибора фиксируется, результат проверки для каждого модуля, входящего всостав прибора. Если проверка всех модулей завершилась с результатом НОРМА,общий результат – НОРМА. Если проверка хотя бы одного модуля завершилась срезультатом НЕНОРМА, то общий результат — НЕНОРМА.
При проверкеверсий отдельного модуля, результат НОРМА — если проверка завершилась успешно;и НЕНОРМА – если проверка завершилась неудачно.
/>Входные параметрыСтруктура XML-файла“device_list.xml”
Файл “device_list.xml”состоит из тегов “device” и тега “default”.
Тег “device”имеет атрибут “name”, в котором содержится название прибора,соответствующего этому тегу. Внутри тегов “device”содержатся теги “module”, которые имеют атрибут “baseaddress”,содержащий базовый адрес модуля в приборе. Внутри тега “module”указывается название модуля.
Тег “default” содержит в себе теги “module”. Тег “module” имеет один атрибут “baseaddress”, в котором содержится базовый адрес модуля по умолчанию. Внутри тега “module”указывается название модуля.Структура XML-файла“module_list.xml”
Файл “module_list.xml”состоит из тегов “module”.
Тег “module”содержит в себе тег “name” и теги “version”. Тег “name”содержит в себе название модуля. Тег “version” имеет один атрибут “description”, в котором содержится информация о версии, описываемой соответствующимтегом “version”. Тег “version” содержит в себе теги “address” (адрес регистра версии модуля), “value” (значениеверсии модуля) и “type” (разрядность версии модуля).
При выпускеновой версии модуля, тег “name” в соответствующем теге “module”дополняется датой выпуска следующей версии. Затем создается новый тег “module”с наименованием модуля и обновленными значениями версий в теге “version”./>СтруктураTXT-файла “corrections.txt”
Если есть необходимость проверить прибор сболее ранними версиями каких-либо модулей, входящих в его состав, составляетсяфайл поправок “corrections.txt”.Структура файла “corrections.txt”по п. 0.
Если в папке с программой содержится файл “corrections.txt”, то программапроизводит обработку этого файла.
В процессе обработки заполняется массив поправок, содержащих дванаименования модулей: с поздней версией и с более ранней версией.
Файл “corrections.txt” предназначен для внесения поправок в работупрограммы.
Файл состоитиз записей вида:
=;
Здесь “name” –наименование модуля, который необходимо проверить с особыми значениями версий;“new_name” – наименованиемодуля в файле “module_list.txt” с особыми значениями версий.
Заключение
В ходе преддипломной практики (в период с 15 декабря2008 по 15 февраля 2009 г.) мною были выполнены поставленные предварительнозадачи:
— получены практические навыки работы в коллективеинженеров,
— разработана программа проверки версий компонентизделий,
— подготовлена к выпуску программная документация.
Приложение 1 – Исходныетексты программы
//--------------------------------------------------------------
#ifndef Unit2H
#define Unit2H
//--------------------------------------------------------------#include
//--------------------------------------------------------------classExecuting: public TThread
{
private:
protected:
void __fastcall Execute();
public:
bool end;
__fastcall Executing(bool CreateSuspended);
};
//--------------------------------------------------------------#endif
//--------------------------------------------------------------
#include
#pragma hdrstop
#include «Unit1.h»
#include «Unit2.h»
#include
#include «ProgExchCl_b.h»
#include «Udevices.h»
#define SecondLevelNodeAccessForm1->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
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
if(AnsiString(SecondLevelNodeAccess->FindNode(«default»)->ChildNodes->GetNode(i)->Text)== Parameter){
*item_index = i;
return 2;
}
}
return 0;
}
//--------------------------------------------------------------
void __fastcall GetModuleList(AnsiStringParameter, 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 = newTModule[*modules_counter]; // выделяем память под массив модулей
for (i = 0; i
if(cor_count)
{
for(j = 0; 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
for (j = 0; j
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[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(AnsiStringParameter, 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
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[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
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(unsignedint BaseAddress, unsigned int type) // считываем версию с модуля
{
unsigned short i, j;
unsigned short SHsum; // контрольная сумма
unsigned char* pTarget = new unsignedchar[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]=(unsignedchar)(MessageSize>>8); //старший байт
pTarget[3] = 0x04;
pTarget[4] = (unsigned char) type;
*(int*)(pTarget + 0x05) = BaseAddress;
version = 0;
SHsum=0x0;
for ( i=3; i
// MessageBox(NULL,AnsiString(SHsum).c_str(), «Контрольная сумма», MB_OK);
pTarget[9]=(unsigned char)(SHsum);//младший байт
pTarget[10]=(unsignedchar)(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(boolCreateSuspended)// конструктор
: 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
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 = newTCorrection[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
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);
// получение списка модулей входящих в состав прибора
if (item_type == 0){
MessageBox(NULL, «Прибор или модуль не былнайден», «Ошибка», MB_ICONERROR | MB_OK );
PostMessage(Form1->Handle, WM_CLOSE,0,0);
return;
}
if (item_type == 1) {
GetModuleList(ParamStr(1), &Module,index, &modules_counter);
if(index == -1) {
PostMessage(Form1->Handle, WM_CLOSE,0,0);
return;
}
mes = AnsiString(«Проверка версии прибора: „) + ParamStr(1);
}
if (item_type == 2) {
GetModule(ParamStr(1), &Module, index);
if(index == -1) {
PostMessage(Form1->Handle, WM_CLOSE,0,0);
return;
}
mes = AnsiString(“Проверка версии модуля:») + ParamStr(1);
modules_counter = 1;
}
msg(" ");
msg(" ");
msg(mes.c_str());
logmsg(mes.c_str());
// перевести вывод в режим отладочной (0x01 0x02) илиотчетной (0x01 0x01) информации
received_data[0] = 0x01; received_data[1] =0x02;
res = mWrite(m_Disp, received_data, 2,&wrtd);
if(res != 0x0)
{
// sprintf(received_data, «Ошибка%d при переводе вывода в режим отладочной информации», res);
// MessageBox(NULL,received_data, «Ошибка», MB_OK);
}
// вывод результатов тестирования по каждому модулю
for (i = 0; i
// название модуля
msg(" ");
msg(Module[i].name.c_str());
logmsg(" ");
logmsg(Module[i].name.c_str());
for (j = 0; j
received_version = get_version( (unsignedint) (Module[i].baseaddress + Module[i].version[j]->address),Module[i].version[j]->type);
// если версии совпадают, то НОРМА, если не совпадают,то НЕНОРМА
if(received_version ==Module[i].version[j]->value){
mes =AnsiString(" ") +Module[i].version[j]->description + AnsiString(" 0x") +IntToHex((int) Module[i].version[j]->value, Module[i].version[j]->type) +AnsiString(" :HOPMA ");
msg(mes.c_str());
logmsg(mes.c_str());
}
else {
mes =AnsiString(" ") +Module[i].version[j]->description + AnsiString(" 0x") +IntToHex((int) received_version, Module[i].version[j]->type) +AnsiString(" :HEHOPMA ") + AnsiString("(должно быть0x") + IntToHex((int) Module[i].version[j]->value,Module[i].version[j]->type) + AnsiString(")");
msg(mes.c_str());
logmsg(mes.c_str());
error+=1;
}
}
}
// перевести вывод в режим отладочной (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);
}
// общий результат тестирования
if(error) {
msg(" ");
msg(«Результат: НЕНОРМА»);
logmsg(" ");
logmsg(«Результат: НЕНОРМА»);
}
else {
msg(" ");
msg(«Результат: НОРМА»);
logmsg(" ");
logmsg(«Результат: НОРМА»);
}
// освобождаем динамически выделенную память
if (item_type == 1) {
delete [] Module;
}
else delete Module;
delete [] Correction;
if(mClose != NULL)
{
// отключить каналы обмена
mClose(m_Disp);
}
ProgExchCl_FreeLibrary();
CoUninitialize();
PostMessage(Form1->Handle, WM_CLOSE,0,0);
}
//--------------------------------------------------------------
#ifndef Unit1H
#define Unit1H
//--------------------------------------------------------------#include
#include
#include
#include
#include
#include
#include
#include
//--------------------------------------------------------------
typedef struct _SVersion{
unsigned int address; //адрес регистра версии
unsigned int value; //считанноезначение версии
unsigned int type; //разрядность версии
AnsiString description;//описание версии
} TVersion,* PVersion;
typedef struct _SModule{
AnsiString name; //имя модуля
unsigned int baseaddress; //базовый адрес модуля
int version_count;//количествоверсий у модуля
PVersion version[10]; //массив версий модуля
} TModule,* PModule;
typedef struct _SCorrection{
AnsiString name;
AnsiString new_name;
} TCorrection,* PCorrection;
class TForm1: public TForm
{
__published: // IDE-managedComponents
TXMLDocument *XMLDocument1;
TMemo *LogText;
void __fastcall FormActivate(TObject*Sender);
void __fastcall FormClose(TObject *Sender,TCloseAction &Action);
private: // User declarations
public: // Userdeclarations
__fastcall TForm1(TComponent* Owner);
};
//--------------------------------------------------------------
extern PACKAGE TForm1 *Form1;
//--------------------------------------------------------------
#endif
//--------------------------------------------------------------
#include
#pragma hdrstop
#include «Unit1.h»
#include «Unit2.h»
#include
//--------------------------------------------------------------#pragmapackage(smart_init)
#pragma resource "*.dfm"
Executing *Thread;
TForm1 *Form1;
tagMSG lpMsg;
//--------------------------------------------------------------__fastcallTForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//--------------------------------------------------------------
void __fastcallTForm1::FormActivate(TObject *Sender)
{
Thread = new Executing(FALSE); // запускаем поток
}
//--------------------------------------------------------------
void __fastcall TForm1::FormClose(TObject*Sender, TCloseAction &Action)
{
Thread->WaitFor();
delete (Thread);
}
//--------------------------------------------------------------
//---------------------------------------------------------------------------
#ifndef UdevicesH
#define UdevicesH
#include
//#include «U_MK_pipe.h»
#include
//--------------------------------------------------------------//Абстрактный класс, реализующий базовые функции любого устройства
class TDevFather: public TObject
{
__published:
private: // User declarations
protected:
bool active;
char receiver[0x1000];//априорно выделено 4кб буфера,приготовлены для отправки классу монитору
int receiver_size;//размер реально принятых байт вбуфере
public:
virtual __fastcall TDevFather();
virtual __fastcall ~TDevFather();
virtual int __fastcall link_on();
virtual int __fastcall link_off();
//функции для работы с мостом в целях ввода/вывода
//чтение из буфера устройтва
virtual int __fastcall scan();//Возвращает признаксостояния устройства
virtual int __fastcall read();//Если положительноечисло, то это число пинятых байт, если отрицательное, то это код ошибки
virtual char* __fastcall get_receiver_ptr();//
//отправить данные
virtual int __fastcall write(char* chs, intsize);//передача символов/байтов на устройство
//запись в буфер
//virtual int __fastcall add_to_sender(char* chs, intsize);//передача символов/байтов в передающий буфер
};
//--------------------------------------------------------------
class TCom: public TDevFather
{
__published:
private: // User declarations
protected:
AnsiString comname;
int baudrate;
HANDLE com_hndl;
DCB st_dcb;
public:
virtual __fastcall TCom(char* comname, intbaudrate);
virtual __fastcall ~TCom();
int __fastcall link_on();
int __fastcall link_off();
//функции для работы с мостом в целях ввода/вывода
//чтение из буфера устройтва
int __fastcall scan();//Возвращает признак состоянияустройства
int __fastcall read();//Если положительное число, тоэто число пинятых байт, если отрицательное, то это код ошибки
//virtual char* __fastcallget_receiver_ptr();// метод наследуется без изменения
//отправить данные
virtual int __fastcall write(char* chs, int size);//передачасимволов/байтов на устройство
//запись в буфер
//virtual int __fastcall add_to_sender(char* chs, intsize);//передача символов/байтов в передающий буфер
void __fastcall set_comname(AnsiStringcomname);
void __fastcall set_baudrate(int baudrate);
AnsiString __fastcall get_comname();
int __fastcall get_baudrate();
};
//--------------------------------------------------------------#endif
//--------------------------------------------------------------
#pragma hdrstop
#include
#include
#include «Udevices.h»
//--------------------------------------------------------------__fastcallTDevFather::TDevFather(){}
//--------------------------------------------------------------__fastcallTDevFather::~TDevFather(){}
//--------------------------------------------------------------int__fastcall TDevFather::link_on()
{ return 0; }
//--------------------------------------------------------------int__fastcall TDevFather::link_off()
{ return 0; }
//--------------------------------------------------------------//функции для работы с мостом
int __fastcall TDevFather::scan()//Возвращает признаксостояния устройства
{
//
return receiver_size;
}
//---------------------------------------------------------------------------
int __fastcall TDevFather::read()//Если положительноечисло, то это число принятых байт, если отрицательное, то это код ошибки
{
//
return receiver_size;
}
//---------------------------------------------------------------------------
char* __fastcallTDevFather::get_receiver_ptr()//
{
return receiver;
}
//---------------------------------------------------------------------------
int __fastcall TDevFather::write(char* chs,int size)
{
return size;
}
//---------------TCom-------------------------------------------__fastcallTCom::TCom(char* comname, int baudrate)
{
//
TCom::comname=comname; //=«COM1»;
TCom::baudrate=baudrate; //=115200;
active=false;
}
//--------------------------------------------------------------__fastcallTCom::~TCom()
{
//
if(active)
{
link_off();
}
}
//--------------------------------------------------------------int__fastcall TCom::link_on()
{
//
if (!active)
{
com_hndl=CreateFile(comname.c_str(),GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0);
if (com_hndl == INVALID_HANDLE_VALUE)
{
//MessageBoxA(0,«Invalid handlevalue»,«Simple_COM», MB_OK);
active=false;
return -1;
}
//настройка параметров соединения
st_dcb.DCBlength= sizeof(DCB);
st_dcb.Parity=NOPARITY; //NOPARITY,ODDPARITY, MARKPARITY , EVENPARITY
st_dcb.StopBits=ONESTOPBIT; //ONESTOPBIT,ONE5STOPBITS , TWOSTOPBITS
st_dcb.ByteSize=8; //4-8
st_dcb.BaudRate=baudrate; //CBR_115200
SetCommState(com_hndl, &st_dcb);
if ( com_hndl == INVALID_HANDLE_VALUE)
{
//MessageBoxA(0,«Invalid handlevalue»,«Simple_COM», MB_OK);
active=false;
return -1;
}
SetupComm(com_hndl, 40000, 40000);//размеры банков
if (com_hndl == INVALID_HANDLE_VALUE)
{
//MessageBoxA(0,«Invalid handlevalue»,«Simple_COM», MB_OK);
active=false;
return -1;
}
SetCommMask(com_hndl,EV_RXCHAR);
if (com_hndl == INVALID_HANDLE_VALUE)
{
//MessageBoxA(0,«Invalid handlevalue»,«Simple_COM», MB_OK);
active=false;
return -1;
}
active=true;
};
if (!active)
{
return -1;
}else{
return 0;
}
}
//--------------------------------------------------------------int__fastcall TCom::link_off()
{
//
if (active)
{
active=false;
CloseHandle(com_hndl);
return 0;
}
else
{
active=false;
return -1;
}
}
//--------------------------------------------------------------int__fastcall TCom::scan()//Возвращает признак состояния устройства
{
COMSTAT st;
unsigned long Err;
if (active)
{
if ( ClearCommError(com_hndl, &Err,&st) )
{
return st.cbInQue;
}
else
{
//MessageBoxA(0,«Com scanerror»,«Simple_COM», MB_OK);
return -1;
}
}
else
{
return 0;
}
}
//--------------------------------------------------------------int__fastcall TCom::read()//Если положительное число, то это число пинятых байт,если отрицательное, то это код ошибки
{
COMSTAT st;
unsigned long Err;
unsigned long readed_bytes;
//
readed_bytes=0;
if (active)
{
if ( ClearCommError(com_hndl, &Err,&st) )
{
if ( (Err & CE_BREAK)>0 )
{
//MessageBoxA(0,«Com read error:CE_BREAK»,«Simple_COM», MB_OK);
return -2;
}
if ( 0x1000>st.cbInQue )
{
if (! ReadFile(com_hndl, receiver,st.cbInQue, &readed_bytes, NULL) )
{
//MessageBoxA(0,«Com read error:ReadFile 1»,«Simple_COM», MB_OK);
return -3;
}
}
else
{
if (! ReadFile(com_hndl, receiver, 0x1000,&readed_bytes, NULL) )
{
//MessageBoxA(0,«Com read error:ReadFile 2»,«Simple_COM», MB_OK);
return -4;
}
}
}
else
{
//MessageBoxA(0,«0шибка сканирования устройства COM»,«Simple_COM», MB_OK);
}
}
return (int)readed_bytes;
}
//--------------------------------------------------------------int__fastcall TCom::write(char* chs, int size)
{
unsigned long sended;
//
sended=0;
if (! WriteFile(com_hndl, chs, (unsignedlong)size, &sended, NULL) )
{//ошибка
//MessageBoxA(0, «Ошибка передачи данных»,«Simple_COM», MB_OK);
return -1;
}
return (int)sended;
}
//--------------------------------------------------------------
void __fastcallTCom::set_comname(AnsiString comname){}
void __fastcall TCom::set_baudrate(intbaudrate){}
AnsiString __fastcall TCom::get_comname()
{//
return comname;
}
//--------------------------------------------------------------int__fastcall TCom::get_baudrate()
{//
return baudrate;
}