Modbus RTU - Страница 2

vovaf · 12.02.2010, 18:17

Как уже писал

Сообщение от baiderin

Таймером.Запускать по каждому импульсу.

При приеме каждого байта запускаете таймер на время вашего интервала.
При приеме пакета после каждого байта таймер перезапускается. При паузе в интервал таймер дает прерывание, в котором можно выставить флаг что пакет принят и ожидаете новый пакет

CMP_SYS · 12.02.2010, 18:35

Спасибо за помощь!!! Реализовал ))) Все работает.

mikemdr · 17.02.2010, 13:34

Сообщение от CMP_SYS

Спасибо за помощь!!! Реализовал ))) Все работает.

А можно чуть-чуть уточнить: как?

SasaVitebsk · 17.02.2010, 14:47

На AVR - примерно так:
1) По прерыванию USART0_RX_vect принимаем байт, и взводим таймер на интервал 1.5 байта на выбранной скорости. Обрабатываем байт.
2) По прерыванию TIMER3_OVF_vect (переполнение таймера) определяем конец пакета. Выясняем его целостность и законченность. Определяем есть ли ответ.
(точнее, операции по обработке пакета могут находится как в 2 этих прерываниях, так и в голове. Это зависит от сложности обработки и т.п. Я обычно делаю разбор пакета "на лету". Таким образом к прерыванию 2 у меня пакет уже обработан и, если надо - ответ готов. Я заполняю буфер на передачу, переключаю канал на передачу и разрешаю следующее прерывание UDRE)
3) По прерыванию USART0_UDRE_vect выдаю ответ из буфера ответа.
4) По прерыванию USART0_TX_vect переключаю передатчик на приём, запрещаю передачу и разрешаю приём.

Leonid2000 · 29.04.2010, 03:26

У меня тут вопрос. А что обязательно делать полную поддержку модбаса

? Если да то это сложно

, методы подсчёта контрольной суммы и сам состав соообщений одинаков а вот функцианально они разные по кодам функций. у меня например вот кусок кода который по прерыванию UART работает и вполне нормально отвечает многим OPC.

unsigned char mb_buf[31] ; //,mb_count=0;

//объединение разных типов переменных в четырёх регистрах
//для быстрого и удобного преобразования

union modbus
{
unsigned char m_b[4];
unsigned long int m_l;
unsigned int m_i[2];
float m_f;
};

union modbus Modicon;

