ModBus Slave RTU/ASCII без смс и регистрации

//////////////////////////////////////////////////////////////////// //    Асинхронная обработка сообщение ModBus v2   // //    Автор - Iван                                                      // /////////////////////////////////////////////////////////////////// #ifndef __MODBUS_H #define __MODBUS_H  #include "main.h"  /////////////////////////////////////////////////////////////////////////////// //Настройки МодБас //Данные, регистры Модбас  #define ModBusUseGlobal (0) //Использовать глобальные входы/выходы, входные/выходные регистры //Функции протокола Модбас #define ModBusUseFunc1  (0) //Использовать функцию 1  - чтение статуса Coils (дискретных выходных битов) #define ModBusUseFunc2  (0) //Использовать функцию 2  - чтение статуса дискретных входов #define ModBusUseFunc3  (1) //Использовать функцию 3  - чтение значения выходных регистров #define ModBusUseFunc4  (0) //Использовать функцию 4  - чтение значения входных регистров #define ModBusUseFunc5  (0) //Использовать функцию 5  - запись выходного бита #define ModBusUseFunc6  (1) //Использовать функцию 6  - запись выходного регистра #define ModBusUseFunc15 (0) //Использовать функцию 15 - запись нескольких выходных битов #define ModBusUseFunc16 (1) //Использовать функцию 16 - запись нескольких выходных регистров //Адрес устройства #define ModBusID (1) //Адрес на шине МодБас #define ModBusID_FF (255) //Адрес на шине МодБас, на который отвечает всегда //Таймауты #define ModBusMaxPause (5)//Пауза между символами, для определения начала пакета [mS],  #define ModBusMaxPauseResp (2) //Пауза между запросом Мастера и ответом Слайва [mS] //Длинна пакетов #define ModBusMaxPaketRX (96)//Максимальный размер принимаемого пакета <127 //Дискретные входы #define ModBusMaxInBit (0) //Количество дискретных входов  #define ModBusMaxInBitTX (8) //Максимальное количество дискретных входов при передаче пакета  #define ModBusMaxInByte ((ModBusMaxInBit+7)/8) //Количество дискретных входов в байтах //Дискретные выходы #define ModBusMaxOutBit (0) //Количество дискретных выходов #define ModBusMaxOutByte ((ModBusMaxOutBit+7)/8) //Количество дискретных выходов в байтах #define ModBusMaxOutBitTX (8) //Максимальное количество дискретных выходов в передаваемом пакете  #define ModBusMaxOutBitRX (8) //Максимальное количество дискретных выходов доступное для груповой установки //Регистры доступные для чтения #define ModBusMaxInReg (0) //Количество входных регистров (регистры только для чтения) #define ModBusMaxInRegTX (24) //Максимальное количество входных регистров в передаваемом пакете  //Регистры доступные для чтения-записи #define ModBusMaxOutReg (48) //Количество выходных регистров #define ModBusMaxOutRegTX (32)//Максимальное количество выходных регистров в передаваемом пакете  #define ModBusMaxOutRegRX (32)//Максимальное количество выходных регистров  доступное для груповой установки //////////////////////////////////////////////////////////////////////////////// //Опорные функции, связь с системой //Системный таймер, инкрементируется каждую миллисекунду #define ModBusSysTimer TimingDelay //Запись байта в поток последовательного порта - void ModBusPUT(unsigned char A) #define ModBusPUT(A) PutFifo0(A)  //Чтение байта из потока последовательного порта, - unsigned short ModBusGET(void) //Если нет данных возвращает 0х0000, иначе возвращает 0х01ХХ #define ModBusGET()  Inkey16Fifo0()  ////////////////////////////////////////////////////////////////////////////////  //Инициализация  void ModBusIni(void);  //Функция обработки Сообщений модбас RTU //Работает совместно с системным таймером  //Использует макросы ModbusPUT(A) ModbusGET() void ModBusRTU(void);  //Функция обработки Сообщений модбас ASCII //Работает совместно с системным таймером  //Использует макросы ModbusPUT(A) ModbusGET() void ModBusASCII(void);  //Заполнение регистров Модбас //перенос данных из программных переменных в регистры МодБас void Prg2ModBusOutBit(void); void Prg2ModBusInBit(void); void Prg2ModBusOutReg(void); void Prg2ModBusInReg(void); //Считывание регистров Модбас //перенос данных из регистров МодБас в программные переменные void ModBus2PrgOutBit(void); void ModBus2PrgOutReg(void);  #pragma pack(push,1) //Тип данных для работы с дискретными входами/выходами typedef union   {   unsigned char byte;   struct     {     unsigned char bit0:1;     unsigned char bit1:1;     unsigned char bit2:1;     unsigned char bit3:1;     unsigned char bit4:1;     unsigned char bit5:1;     unsigned char bit6:1;     unsigned char bit7:1;     };   }   ModBusBit_t; #pragma pack(pop)    #ifdef __MODBUS2PRG_C #if ModBusMaxInBit!=0 ModBusBit_t ModBusInBit[ModBusMaxInByte]; //массив дискретных входов #endif #if ModBusMaxOutBit!=0 ModBusBit_t ModBusOutBit[ModBusMaxOutByte]; //массив дискретных выходов #endif #if ModBusMaxInReg!=0 unsigned short ModBusInReg[ModBusMaxInReg]; //массив входных регистров #endif #if ModBusMaxOutReg!=0 unsigned short ModBusOutReg[ModBusMaxOutReg]; //массив выходных регистров #endif #else  #if ModBusUseGlobal!=0 || defined(__MODBUS_C) #if ModBusMaxInBit!=0 extern ModBusBit_t ModBusInBit[ModBusMaxInByte]; //массив дискретных входов #endif #if ModBusMaxOutBit!=0 extern ModBusBit_t ModBusOutBit[ModBusMaxOutByte]; //массив дискретных выходов #endif #if ModBusMaxInReg!=0 extern unsigned short ModBusInReg[ModBusMaxInReg]; //массив входных регистров #endif #if ModBusMaxOutReg!=0 extern unsigned short ModBusOutReg[ModBusMaxOutReg]; //массив выходных регистров #endif #endif//#if ModBusUseGlobal!=0 #endif//#ifdef __MODBUS2PRG_C #endif//#ifndef __MODBUS_H 

#define __MODBUS_C #include "modbus.h"  static unsigned char PaketRX[ModBusMaxPaketRX];//массив для сохранения пакета static unsigned char UkPaket;//указатель в массиве, текущий принятый символ  static unsigned long TimModbus; //время приема пакета по системному таймеру static unsigned short CRCmodbus;//текущий CRC static unsigned char Sost;//состояние 0/1 прием/передача  //Инициализация  void ModBusIni(void)   {   TimModbus=ModBusSysTimer;//запомнить таймер   UkPaket=0;//сбросить указатель пакета   CRCmodbus=0xFFFF; //установить начальное значение CRC   //Инициализация регистров МодБас #if ModBusMaxOutBit!=0   Prg2ModBusOutBit(); #endif   #if ModBusMaxInBit!=0     Prg2ModBusInBit(); #endif   #if ModBusMaxOutReg!=0     Prg2ModBusOutReg(); #endif   #if ModBusMaxInReg!=0   Prg2ModBusInReg(); #endif     return;   }  //Функция вычисления CRC static inline unsigned short CRCfunc(unsigned short inCRC, unsigned char in)   {   inCRC=inCRC^in;   for(int j=0;j<8;j++){if(inCRC&1){inCRC=(inCRC>>1)^0xA001U;}else {inCRC=inCRC>>1;}}   return inCRC;   }  //Функция обработки Сообщений модбас void ModBusRTU(void)   {   if(Sost==0)     {//Состояние прием     while(!0)       {//Цикл приема символов       unsigned short Tmp=ModBusGET(); //читаем символ из входного потока       if(Tmp==0) return; //если нет данных - возврат        //символ принят       Tmp=Tmp&0xFF;//отбрасываем признак приема байта       //Проверка временного интервала между символами       if((ModBusSysTimer-TimModbus)>ModBusMaxPause)         {//превышен таймаут, начинаем прием нового пакета         PaketRX[0]=Tmp;//сохранить принятый символ в буфер приема         UkPaket=1;//установить указатель пакета         TimModbus=ModBusSysTimer;//сбросить таймер         //вычисление CRC         CRCmodbus=CRCfunc(0xFFFF,Tmp);         continue;//повторный запрос символа         }       else         {//таймаут не превышен, принимаем уже начатый пакет         TimModbus=ModBusSysTimer;//сбросить таймер         PaketRX[UkPaket]=Tmp;//сохранить принятый символ         UkPaket++;//инкремент указателя пакета         if(UkPaket==ModBusMaxPaketRX)//проверяем на длину пакета           {//буфер пакета переполнился           UkPaket=0;//сбросить указатель пакета           CRCmodbus=0xFFFF; //установить начальное значение CRC           return;//ошибка, повторный запрос символа требуется           }         //вычисление CRC         CRCmodbus=CRCfunc(CRCmodbus,Tmp);         }       //Если принято мало данных       if(UkPaket<8) continue; //повторный запрос символа       //проверка на принятие пакета       if(CRCmodbus==0)          {//проверка на длинные пакеты         if(PaketRX[1]==15 || PaketRX[1]==16)           {//если длинные команды (15,16) , проверяем "Счетчик байт"           if((PaketRX[6]+9)!=UkPaket) continue;           }         break; //Ура! Пакет принят!!!         }       }     //////////////////////////////////////////////////////////////////////////////     //                         Ура! Пакет принят!!!     /////////////////////////////////////////////////////////////////////////////     UkPaket=0;//сбросить указатель пакета          //проверка адреса     if((PaketRX[0]!=ModBusID)&&(PaketRX[0]!=ModBusID_FF))       {//Не наш адрес       CRCmodbus=0xFFFF; //установить начальное значение CRC       return;//повторный запрос не требуется       }                //переходим в состояние передача ответа     Sost=!0; #if ModBusMaxPauseResp!=0       return;//повторный запрос не требуется #endif      }      /////////////////////////////////////////////////////////////////////////////    if(Sost!=0  #if ModBusMaxPauseResp!=0           && (ModBusSysTimer-TimModbus)>=ModBusMaxPauseResp #endif           )     {//Состояние передача ответа     Sost=0;     /////////////////////////////////////////////////////////////////////////////         //                       обработка команд                                  //     /////////////////////////////////////////////////////////////////////////////     //Код функции 01 - чтение статуса Coils (дискретных выходных битов).      /*Сообщение-запрос содержит адрес начального бита и количество битов для чтения.      Биты нумеруются начиная с 0.      В сообщении-ответе каждое значение переменной передается одним битом,     то есть в одном байте пакуется статус 8 битов переменных.      Если количество их не кратно восьми, остальные биты в байте заполняются нулями.      Счетчик вмещает количество байт в поле данных.     01 Чтение статуса выходов            ОПИСАНИЕ            Читает статуса ON/OFF дискретных выходов в подчиненном.            ЗАПРОС            Запрос содержит адрес начального выхода и количество выходов для чтения.            Выхода адресуются начиная с нуля: выхода 1-16 адресуются как 0-15.           Ниже приведен пример запроса на чтение выходов 20-56 с подчиненного устройства 17.            Имя поля						Пример                                                                   (Hex)            Адрес подчиненного					11	0           Функция						01	1           Начальный адрес Hi					00	2           Начальный адрес Lo					13	3           Количество Hi						00	4           Количество Lo						25	5           Контрольная сумма (CRC или LRC)			--            ОТВЕТ            Статус выходов в ответном сообщении передается как один выход на бит.           Если возвращаемое количество выходов не кратно восьми, то оставшиеся биты в последнем байте сообщения будут установлены в 0.            Счетчик байт содержит количество байт передаваемых в поле данных.            Имя поля						Пример                                                                   (Hex)            Адрес подчиненного					11	0           Функция						01	1           Счетчик байт						05	2           Данные(Выхода 27-20)					CD	3           Данные(Выхода 35-28)					6B	4           Данные(Выхода 43-36)					B2	5           Данные(Выхода 51-44)					0E	6           Данные(Выхода 56-52)					1B	7           Контрольная сумма (CRC или LRC)			--     */ #if ModBusUseFunc1!=0            if(PaketRX[1]==0x01)       {       //вычисление адреса запрашиваемых бит       unsigned short AdresBit=(((((unsigned short)PaketRX[2])<<8)|(PaketRX[3])));       //вычисление количества запрашиваемых бит       unsigned short KolvoBit=((((unsigned short)PaketRX[4])<<8)|(PaketRX[5]));       //если неправильный адрес и количество       if((AdresBit+KolvoBit)>(ModBusMaxOutBit) || KolvoBit>ModBusMaxOutBitTX || KolvoBit==0)         {//неправильный адрес и количество         CRCmodbus=0xFFFF; //установить начальное значение CRC         return;//повторный запрос не требуется         }       Prg2ModBusOutBit();//Заполнение регистров Модбас (GlobalDate->ModBus)       //формирование пакета ответа       //адрес       ModBusPUT(PaketRX[0]);       CRCmodbus=CRCfunc(0xFFFF,PaketRX[0]);       //код команды           ModBusPUT(1);       CRCmodbus=CRCfunc(CRCmodbus,1);       //количества полных байт       ModBusPUT((KolvoBit+7)>>3);       CRCmodbus=CRCfunc(CRCmodbus,((KolvoBit+7)>>3));       //копирование битов в пакет ответа       unsigned char TxByte=0;//текущий байт       unsigned char Bit=AdresBit&7;//указатель бит в ModBusOutBit[]       AdresBit=AdresBit>>3;//указатель байт ModBusOutBit[]       //копирование из регистра ModBusOutBit[] в пакет       int i=0;       while(!0)         {         if((ModBusOutBit[AdresBit].byte)&(1<<Bit))           {           TxByte=TxByte|(1<<(i&7));           }         //инкрементруем указатели          Bit++;         if(Bit==8){Bit=0;AdresBit++;}         i++;         if((i&7)==0)           {           ModBusPUT(TxByte);           CRCmodbus=CRCfunc(CRCmodbus,TxByte);           TxByte=0;           if(i==KolvoBit) break; else continue;           }         if(i==KolvoBit)            {           ModBusPUT(TxByte);           CRCmodbus=CRCfunc(CRCmodbus,TxByte);           break;           }         }       ModBusPUT(CRCmodbus);       ModBusPUT(CRCmodbus>>8);       //конец       CRCmodbus=0xFFFF; //установить начальное значение CRC       return;//повторный запрос не требуется        } #endif         /////////////////////////////////////////////////////////////////////////////     //Код функции 2 - чтение статуса дискретных входов     /*02 Read Input Status            ОПИСАНИЕ            Чтение ON/OFF состояния дискретных входов (ссылка 1Х) в пдчиненном.            ЗАПРОС            Запрос содержит номер начального входа и количество входов для чтения. Входа адресуются начиная с 0.           Ниже приведен пример запроса на чтение входов 10197-10218 с подчиненного устройства 17.                    Запрос            Имя поля						Пример                                                                   (Hex)            Адрес подчиненного					11	0           Функция						02	1           Начальный адрес ст.					00	2           Начальный адрес мл.					C4	3           Кол-во входов ст.					00	4           Кол-во входов мл.					16	5           Контрольная сумма					--            ОТВЕТ            Статус входов в ответном сообщении передается как один выход на бит.           Если возвращаемое количество входов не кратно восьми, то оставшиеся биты в последнем байте сообщения будут установлены в 0.            Счетчик байт содержит количество байт передаваемых в поле данных.            Имя поля						Пример                                                                   (Hex)            Адрес подчиненного					11	0           Функция						01	1           Счетчик байт						03	2           Данные(Входы 10204-10197)				AC	3           Данные(Входы 10212-10205)				DB	4           Данные(Входы 10218-10213)				35	5           Контрольная сумма (CRC или LRC)			--       */ #if ModBusUseFunc2!=0          if(PaketRX[1]==0x02)       {       //вычисление адреса запрашиваемых бит       unsigned short AdresBit=(((((unsigned short)PaketRX[2])<<8)|(PaketRX[3])));       //вычисление количества запрашиваемых бит       unsigned short KolvoBit=((((unsigned short)PaketRX[4])<<8)|(PaketRX[5]));       //если неправильный адрес и количество       if((AdresBit+KolvoBit)>(ModBusMaxInBit) || KolvoBit>ModBusMaxInBitTX || KolvoBit==0)         {//неправильный адрес и количество         CRCmodbus=0xFFFF; //установить начальное значение CRC         return;//повторный запрос не требуется         }       Prg2ModBusInBit();//Заполнение регистров Модбас (GlobalDate->ModBus)       //формирование пакета ответа       //адрес       ModBusPUT(PaketRX[0]);       CRCmodbus=CRCfunc(0xFFFF,PaketRX[0]);       //код команды           ModBusPUT(2);       CRCmodbus=CRCfunc(CRCmodbus,2);       //количества полных байт       ModBusPUT((KolvoBit+7)>>3);       CRCmodbus=CRCfunc(CRCmodbus,((KolvoBit+7)>>3));       //копирование битов в пакет ответа       unsigned char TxByte=0;//текущий байт       unsigned char Bit=AdresBit&7;//указатель бит        AdresBit=AdresBit>>3;//указатель байт        //копирование из регистра ModBusInBit[] в пакет       int i=0;       while(!0)         {         if((ModBusInBit[AdresBit].byte)&(1<<Bit))           {//устанавливаем бит в пакете           TxByte=TxByte|(1<<(i&7));           }         //инкрементруем указатели          Bit++;         if(Bit==8){Bit=0;AdresBit++;}         i++;         if((i&7)==0)           {           ModBusPUT(TxByte);           CRCmodbus=CRCfunc(CRCmodbus,TxByte);           TxByte=0;           if(i==KolvoBit) break; else continue;           }         if(i==KolvoBit)           {           ModBusPUT(TxByte);           CRCmodbus=CRCfunc(CRCmodbus,TxByte);           break;           }         }       ModBusPUT(CRCmodbus);       ModBusPUT(CRCmodbus>>8);       //конец       CRCmodbus=0xFFFF; //установить начальное значение CRC       return;//повторный запрос не требуется       } #endif         /////////////////////////////////////////////////////////////////////////////     //Код функции 03 - чтение значения выходных/внутренних регистров.      /*Сообщение-запрос содержит адрес начального исходного/внутреннего регистра (двухбайтовое слово),      и количество регистров для чтения. Регистры нумеруются начиная с 0.     03 Read Holding Registers            ОПИСАНИЕ            Чтение двоичного содержания регистров (ссылка 4Х) в подчиненном.            ЗАПРОС            Сообщение запроса специфицирует начальный регистр и количество регистров для чтения.            Регистры адресуются начина с 0: регистры 1-16 адресуются как 0-15.           Ниже приведен пример чтения регистров 40108-40110 с подчиненного устройства 17.            Запрос            Имя поля						Пример                                                                   (Hex)            Адрес подчиненного					11	0           Функция						03	1           Начальный адрес ст.					00	2           Начальный адрес мл.					6B	3           Кол-во регистров ст.					00	4           Кол-во регистров мл.					03	5           Контрольная сумма					--            ОТВЕТ            Данные регистров в ответе передаются как два бйта на регистр.            Для каждого регистра, первый байт содержит старшие биты второй байт содержит младшие биты.           За одно обращение может считываться 125 регистров для контроллеров 984-Х8Х (984-685 и т.д.),            и 32 регистра для других контроллеров. Ответ дается когда все данные укомплектованы.           Это пример ответа на запрос представленный выше:            Ответ            Имя поля						Пример                                                                   (Hex)            Адрес подчиненного					11	0           Функция						03	1           Счетчик байт						06	2           Данные (регистр 40108) ст.				02	3           Данные (регистр 40108) мл.				2B	4           Данные (регистр 40109) ст.				00	5           Данные (регистр 40109) мл.				00	6           Данные (регистр 40110) ст.				00	7           Данные (регистр 40110) мл.				64	8           Контрольная сумма					--     */ #if ModBusUseFunc3!=0           if(PaketRX[1]==0x03)       {       //вычисление адреса запрашиваемых слов       unsigned short AdresWord=(((((unsigned short)PaketRX[2])<<8)|(PaketRX[3])));       //вычисление адреса количества запрашиваемых слов       unsigned short KolvoWord=((((unsigned short)PaketRX[4])<<8)|(PaketRX[5]));        //если неправильный адрес и количество       if(((AdresWord+KolvoWord)>ModBusMaxOutReg) || (KolvoWord>ModBusMaxOutRegTX))         {//тады конец         CRCmodbus=0xFFFF;//установить начальное значение CRC         return;//Ошибка, повторный запрос не требуется         }       Prg2ModBusOutReg();//Заполнение регистров Модбас (GlobalDate->ModBus)       //формирование пакета ответа       //адрес       ModBusPUT(PaketRX[0]);       CRCmodbus=CRCfunc(0xFFFF,PaketRX[0]);       //код команды           ModBusPUT(3);       CRCmodbus=CRCfunc(CRCmodbus,3);       //количества полных байт       ModBusPUT(KolvoWord<<1);       CRCmodbus=CRCfunc(CRCmodbus,(KolvoWord<<1));       //Копирование из регистра ModBusOutReg[] в пакет ответа       for(int i=0;i<KolvoWord;i++)         {         ModBusPUT(ModBusOutReg[AdresWord+i]>>8);         CRCmodbus=CRCfunc(CRCmodbus,(ModBusOutReg[AdresWord+i]>>8));         ModBusPUT(ModBusOutReg[AdresWord+i]>>0);         CRCmodbus=CRCfunc(CRCmodbus,(ModBusOutReg[AdresWord+i]>>0));         }       ModBusPUT(CRCmodbus);       ModBusPUT(CRCmodbus>>8);       //конец       CRCmodbus=0xFFFF; //установить начальное значение CRC       return;//повторный запрос не требуется       } #endif          /////////////////////////////////////////////////////////////////////////////     //Код функции 04 - чтение значения входных регистров     /*04 Read Input Registers            СОДЕРЖАНИЕ            Чтение двоичного содержания входных регистров (ссылка 3Х) в подчиненном.            ЗАПРОС            Запрос содержит номер начального регистра и количество регистров для чтения.           Ниже приведен пример запроса для чтения регистра 30009 с подчиненного устройства 17.            Запрос            Имя поля						Пример                                                                   (Hex)            Адрес подчиненного					11	0           Функция						03	1           Начальный адрес ст.					00	2           Начальный адрес мл.					6B	3           Кол-во регистров ст.					00	4           Кол-во регистров мл.					03	5           Контрольная сумма					--               ОТВЕТ            Данные регистров в ответе передаются как два бйта на регистр.            Для каждого регистра, первый байт содержит старшие биты второй байт содержит младшие биты.           За одно обращение может считываться 125 регистров для контроллеров 984-Х8Х (984-685 и т.д.),            и 32 регистра для других контроллеров. Ответ дается когда все данные укомплектованы.           Это пример ответа на запрос представленный выше:            Ответ            Имя поля						Пример                                                                   (Hex)            Адрес подчиненного					11	0           Функция						03	1           Счетчик байт						02	2           Данные (регистр 30009) ст.				00	3           Данные (регистр 30009) мл.				2A	4           Контрольная сумма					--       */ #if ModBusUseFunc4!=0          if(PaketRX[1]==0x04)       {       //вычисление адреса запрашиваемых слов       unsigned short AdresWord=(((((unsigned short)PaketRX[2])<<8)|(PaketRX[3])));       //вычисление адреса количества запрашиваемых слов       unsigned short KolvoWord=((((unsigned short)PaketRX[4])<<8)|(PaketRX[5]));        //если неправильный адрес и количество       if(((AdresWord+KolvoWord)>ModBusMaxInReg) || (KolvoWord>ModBusMaxInRegTX))         {//тады конец         CRCmodbus=0xFFFF;//установить начальное значение CRC         return;//Ошибка, повторный запрос не требуется         }       Prg2ModBusInReg();//Заполнение регистров Модбас (GlobalDate->ModBus)       //формирование пакета ответа       //адрес       ModBusPUT(PaketRX[0]);       CRCmodbus=CRCfunc(0xFFFF,(PaketRX[0]));       //код команды           ModBusPUT(4);       CRCmodbus=CRCfunc(CRCmodbus,4);       //количества полных байт       ModBusPUT(KolvoWord<<1);       CRCmodbus=CRCfunc(CRCmodbus,(KolvoWord<<1));       //Копирование из регистра ModBusInReg[] в пакет ответа       for(int i=0;i<KolvoWord;i++)         {         ModBusPUT(ModBusInReg[AdresWord+i]>>8);         CRCmodbus=CRCfunc(CRCmodbus,(ModBusInReg[AdresWord+i]>>8));         ModBusPUT(ModBusInReg[AdresWord+i]>>0);         CRCmodbus=CRCfunc(CRCmodbus,(ModBusInReg[AdresWord+i]>>0));         }       ModBusPUT(CRCmodbus);       ModBusPUT(CRCmodbus>>8);       //конец       CRCmodbus=0xFFFF; //установить начальное значение CRC       return;//повторный запрос не требуется       } #endif           /////////////////////////////////////////////////////////////////////////////     //Код функции 05 - запись выходного/внутреннего бита     /*05 Force Single Coil            ОПИСАНИЕ            Установка единичного выхода (ссылка 0Х) в ON или OFF.            При широковещательной передаче функция устанавливает все выходы с данным адресом во всех подчиненных контроллерах.            ЗАМЕЧАНИЕ Функция может пересекаться с установкой защиты                           памяти и установкой недоступности выходов.            ЗАПРОС            Запрос содержит номер выхода для установки. Выходы адресуются начиная с 0. Выход 1 адресуется как 0.           Состояние, в которое необходимо установить выход (ON/OFF) описывается в поле данных.            Величина FF00 Hex - ON. Величина 0000 - OFF. Любое другое число неверно и не влияет на выход.           В приведенном ниже примере устанавливается выход 173 в состояние ON в подчиненном устройстве 17.            Запрос            Имя поля						Пример                                                                   (Hex)            Адрес подчиненного					11	0           Функция						05	1           Адрес выхода мл.					00	2           Адрес выхода ст.					AC	3           Данные ст.						FF	4           Данные мл.						00	5           Контрольная сумма					--               ОТВЕТ            Нормальный ответ повторяет запрос.            Ответ            Имя поля						Пример                                                                   (Hex)            Адрес подчиненного					11	0           Функция						05	1           Адрес выхода мл.					00	2           Адрес выхода ст.					AC	3           Данные ст.						FF	4           Данные мл.						00	5           Контрольная сумма					--       */ #if ModBusUseFunc5!=0          if(PaketRX[1]==0x05)       {       //вычисление адреса записываемого выхода       unsigned short AdresBit=(((((unsigned short)PaketRX[2])<<8)|(PaketRX[3])));       //проверка на допустимый адрес         if(AdresBit>=ModBusMaxOutBit)         {//если неправильный адрес         CRCmodbus=0xFFFF; //установить начальное значение CRC         return;//Ошибка, повторный запрос не требуется         }       //установка сброс бита       switch (((((unsigned short)PaketRX[4])<<8)|(PaketRX[5])))         {         case 0xFF00:         //установка бита         ModBusOutBit[(AdresBit>>3)].byte|=(1<<(AdresBit&7));         break;         case 0x0000:         //сброс бита         ModBusOutBit[(AdresBit>>3)].byte&=(~(1<<(AdresBit&7)));         break;         default:           {//конец           CRCmodbus=0xFFFF; //установить начальное значение CRC           return;//Ошибка, повторный запрос не требуется           }          }       //Ответ       for(int i=0;i<8;i++) ModBusPUT(PaketRX[i]);//запускаем передачу пакета ответа       ModBus2PrgOutBit();//Считывание регистров Модбас (ModBus->GlobalDate)       //конец       CRCmodbus=0xFFFF; //установить начальное значение CRC       return;//повторный запрос не требуется        } #endif          /////////////////////////////////////////////////////////////////////////////     //Код функции 06 - запись выходного/внутреннего регистра.      /*Функция аналогична 05, но оперирует с регистрами (словами).      В запросе указывается номер выходного/внутреннего регистра и его значение.      06 Preset Single Register            ОПИСАНИЕ. Записывает величину в единичный регистр (ссылка 4Х).           При щироковезательной передаче на всех подчиненных устройствах устанавливается один и тот же регистр.            ЗАМЕЧАНИЕ            Функция может пересекаться с установленной защитой памяти.            ЗАПРОС            Запрос содержит ссылку на регистр, который необходимо установить. Регистры адресуются с 0.           Величина, в которую необходимо установить регистр передается в поле данных.            Контроллеры M84 и 484 используют 10-ти битную величину, старшие шесть бит заполняются 0.            Все другие контроллерыиспользуют 16 бит.           В приведенном ниже примере в регистр 40002 записывается величина 0003 Hex в подчиненном устройстве 17.            Запрос            Имя поля						Пример                                                                   (Hex)            Адрес подчиненного					11	0           Функция						06	1           Адрес регистра мл.					00	2           Адрес регистра ст.					01	3           Данные ст.						00	4           Данные мл.						03	5           Контрольная сумма					--               ОТВЕТ            Нормальный ответ повторяет запрос.            Ответ            Имя поля						Пример                                                                   (Hex)            Адрес подчиненного					11	0           Функция						06	1           Адрес регистра мл.					00	2           Адрес регистра ст.					01	3           Данные ст.						00	4           Данные мл.						03	5           Контрольная сумма					--       */ #if ModBusUseFunc6!=0         if(PaketRX[1]==0x06)       {       //вычисление адреса записываемого выхода       unsigned short AdresWord=(((((unsigned short)PaketRX[2])<<8)|(PaketRX[3])));       //проверка на допустимый адрес         if(AdresWord>=(ModBusMaxOutReg))         {//если неправильный адрес         CRCmodbus=0xFFFF; //установить начальное значение CRC         return;//Ошибка, повторный запрос не требуется         }       //запись слова       ModBusOutReg[AdresWord]=(((((unsigned short)PaketRX[4])<<8)|(PaketRX[5])));       //Ответ       for(int i=0;i<8;i++) ModBusPUT(PaketRX[i]);//запускаем передачу пакета ответа       ModBus2PrgOutReg();//Считывание регистров Модбас (ModBus->GlobalDate)       //конец       CRCmodbus=0xFFFF; //установить начальное значение CRC       return;//повторный запрос не требуется       } #endif          /////////////////////////////////////////////////////////////////////////////     //Код функции 0x0F - запись нескольких выходных/внутренних битов.      /*В запросе указывается начальный адрес бита, количество бит для записи, счетчик байтов и непосредственно значения.      15 (0F Hex) Force Multiple Coils            ОПИСАНИЕ            Устанавливает каждый выход (ссылка 0Х) последовательности выходов в одно из состояний ON или OFF.            При широковещательной передаче функция устанавливает подобные выходы на всех подчиненных.            ЗАМЕЧАНИЕ Функция может пересекаться с установкой защиты памяти и установкой недоступности выходов.            ЗАПРОС            Запрос специфицирует выходы для установки. Выходы адресуются начиная с 0.           Ниже показан пример запроса на установку последовательности выходов начиная с 20 (адресуется как 19)            в подчиненном устройстве 17.           Поле данных запроса содержит 2 байта: CD 01 Hex (1100 1101 0000 0001 двоичное).            Соответствие битов и выходов представлено ниже:            Бит:    1  1  0  0  1  1  0  1		0  0  0  0  0  0   0  1            Выход: 27 26 25 24 23 22 21 20		-  -  -  -  -  -  29 28            Запрос            Имя поля						Пример                                                                   (Hex)            Адрес подчиненного					11	0           Функция						0F	1           Адрес выхода ст.					00	2           Адрес выхода мл.					13	3           Кол-во выходов ст.					00	4           Кол-во выходов мл.					0A	5           Счетчик байт						02	6           Данные для установки (Выходы 27-20)			CD	7           Данные для установки (Выходы 29-28) 			01	8           Контрольная сумма					--	9               ОТВЕТ            Нормальный ответ возвращает адрес подчиненного, код функции, начальный адрес, и количество установленных выходов.           Это пример ответа на представленный выше запрос.            Ответ            Имя поля						Пример                                                                   (Hex)            Адрес подчиненного					11	0           Функция						0F	1           Адрес выхода ст.					00	2           Адрес выхода мл.					13	3           Кол-во выходов ст.					00	4           Кол-во выходов мл.					0A	5           Контрольная сумма					--     */ #if ModBusUseFunc15!=0         if(PaketRX[1]==0x0F)       {       //вычисление адреса записываемых бит       unsigned short AdresBit=(((((unsigned short)PaketRX[2])<<8)|(PaketRX[3])));       //вычисление количества записываемых бит       unsigned short KolvoBit=(((((unsigned short)PaketRX[4])<<8)|(PaketRX[5])));       //если неправильный адрес и количество       if(((AdresBit+KolvoBit)>ModBusMaxOutBit) || (KolvoBit>ModBusMaxOutBitRX))         {//тады конец         CRCmodbus=0xFFFF; //установить начальное значение CRC         return;//Ошибка, повторный запрос не требуется         }       //установка битов       unsigned char Bit=(AdresBit&7);//указатель бит в ModBusOutBit[]       AdresBit=AdresBit>>3;//указатель байт ModBusOutBit[]       //цикл по битам       for(int i=0;i<KolvoBit;i++)         {         if(PaketRX[7+(i>>3)]&(1<<(i&7)))//если текущий бит PaketRX равен 1           {//устанавливаем бит в ModBusOutBit[]           ModBusOutBit[AdresBit].byte=(ModBusOutBit[AdresBit].byte)|((unsigned char)(1<<Bit));           }         else           {//сбрасываем бит ModBusOutBit[]           ModBusOutBit[AdresBit].byte=(ModBusOutBit[AdresBit].byte)&((unsigned char)(~(1<<Bit)));           }         //инкрементруем указатели          Bit++;if(Bit==8){Bit=0;AdresBit++;}         }                  //вычисляем CRC пакета передачи и передаем       CRCmodbus=0xFFFF;       for(int i=0;i<6;i++)         {         ModBusPUT(PaketRX[i]);         CRCmodbus=CRCfunc(CRCmodbus,(PaketRX[i]));         }       ModBusPUT(CRCmodbus);       ModBusPUT(CRCmodbus>>8);                  ModBus2PrgOutBit();//Считывание регистров Модбас (ModBus->GlobalDate)              //конец       CRCmodbus=0xFFFF; //установить начальное значение CRC       return;//повторный запрос не требуется       } #endif          //Код функции 0x10 запись нескольких выходных/внутренних регистров.     /*16 (10 Hex) Preset Multiple Regs            ОПИСАНИЕ            Запись данных в последовательность регистров (ссылка 4Х).            При широковещательной передаче, функция устанавливает подобные регистры во всех подчиненных устройствах.            ЗАМЕЧАНИЕ            Функция может пересекаться с установленной защитой памяти.            ЗАПРОС            Запрос специфицирует регистры для записи. Регистры адресуются начиная с 0.           Данные для записи в регистры содержатся в поле данных запроса.            Контроллеры M84 и 484 используют 10-битовую величину, со старшими шестью битами установленными в 0.            Все остальные контроллеры используют 16 бит.           Ниже приведен пример запроса на установку двух регистров начиная с 40002 в 00 0A и 01 02 Hex,            в подчиненном устройстве 17:            Запрос            Имя поля						Пример                                                                   (Hex)            Адрес подчиненного					11	0           Функция						10	1           Начальный адрес					00	2           Начальный адрес					01	3           Кол-во регистров ст.					00	4           Кол-во регистров мл.					02	5           Счетчик байт						04	6           Данные ст.						00	7           Данные мл.						0A	8           Данные ст.						01	9           Данные мл.						02	10           Контрольная сумма					--               ОТВЕТ            Нормальный ответ содержит адрес подчиненного, код функции, начальный адрес, и количество регистров.      */ #if ModBusUseFunc16!=0          if(PaketRX[1]==0x10)       {       //вычисление адреса записываемых слов       unsigned short b=(((((unsigned short)PaketRX[2])<<8)|(PaketRX[3])));       //вычисление количества записываемых слов       unsigned short c=(((((unsigned short)PaketRX[4])<<8)|(PaketRX[5])));       //если неправильный адрес и количество       if(((b+c)>ModBusMaxOutReg) || c>ModBusMaxOutRegRX || c==0)         {//тады конец         CRCmodbus=0xFFFF;//установить начальное значение CRC         return;//Ошибка, повторный запрос не требуется         }       //Копирование из пакета в регистр ModBusOutReg[]       for(int i=0;i<c;i++)         {         ModBusOutReg[b+i]=(((unsigned short)PaketRX[7+(i<<1)])<<8)|(PaketRX[8+(i<<1)]);         }       //вычисляем CRC пакета передачи и передаем       CRCmodbus=0xFFFF;       for(int i=0;i<6;i++)         {         ModBusPUT(PaketRX[i]);         CRCmodbus=CRCfunc(CRCmodbus,(PaketRX[i]));         }       ModBusPUT(CRCmodbus);       ModBusPUT(CRCmodbus>>8);       ModBus2PrgOutReg();//Считывание регистров Модбас (ModBus->GlobalDate)       //конец       CRCmodbus=0xFFFF; //установить начальное значение CRC       return;//повторный запрос не требуется        } #endif              /////////////////////////////////////////////////////////////////////////////     //полный конец     CRCmodbus=0xFFFF; //установить начальное значение CRC     return;////Ошибка, нераспознана команда, повторный запрос не требуется     }   return;//повторный запрос не требуется    }  //Функция конвертация шеснадцатиричных символов в число static inline unsigned char Hex2Dig(unsigned char h)   {   if((h>='0')&&(h<='9')) return (h -'0');   if((h>='A')&&(h<='F')) return (h -'A'+10);   return 0;   } static unsigned char LRCmodbus;//тукущий LRC static unsigned char Simvol0;//предидущий принятвй символ #define ASCII_CR (0x0D)//возврат каретки  #define ASCII_LF (0x0A)//перевод строки static const unsigned char BCD[]="0123456789ABCDEF";//строка для конвертации числа в символ  //Функция обработки Сообщений модбас ASCII void ModBusASCII(void)   {   if(Sost==0)     {//Состояние прием     while(!0)       {//Цикл приема символов       unsigned short Tmp=ModBusGET(); //читаем символ из входного потока       if(Tmp==0) return; //если нет данных повторный запрос не требуется        //Символ принят       Tmp=Tmp&0xFF;//отбрасываем признак приема байта       //проверка на начало пакета       if(Tmp==':')         {//начало пакета         LRCmodbus=0;//обнуляем LRC         UkPaket=0;//указатель в массиве, текущий принятый символ         continue;//запускаем повторный запрос символа         }               //проверка на алфавит сообщения       if(!(            ((Tmp>='0')&&(Tmp<='9'))||            ((Tmp>='A')&&(Tmp<='F'))||            (Tmp==ASCII_CR)||            (Tmp==ASCII_LF)            ))          {         return;//Ошибка, повторный запрос не требуется         }                //сохраняем принятый символ       if((UkPaket&1)==0)         {//указатель принятых данных четный 0,2,4,6...         Simvol0=Tmp; //сохраняем первый символ пакета         UkPaket++; //икреметируем указатель пакета         continue;//запускаем повторный запрос          }       else          {//указатель принятых данных нечетный 1,3,5,7...         if(Tmp!=ASCII_LF)           {//не достигнут конец           PaketRX[UkPaket>>1]=(Hex2Dig(Simvol0)<<4)|(Hex2Dig(Tmp));//сохраняем байт пакета            LRCmodbus=LRCmodbus-PaketRX[UkPaket>>1];//считаем LRC           UkPaket++;//икреметируем указатель пакета           if(UkPaket>(ModBusMaxPaketRX<<1))//проверка на переполнение             {//Буфер приема переполнился             UkPaket=0;//сбросить указатель пакета             return;//ошибка, повторный запрос не требуется             }           }         else break;         }       }                //Проверка LCR     if(LRCmodbus!=0) return;//Ошибка, повторный запрос не требуется          //Провекка адреса     if((PaketRX[0]!=ModBusID)&&(PaketRX[0]!=ModBusID_FF))       {//Не наш адрес       return;//повторный запрос не требуется       }            //преходим в состояние передача     Sost=!0;     TimModbus=ModBusSysTimer;//запомнить таймер #if ModBusMaxPauseResp!=0       return;//повторный запрос не требуется #endif       }        /////////////////////////////////////////////////////////////////////////////    if(Sost!=0  #if ModBusMaxPauseResp!=0           && (ModBusSysTimer-TimModbus)>=ModBusMaxPauseResp #endif           )     {//Состояние передача ответа     Sost=0;     /////////////////////////////////////////////////////////////////////////////         //                       обработка команд                                  //     ///////////////////////////////////////////////////////////////////////////// #if ModBusUseFunc1!=0          //01 Чтение статуса выходов      if(PaketRX[1]==0x01)       {       //вычисление адреса запрашиваемых бит       unsigned short AdresBit=(((((unsigned short)PaketRX[2])<<8)|(PaketRX[3])));       //вычисление количества запрашиваемых бит       unsigned short KolvoBit=((((unsigned short)PaketRX[4])<<8)|(PaketRX[5]));       //если неправильный адрес и количество       if((AdresBit+KolvoBit)>(ModBusMaxOutBit) || KolvoBit>ModBusMaxOutBitTX || KolvoBit==0)         {//конец         return;//Ошибка, повторный запрос не требуется         }       Prg2ModBusOutBit();//Заполнение регистров Модбас (GlobalDate->ModBus)       //формирование пакета ответа       ModBusPUT(':');       //адрес       ModBusPUT(BCD[PaketRX[0]>>4]);//Передаем старший        ModBusPUT(BCD[PaketRX[0]&0x0F]);//передаем младший       LRCmodbus=0-PaketRX[0];//считаем LRC       //код команды           ModBusPUT(BCD[1>>4]);//Передаем старший        ModBusPUT(BCD[1&0x0F]);//передаем младший       LRCmodbus=LRCmodbus-1;//считаем LRC       //количества полных байт       ModBusPUT(BCD[((KolvoBit+7)>>3)>>4]);//Передаем старший        ModBusPUT(BCD[((KolvoBit+7)>>3)&0x0F]);//передаем младший       LRCmodbus=LRCmodbus-((KolvoBit+7)>>3);//считаем LRC       //копирование битов в пакет ответа       unsigned char TxByte=0;//текущий байт       unsigned char Bit=AdresBit&7;//указатель бит в ModBusOutBit[]       AdresBit=AdresBit>>3;//указатель байт ModBusOutBit[]       //копирование из регистра ModBusOutBit[] в пакет       int i=0;       while(!0)         {         if((ModBusOutBit[AdresBit].byte)&(1<<Bit))//если текущий бит ModBusOutBit[] равен 1           {//устанавливаем бит в пакете           TxByte=TxByte|(1<<(i&7));           }         //инкрементруем указатели          Bit++;         if(Bit==8){Bit=0;AdresBit++;}         i++;         if((i&7)==0)           {           ModBusPUT(BCD[TxByte>>4]);//Передаем старший            ModBusPUT(BCD[TxByte&0x0F]);//передаем младший           LRCmodbus=LRCmodbus-TxByte;//считаем LRC           TxByte=0;           if(i==KolvoBit) break; else continue;           }         if(i==KolvoBit)            {           ModBusPUT(BCD[TxByte>>4]);//Передаем старший            ModBusPUT(BCD[TxByte&0x0F]);//передаем младший           LRCmodbus=LRCmodbus-TxByte;//считаем LRC           break;           }         }       ModBusPUT(BCD[LRCmodbus>>4]);       ModBusPUT(BCD[LRCmodbus&0x0F]);       ModBusPUT(ASCII_CR);       ModBusPUT(ASCII_LF);       //конец       return;//повторный запрос не требуется       } #endif #if ModBusUseFunc2!=0          //02 Read Input Status      if(PaketRX[1]==0x02)       {       //вычисление адреса запрашиваемых бит       unsigned short AdresBit=(((((unsigned short)PaketRX[2])<<8)|(PaketRX[3])));       //вычисление количества запрашиваемых бит       unsigned short KolvoBit=((((unsigned short)PaketRX[4])<<8)|(PaketRX[5]));       //если неправильный адрес и количество       if((AdresBit+KolvoBit)>(ModBusMaxInBit) || KolvoBit>ModBusMaxInBitTX || KolvoBit==0)         {//конец         return;//Ошибка, повторный запрос не требуется         }       Prg2ModBusInBit();//Заполнение регистров Модбас (GlobalDate->ModBus)       //формирование пакета ответа       ModBusPUT(':');       //адрес       ModBusPUT(BCD[PaketRX[0]>>4]);//Передаем старший        ModBusPUT(BCD[PaketRX[0]&0x0F]);//передаем младший       LRCmodbus=0-PaketRX[0];//считаем LRC       //код команды           ModBusPUT(BCD[2>>4]);//Передаем старший        ModBusPUT(BCD[2&0x0F]);//передаем младший       LRCmodbus=LRCmodbus-2;//считаем LRC       //количества полных байт       ModBusPUT(BCD[((KolvoBit+7)>>3)>>4]);//Передаем старший        ModBusPUT(BCD[((KolvoBit+7)>>3)&0x0F]);//передаем младший       LRCmodbus=LRCmodbus-((KolvoBit+7)>>3);//считаем LRC       //копирование битов в пакет ответа       unsigned char TxByte=0;//текущий байт       unsigned char Bit=AdresBit&7;//указатель бит в ModBusOutBit[]       AdresBit=AdresBit>>3;//указатель байт ModBusOutBit[]       //копирование из регистра ModBusOutBit[] в пакет       int i=0;       while(!0)         {         if((ModBusInBit[AdresBit].byte)&(1<<Bit))//если текущий бит ModBusOutBit[] равен 1           {//устанавливаем бит в пакете           TxByte=TxByte|(1<<(i&7));           }         //инкрементруем указатели          Bit++;         if(Bit==8){Bit=0;AdresBit++;}         i++;         if((i&7)==0)           {           ModBusPUT(BCD[TxByte>>4]);//Передаем старший            ModBusPUT(BCD[TxByte&0x0F]);//передаем младший           LRCmodbus=LRCmodbus-TxByte;//считаем LRC           TxByte=0;           if(i==KolvoBit) break; else continue;           }         if(i==KolvoBit)            {           ModBusPUT(BCD[TxByte>>4]);//Передаем старший            ModBusPUT(BCD[TxByte&0x0F]);//передаем младший           LRCmodbus=LRCmodbus-TxByte;//считаем LRC           break;           }         }       ModBusPUT(BCD[LRCmodbus>>4]);       ModBusPUT(BCD[LRCmodbus&0x0F]);       ModBusPUT(ASCII_CR);       ModBusPUT(ASCII_LF);       //конец       return;//повторный запрос не требуется       } #endif #if ModBusUseFunc3!=0          //03 Read Holding Registers      if(PaketRX[1]==0x03)       {       //вычисление адреса запрашиваемых слов       unsigned short AdresWord=(((((unsigned short)PaketRX[2])<<8)|(PaketRX[3])));       //вычисление адреса количества запрашиваемых слов       unsigned short KolvoWord=((((unsigned short)PaketRX[4])<<8)|(PaketRX[5]));        //если неправильный адрес и количество       if(((AdresWord+KolvoWord)>ModBusMaxOutReg) || KolvoWord>ModBusMaxOutRegTX)         {//тады конец         return;//Ошибка, повторный запрос не требуется         }       Prg2ModBusOutReg();//Заполнение регистров Модбас (GlobalDate->ModBus)       //формирование пакета ответа       ModBusPUT(':');       //адрес       ModBusPUT(BCD[PaketRX[0]>>4]);//Передаем старший        ModBusPUT(BCD[PaketRX[0]&0x0F]);//передаем младший       LRCmodbus=0-PaketRX[0];//считаем LRC       //код команды       ModBusPUT(BCD[3>>4]);//Передаем старший        ModBusPUT(BCD[3&0x0F]);//передаем младший       LRCmodbus=LRCmodbus-3;//считаем LRC       //количества полных байт       ModBusPUT(BCD[(KolvoWord<<1)>>4]);//Передаем старший        ModBusPUT(BCD[(KolvoWord<<1)&0x0F]);//передаем младший       LRCmodbus=LRCmodbus-(KolvoWord<<1);//считаем LRC       //Копирование из регистра ModBusOutReg[] в пакет ответа       for(int i=0;i<KolvoWord;i++)         {         ModBusPUT(BCD[((ModBusOutReg[AdresWord+i])>>8)>>4]);//Передаем старший          ModBusPUT(BCD[((ModBusOutReg[AdresWord+i])>>8)&0x0F]);//передаем младший         LRCmodbus=LRCmodbus-((ModBusOutReg[AdresWord+i])>>8);//считаем LRC         ModBusPUT(BCD[(((ModBusOutReg[AdresWord+i])>>0)>>4)&0x0F]);//Передаем старший          ModBusPUT(BCD[(((ModBusOutReg[AdresWord+i])>>0)>>0)&0x0F]);//передаем младший         LRCmodbus=LRCmodbus-((ModBusOutReg[AdresWord+i])>>0);//считаем LRC         }       ModBusPUT(BCD[LRCmodbus>>4]);       ModBusPUT(BCD[LRCmodbus&0x0F]);       ModBusPUT(ASCII_CR);       ModBusPUT(ASCII_LF);       //конец       return;//повторный запрос не требуется       } #endif #if ModBusUseFunc4!=0          //04 Read Input Registers      if(PaketRX[1]==0x04)       {       //вычисление адреса запрашиваемых слов       unsigned short AdresWord=(((((unsigned short)PaketRX[2])<<8)|(PaketRX[3])));       //вычисление адреса количества запрашиваемых слов       unsigned short KolvoWord=((((unsigned short)PaketRX[4])<<8)|(PaketRX[5]));        //если неправильный адрес и количество       if(((AdresWord+KolvoWord)>ModBusMaxOutReg) || KolvoWord>ModBusMaxOutRegTX)         {//тады конец         return;//Ошибка, повторный запрос не требуется         }       Prg2ModBusInReg();//Заполнение регистров Модбас (GlobalDate->ModBus)       //формирование пакета ответа       ModBusPUT(':');       //адрес       ModBusPUT(BCD[PaketRX[0]>>4]);//Передаем старший        ModBusPUT(BCD[PaketRX[0]&0x0F]);//передаем младший       LRCmodbus=0-PaketRX[0];//считаем LRC       //код команды       ModBusPUT(BCD[4>>4]);//Передаем старший        ModBusPUT(BCD[4&0x0F]);//передаем младший       LRCmodbus=LRCmodbus-4;//считаем LRC       //количества полных байт       ModBusPUT(BCD[(KolvoWord<<1)>>4]);//Передаем старший        ModBusPUT(BCD[(KolvoWord<<1)&0x0F]);//передаем младший       LRCmodbus=LRCmodbus-(KolvoWord<<1);//считаем LRC       //Копирование из регистра ModBusOutReg[] в пакет ответа       for(int i=0;i<KolvoWord;i++)         {         ModBusPUT(BCD[((ModBusInReg[AdresWord+i])>>8)>>4]);//Передаем старший          ModBusPUT(BCD[((ModBusInReg[AdresWord+i])>>8)&0x0F]);//передаем младший         LRCmodbus=LRCmodbus-((ModBusInReg[AdresWord+i])>>8);//считаем LRC         ModBusPUT(BCD[(((ModBusInReg[AdresWord+i])>>0)>>4)&0x0F]);//Передаем старший          ModBusPUT(BCD[(((ModBusInReg[AdresWord+i])>>0)>>0)&0x0F]);//передаем младший         LRCmodbus=LRCmodbus-((ModBusInReg[AdresWord+i])>>0);//считаем LRC         }       ModBusPUT(BCD[LRCmodbus>>4]);       ModBusPUT(BCD[LRCmodbus&0x0F]);       ModBusPUT(ASCII_CR);       ModBusPUT(ASCII_LF);       //конец       return;//повторный запрос не требуется       } #endif #if ModBusUseFunc5!=0          //05 Force Single Coil      if(PaketRX[1]==0x05)       {       //вычисление адреса записываемого выхода       unsigned short AdresBit=(((((unsigned short)PaketRX[2])<<8)|(PaketRX[3])));       //проверка на допустимый адрес         if(AdresBit>=ModBusMaxOutBit)//если неправильный адрес         {//тады конец         return;//Ошибка, повторный запрос не требуется         }       //установка сброс бита       switch (((((unsigned short)PaketRX[4])<<8)|(PaketRX[5])))         {         case 0xFF00:         //установка бита         ModBusOutBit[(AdresBit>>3)].byte|=(1<<(AdresBit&7));         break;         case 0x0000:         //сброс бита         ModBusOutBit[(AdresBit>>3)].byte&=(~(1<<(AdresBit&7)));         break;         default:           { //конец           return;//Ошибка, повторный запрос не требуется           }          }                      //Ответ       ModBusPUT(':');       for(int i=0;i<7;i++)         {         ModBusPUT(BCD[PaketRX[i]>>4]);//Передаем старший          ModBusPUT(BCD[PaketRX[i]&0x0F]);//передаем младший         }       ModBusPUT(ASCII_CR);       ModBusPUT(ASCII_LF);                 ModBus2PrgOutBit();//Считывание регистров Модбас (ModBus->GlobalDate)              //конец       return;//повторный запрос не требуется        } #endif #if ModBusUseFunc6!=0          //06 Preset Single Register      if(PaketRX[1]==0x06)       {       //вычисление адреса записываемого выхода       unsigned short AdresWord=(((((unsigned short)PaketRX[2])<<8)|(PaketRX[3])));              //проверка на допустимый адрес         if(AdresWord>=(ModBusMaxOutReg))//если неправильный адрес         {//тады конец         return;//Ошибка, повторный запрос не требуется         }       //запись слова       ModBusOutReg[AdresWord]=(((((unsigned short)PaketRX[4])<<8)|(PaketRX[5])));              //Ответ       ModBusPUT(':');       for(int i=0;i<7;i++)         {         ModBusPUT(BCD[PaketRX[i]>>4]);//Передаем старший          ModBusPUT(BCD[PaketRX[i]&0x0F]);//передаем младший         }       ModBusPUT(ASCII_CR);       ModBusPUT(ASCII_LF);              ModBus2PrgOutReg();//Считывание регистров Модбас (ModBus->GlobalDate)                //конец       return;//повторный запрос не требуется       } #endif #if ModBusUseFunc15!=0           //15 (0F Hex) Force Multiple Coils      if(PaketRX[1]==0x0F)       {       //вычисление адреса записываемых бит       unsigned short AdresBit=(((((unsigned short)PaketRX[2])<<8)|(PaketRX[3])));       //вычисление количества записываемых бит       unsigned short KolvoBit=(((((unsigned short)PaketRX[4])<<8)|(PaketRX[5])));       //если неправильный адрес и количество       if(((AdresBit+KolvoBit)>ModBusMaxOutBit) || (KolvoBit>ModBusMaxOutBitRX))         {//тады конец         return;//Ошибка, повторный запрос не требуется         }       //установка битов       unsigned char Bit=(AdresBit&7);//указатель бит в ModBusOutBit[]       AdresBit=AdresBit>>3;//указатель байт ModBusOutBit[]       //цикл по битам       for(int i=0;i<KolvoBit;i++)         {         if(PaketRX[7+(i>>3)]&(1<<(i&7)))//если текущий бит PaketRX равен 1           {//устанавливаем бит в ModBusOutBit[]           ModBusOutBit[AdresBit].byte=(ModBusOutBit[AdresBit].byte)|((unsigned char)(1<<Bit));           }         else           {//сбрасываем бит ModBusOutBit[]           ModBusOutBit[AdresBit].byte=(ModBusOutBit[AdresBit].byte)&((unsigned char)(~(1<<Bit)));           }         //инкрементруем указатели          Bit++;if(Bit==8){Bit=0;AdresBit++;}         }                         //вычисляем LRC пакета передачи и передаем       LRCmodbus=0;       ModBusPUT(':');       for(int i=0;i<6;i++)         {         ModBusPUT(BCD[PaketRX[i]>>4]);//Передаем старший          ModBusPUT(BCD[PaketRX[i]&0x0F]);//передаем младший         LRCmodbus=LRCmodbus-PaketRX[i];//считаем LRC         }       ModBusPUT(BCD[LRCmodbus>>4]);       ModBusPUT(BCD[LRCmodbus&0x0F]);       ModBusPUT(ASCII_CR);       ModBusPUT(ASCII_LF);              ModBus2PrgOutBit();//Считывание регистров Модбас (ModBus->GlobalDate)              //конец       return;//повторный запрос не требуется       } #endif #if ModBusUseFunc16!=0             //16 (10 Hex) Preset Multiple Regs      if(PaketRX[1]==0x10)       {       //вычисление адреса записываемых слов       unsigned short b=(((((unsigned short)PaketRX[2])<<8)|(PaketRX[3])));       //вычисление количества записываемых слов       unsigned short c=(((((unsigned short)PaketRX[4])<<8)|(PaketRX[5])));              //если неправильный адрес и количество       if(((b+c)>ModBusMaxOutReg) || c>ModBusMaxOutRegRX)         {         //тады конец         return;//Ошибка, повторный запрос не требуется         }       //Копирование из пакета в регистр ModBusOutReg[]       for(int i=0;i<c;i++)         {         ModBusOutReg[b+i]=(((unsigned short)PaketRX[7+(i<<1)])<<8)|(PaketRX[8+(i<<1)]);         }              //вычисляем LRC пакета передачи и передаем       LRCmodbus=0;       ModBusPUT(':');       for(int i=0;i<6;i++)         {         ModBusPUT(BCD[PaketRX[i]>>4]);//Передаем старший          ModBusPUT(BCD[PaketRX[i]&0x0F]);//передаем младший         LRCmodbus=LRCmodbus-PaketRX[i];//считаем LRC         }       ModBusPUT(BCD[LRCmodbus>>4]);       ModBusPUT(BCD[LRCmodbus&0x0F]);       ModBusPUT(ASCII_CR);       ModBusPUT(ASCII_LF);              ModBus2PrgOutReg();//Считывание регистров Модбас (ModBus->GlobalDate)              //конец       return;//повторный запрос не требуется        } #endif         }    //конец   return;//Ошибка, нераспознана команда, повторный запрос не требуется   } 

#define __MODBUS2PRG_C #include "modbus.h"  //Заполнение регистров Модбас //перенос данных из программных переменных в регистры МодБас void Prg2ModBusOutBit(void)   {//заполнение регистров дискретных выходов      return;   }  void Prg2ModBusInBit(void)   {//заполнение регистров дискретных входов   //ModBusInBit[0].bit0=1;      return;   }  void Prg2ModBusOutReg(void)   {//заполнение регистров 4Х регистры для чтения/записи      return;   }  void Prg2ModBusInReg(void)   {//заполнение регистов 3Х регистры для чтения      return;   }  //Считывание регистров Модбас //Перенос данных из регистров МодБас в программные переменные  void ModBus2PrgOutBit(void)   {//чтение регистров дискретных выходов      return;   }  void ModBus2PrgOutReg(void)   {//чтение регистров 4Х регистры для чтения/записи      return;   }