void rd_buff(unsigned char dan) //параметр - входящий байт из UDR
{
if(mb_count==0){if(dan==Nomer_vk) {mb_buf[mb_count]=dan;mb_count++;}; goto exx;} //если не тот номер устройства то пропустить
if (mb_count==1)
{
if((dan==3)||(dan==16)) //если не тот тип кода функции то сбросить
{mb_buf[mb_count]=dan;
mb_count++;
goto exx;
}
else {mb_count=0;};
}
if (mb_count›1)
{
mb_buf[mb_count]=dan;
mb_count++;
if(mb_count==7) //вычисление длины сообщения в зависимости от типа
{
if(mb_buf[1]==3) {dlina_s = 8;}
if(mb_buf[1]==16) {dlina_s = 9 + mb_buf[6];}
};

if(mb_count==dlina_s)
{
mb_count=0;
MakeCRC16(mb_buf, dlina_s-2);
if((mb_buf[dlina_s-2] == bCRCHi)&&(mb_buf[dlina_s-1] = bCRCLo))
{
if (mb_buf[1]==3) //Обработка запросов
{
switch (mb_buf[3])
{ case 1: fs_f(elec[0]); break; //float
case 2: fs_f(elec[1]); break;

//case 12: fs7(1); break; //Int

case 5: tb = PINC; fs72(tb); break; //Char
};
}
if (mb_buf[1]==16) //Обработка записи
{
//процедура ответа вырезана
TMB(

; // процедура автоответа ответа
}
mb_count=0;
}
else
{
mb_count=0;
}

}
if(mb_count›16)mb_count=0;
};
exx:

}

и вот например процедура автоответа

void TMB(unsigned char ds)
{
unsigned char ss, dll;
dll= ds-2;
MakeCRC16(&mb_buf[0], dll); //подсчёт контрольной суммы

mb_buf[ds-2] = bCRCHi; mb_buf[ds-1] = bCRCLo;
PORTB.4=1; //для РС485 включить передачу
for (ss=0;ss‹=ds;ss++) {putchar1(mb_buf[ss]);};
PORTB.4=0; //для РС485 выключить передачу
}

подсчёт контрольной суммы табличный (для Atmega128 лишних байт не много но скорость выше)

/* Процедуры скоростного подсчёта CRC16
*/

typedef unsigned char uchar;
typedef signed char schar;

typedef unsigned int uint;
typedef signed int sint;

uchar bCRCHi,bCRCLo;

flash const uchar mpbCRCHi[0x100] = {
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40
};
flash const uchar mpbCRCLo[0x100] = {
0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2, 0xC6, 0x06, 0x07, 0xC7, 0x05, 0xC5, 0xC4,
0x04, 0xCC, 0x0C, 0x0D, 0xCD, 0x0F, 0xCF, 0xCE, 0x0E, 0x0A, 0xCA, 0xCB, 0x0B, 0xC9, 0x09,
0x08, 0xC8, 0xD8, 0x18, 0x19, 0xD9, 0x1B, 0xDB, 0xDA, 0x1A, 0x1E, 0xDE, 0xDF, 0x1F, 0xDD,
0x1D, 0x1C, 0xDC, 0x14, 0xD4, 0xD5, 0x15, 0xD7, 0x17, 0x16, 0xD6, 0xD2, 0x12, 0x13, 0xD3,
0x11, 0xD1, 0xD0, 0x10, 0xF0, 0x30, 0x31, 0xF1, 0x33, 0xF3, 0xF2, 0x32, 0x36, 0xF6, 0xF7,
0x37, 0xF5, 0x35, 0x34, 0xF4, 0x3C, 0xFC, 0xFD, 0x3D, 0xFF, 0x3F, 0x3E, 0xFE, 0xFA, 0x3A,
0x3B, 0xFB, 0x39, 0xF9, 0xF8, 0x38, 0x28, 0xE8, 0xE9, 0x29, 0xEB, 0x2B, 0x2A, 0xEA, 0xEE,
0x2E, 0x2F, 0xEF, 0x2D, 0xED, 0xEC, 0x2C, 0xE4, 0x24, 0x25, 0xE5, 0x27, 0xE7, 0xE6, 0x26,
0x22, 0xE2, 0xE3, 0x23, 0xE1, 0x21, 0x20, 0xE0, 0xA0, 0x60, 0x61, 0xA1, 0x63, 0xA3, 0xA2,
0x62, 0x66, 0xA6, 0xA7, 0x67, 0xA5, 0x65, 0x64, 0xA4, 0x6C, 0xAC, 0xAD, 0x6D, 0xAF, 0x6F,
0x6E, 0xAE, 0xAA, 0x6A, 0x6B, 0xAB, 0x69, 0xA9, 0xA8, 0x68, 0x78, 0xB8, 0xB9, 0x79, 0xBB,
0x7B, 0x7A, 0xBA, 0xBE, 0x7E, 0x7F, 0xBF, 0x7D, 0xBD, 0xBC, 0x7C, 0xB4, 0x74, 0x75, 0xB5,
0x77, 0xB7, 0xB6, 0x76, 0x72, 0xB2, 0xB3, 0x73, 0xB1, 0x71, 0x70, 0xB0, 0x50, 0x90, 0x91,
0x51, 0x93, 0x53, 0x52, 0x92, 0x96, 0x56, 0x57, 0x97, 0x55, 0x95, 0x94, 0x54, 0x9C, 0x5C,
0x5D, 0x9D, 0x5F, 0x9F, 0x9E, 0x5E, 0x5A, 0x9A, 0x9B, 0x5B, 0x99, 0x59, 0x58, 0x98, 0x88,
0x48, 0x49, 0x89, 0x4B, 0x8B, 0x8A, 0x4A, 0x4E, 0x8E, 0x8F, 0x4F, 0x8D, 0x4D, 0x4C, 0x8C,
0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86, 0x82, 0x42, 0x43, 0x83, 0x41, 0x81, 0x80,
0x40
} ;

void InitCRC16(void)
{
bCRCHi = 0xFF;
bCRCLo = 0xFF;
}

void CalcCRC16(uchar bT)
{
uchar i;

i = bCRCHi ^ bT;

bCRCHi = bCRCLo ^ mpbCRCHi[i];
bCRCLo = mpbCRCLo[i];
}

void MakeCRC16(uchar *pbData, uint wSize)
{
InitCRC16();
while (wSize-- › 0) CalcCRC16( *(pbData++) );
}

SasaVitebsk · 29.04.2010, 11:06

Сообщение от Leonid2000

У меня тут вопрос. А что обязательно делать полную поддержку модбаса?

А нет "полной поддержки". Есть функци да и всё. Там определен обязательный набор - их немного, а далее ты свободен.
Модбас, по сути, неполный протокол. Какие данные передаются - здесь полная свобода. Поэтому 2 прибора полностью поддерживающие модбас - не будут работать из под одной оболочки, если не было у разработчиков общей договорённости по распределению данных, их представлению и так далее.

Из 7 уровней модели OSI, модбасом определены канальный(2), сетевой(3) и транспортный(4). Остальные не прописаны.

Solncevorot · 28.12.2010, 12:49

В описании протокола Modbus RTU написано, что формат посылки master устройства следующий:
1. Старт-бит;
2. Адрес 8 бит;
3. Функция 8 бит;
4. Данные Х*8 бит;
5. CRC 16 бит;
6. Стоп-бит.

Так вот насколько я понимаю, после завершения старт-бита в slave устройство передается непрерывный поток данных, до тех пор, пока передача не будет завершена стоп-битом.

Формат ответа slave устройства примерно такой:
1. Старт-бит;
2. Адрес 8 бит;
3. Данные Х*8 бит;
4. CRC 16 бит;
5. Стоп-бит.

Ничего не сказано о том что каждый передаваемый бит информации чем-то отделяется от соседних в процессе передачи, но Atmega при передаче данных через USART автоматически генерирует старт-бит, стоп-бит, бит паритета (если заказано), и, насколько мне известно, выключить генерацию этой лабуды нельзя. Так как же тогда передавать данные в формате Modbus RTU, чтобы не генерировались старт и стоп биты в середине пакета?

Если не затруднит - проясните мне ситуацию.

vvkka · 28.12.2010, 13:33

выложите свой проект посмотреть MODBUS RTU очень интересно, занимаюсь этой же проблеммой тоже

Vov123 · 28.12.2010, 14:50

Solncevorot

http://www.designers.schneider-elect...Modbus_Rus.pdf

Solncevorot · 28.12.2010, 15:08

Сообщение от Vov123

Solncevorot

http://www.designers.schneider-elect...Modbus_Rus.pdf

Спасибо. Я это читал. Вы можете конкретно ответить на вопрос:
Каждый байт информации (8 бит подряд) начинается старт-битом и заканчивается стоп-битом?

По-другому сформулирую:
Пакет данных выглядит так как описано ниже?
1. Тишина 3,5 символов;

старт-бит
2. Адрес 8 бит;
стоп-бит

старт-бит
3. Функция 8 бит;
стоп-бит

старт-бит
4. Данные Х*8 бит; // между каждыми двумя соседними байтами стоп-бит и старт-бит
стоп-бит

старт-бит
5. CRC старший разряд 8 бит;
стоп-бит

5. CRC младший разряд 8 бит;
стоп-бит

старт-бит
6. Тишина 3,5 символов.