Не могу разобраться с Modbus RTU и 485 интерфейсом ...
- Войдите на сайт для отправки комментариев
Пт, 14/10/2016 - 17:37
Всем привет!
есть (как мне казалась) простая задача: удаленный мониторинг и примитивное управление термостатом с 485 интерфейсом. Собрал стенд, прогнал телеграммы, подключив USB-RS485 конвертер, через TERMITE (Modbus RTU terminal), все хорошо. В комментах, в начале программы, я указал образец сеанса связи ....
Теперь начал дружить контроллер с Ардуиной, но не тут то было. Не понимают они друг друга хоть убей. Вот код (начал с примитива, что бы понять, работает ли данный механизм), который почему то работает по принципу: туда дуй, а от туда ... В общем, уважаемые форумчане, если у кого был опыт работы с Modbus RTU, подскажите, в чем моя ошибка?
//
//
// все эксперименты на Arduino MEGA2560
// в арсенале: Ардуино Мега 2560, TTL to RS-485 module, программатор AVRISP MK II, термостат Pego EXPERT NANO 3CF
// настройки порта термостата: 9600/None/8/One
// протокол обмена: Modbus RTU (Req type = Raw, CRC order MSB -> LSB)
// боевая задача: удаленно смотреть t и менять уставку (либо +30С либо +40С)
// телеграммы термостата известны:
// запрос температуры : 01 03 01 00 00 01 85 F6
// ответ термостата : 01 03 02 01 0C B9 D1 (01 0С = 268 = 26.8С)
// запрос уставки : 01 03 03 00 00 01 84 4E
// ответ термостата : 01 03 02 01 2C B8 09 (01 2С = 300 = 30.0С)
// изменение уставки : 01 06 03 00 01 90 88 72 (01 90 = 400 = 40.0С)
// ответ термостата : 01 06 03 00 01 90 88 72 (01 90 = 400 = 40.0С)
// запрос уставки : 01 03 03 00 00 01 84 4E
// ответ термостата : 01 03 02 01 90 B9 B8 (01 90 = 400 = 40.0С)
// ...
// и так далее ...
//
//
byte TelLen;
unsigned char SerialData[28];
void setup()
{
pinMode(13,OUTPUT); // пин, отвечающий за прием/передачу 485 модуля
digitalWrite(13,LOW); // LOW = прием
Serial.begin(9600); // мониторинг происходящего во время отладки
Serial1.begin(9600); // к этому порту подключен преобразователь 485 интерфейса
}
void loop() {
digitalWrite(13,HIGH); // включаем режим передачи по 485 интерфейсу
// имитирую телеграмму запроса температуры.
// Естественно в нормаьной программе эта часть кода будет выглядеть иначе,
// например вычисление CRC ...
Serial1.print(01,HEX);
Serial1.print(03,HEX);
Serial1.print(01,HEX);
Serial1.print(00,HEX);
Serial1.print(00,HEX);
Serial1.print(01,HEX);
Serial1.print(133,HEX);
Serial1.print(246,HEX);
// для наглядности повторяю в порт мониторинга
Serial.print(01,HEX); delay(1);
Serial.print(03,HEX); delay(1);
Serial.print(01,HEX); delay(1);
Serial.print(00,HEX); delay(1);
Serial.print(00,HEX); delay(1);
Serial.print(01,HEX); delay(1);
Serial.print(133,HEX); delay(1);
Serial.println(246,HEX); delay(1);
Serial.println("---");
digitalWrite(13,LOW);
delay(100);
if (Serial1.available())
{
TelLen = 0;
while(Serial1.available() && TelLen<8)
{
SerialData[TelLen] = (char)Serial1.read();
TelLen++;
}
}
// в порт мониторинга шлю ответ от контроллера
for(byte i=0;i<TelLen;i++)
{
Serial.print(SerialData[i]);
}
Serial.println(" ");
}
Заранее благодарен за дельные ответы.
Modbus RTU использует бинарный формат данных, т.е. "сырые" байты. А вы тут строки посылаете. Посмотрите в описаниях к классу Serial как записать в порт байт или буфер. Я бы использовал write(byte) вместо print(), а ещё лучше буфер передать, тогда не будет задержек между байтами.
Похоже Вы правы!
Вот экран осциллографа, когда я с компьютера посылал телеграммы и получал вразумительные ответы от термостата:
а вот что я получил, когда пытался отправить с Ардуино:
буду рыть в сторону формата отправляемых данных ...
Если у вас есть два конвертера, то осциллограф тут не нужен. Соедините оба конвертера со стороны RS-485, поставьте на компе программку Eltima Software Serial Port Monitor и какой-нибудь эмулятор modbus. Можно для начала и без эмулятора slave. Запустите ардуину и слушайте порт в мониторе (можно даже открыть его, если сервера нет). Там в окне дампа будут видны ваши посылки.
Нельзя просто так послать фрейм модбас. Возьмите библиотеку - например здесь - http://arduino.ru/forum/programmirovanie/modbus-rs485-gotovyi-shild и все проблемы уйдут.
Можно посылать.
прошу не считать меня троллем, но вот так:
SendData[0]=0x01; SendData[1]=0x03; SendData[2]=0x01; SendData[3]=0x00; SendData[4]=0x00; SendData[5]=0x01; SendData[6]=0x85; SendData[7]=0xF6; digitalWrite(13,HIGH); // включаем режим передачи по 485 интерфейсу // имитирую телеграмму запроса температуры. // Естественно в нормаьной программе эта часть кода будет выглядеть иначе, // например вычисление CRC ... for(byte i=0;i<8;i++) { Serial1.write(SendData[i]); Serial.write(SendData[i]); }не работает ...
Проще всего доискиваться причин, когда есть данные с линии. Я правда могу исходник в Proteus промоделировать и узнать в чём дело, но мне лень и лучше вам самому доработать испытательный стенд по моим рекомендациям выше. USB-RS-485 нужно соединить с RS-485 - TTL - Arduino (соединение A-A, B-B). Со стороны USB получается COM-порт, я надеюсь. Вот к этому порту нужно подключить программный монитор порта. Запустив скетч arduino вы увидите _что_ на линии есть непосредственно.
А код с виду правильный теперь, только можно использовать другую форму вызова функции write: write( SendData, 8 ); , т.е. без использования цикла. Он там уже реализован.
П.С. Нельзя мешать в кучу вывод байта в порт RS и на терминал. Сначала выводим в порт RS, а потом отображаем в терминале. Только вот в терминал как раз можно и нужно посылать строки, иначе вы ничего не увидите. Для Serial1 используем write( buffer, count ), а для Serial используем цикл print( byte, HEX ).
А как же тайминги, прописанные в стандарте? Их как выдерживать?
А какие там тайминги? Интервал 3,5 символа от символьной скорости? Его и рассчитать можно, тем более на скорости 9600. Нужно посылать запросы с интервалом не менее 3,5 символа на выбранной символьной скорости, иначе посылки будут склеиваться на приёмной стороне. Под символом здесь понимается "битовый символ", т.е. электрический эквивалент 0 или 1 на линии.
Что касается write( buffer, count ) нужно делать ещё Serial1.flush(), т.е. подождать, пока передача не будет завершена. Запись байта непосредственно в порт идёт только в случае, если внутренний буфер и буфер USART пустые.
А ответ принять и не замесить на 485? Но это так...
Готовую посылку можно отправить через Serial.write, лучше в виде Serial.write(buf, len) и сразу ждать ответ. Ответ может быть разный. Если ошибка короче, нормальный длиннее. Но по хорошему нужно получить второй байт, убедится что не равен 0х83, получить третий байт, если не 0х83 второй, то считать еще третий байт * 2. Посчитать контрольную сумму и сравнить с принятой. Если совпадает, то использовать полученное значение. Иначе повторить запрос. Как то так.
фигушки. ни Serial1.write(SendData,8);
ни Serial1.write(SendData[i]); в порт ничего не посылают ...
осциллограф на АВ телеграмм никаких не показывает. Вот.
Смешно в другом: если к порту Serial1 относиться как просто
к порту, то и телеграммы он принимает и отправляет запросы... красота в общем.
Но стоит на него нацепить RS485 интерфейс, как он становится глух и нем...
До принятия тут ещё далеко, с передачей бы разобраться. А принимаем в обратном порядке: очищаем буфер приёма, ждём до 3.5 символа, если во время ожидания в буфере появились данные, то прибавляем их к принятым ранее и опять ждём до 3.5 символа. Если по завершению ожидания приёмный буфер пустой, то приняли все данные. Далее разбираем что пришло.
3.5 символа это пауза между посылками. Если есть такая пауза, то нужно уже обрабатывать и слать ответ.
Глух и нем бывает только если не правильный конвертер TTL-RS485 прицепить. К каким пинам у вас TTL-RS485 подключён? В спокойном состоянии обе стороны должны слушать линию. (У вас именно так). Попробуйте просто между компьютером и ардуиной через компорт и 485 пообщаться.
вот я ГОБЛИН !!! стал разбираться - перепутал RX и TX когда думая что у меня трэбл с модулем, менял один на другой ... Да:
for(byte i=0;i<8;i++) { Serial1.write(SendData[i]); delay(1); }телеграммы шлет исправно. Рою землю дальше .....
Ура! Заработало !!! (с) Шарик из Простоквашино
Код (говнокод если быть точным) шлет 1 единственную телеграмму и получает от контроллера правильный ответ !!!
Но! Пока CRC я не допилил (не сложно, в инете полно примеров) мусор не отсеивается. Скриншот работы:
и позорище:
// // // все эксперименты на Arduino MEGA2560 // в арсенале: Ардуино Мега 2560, TTL to RS-485 module, программатор AVRISP MK II, термостат Pego EXPERT NANO 3CF // настройки порта термостата: 9600/None/8/One // протокол обмена: Modbus RTU (Req type = Raw, CRC order MSB -> LSB) // боевая задача: удаленно смотреть t и менять уставку (либо +30С либо +40С) // телеграммы термостата известны: // запрос температуры : 01 03 01 00 00 01 85 F6 // ответ термостата : 01 03 02 01 0C B9 D1 (01 0С = 268 = 26.8С) // запрос уставки : 01 03 03 00 00 01 84 4E // ответ термостата : 01 03 02 01 2C B8 09 (01 2С = 300 = 30.0С) // изменение уставки : 01 06 03 00 01 90 88 72 (01 90 = 400 = 40.0С) // ответ термостата : 01 06 03 00 01 90 88 72 (01 90 = 400 = 40.0С) // запрос уставки : 01 03 03 00 00 01 84 4E // ответ термостата : 01 03 02 01 90 B9 B8 (01 90 = 400 = 40.0С) // ... // и так далее ... // // byte TelLen; unsigned char SerialData[28]; unsigned char SendData[8]; void setup() { pinMode(13,OUTPUT); // пин, отвечающий за прием/передачу 485 модуля digitalWrite(13,LOW); // LOW = прием Serial.begin(9600); // мониторинг происходящего во время отладки Serial1.begin(9600); // к этому порту подключен преобразователь 485 интерфейса } void loop() { SendData[0]=0x01; SendData[1]=0x03; SendData[2]=0x01; SendData[3]=0x00; SendData[4]=0x00; SendData[5]=0x01; SendData[6]=0x85; SendData[7]=0xF6; digitalWrite(13,HIGH); // включаем режим передачи по 485 интерфейсу // имитирую телеграмму запроса температуры. // Естественно в нормальной программе эта часть кода будет выглядеть иначе, // например вычисление CRC ... for(byte i=0;i<8;i++) { Serial1.write(SendData[i]); delay(1); } Serial.println("---"); digitalWrite(13,LOW); Serial1.flush(); delay(450); if (Serial1.available()) { TelLen = 0; SerialData[TelLen] = (char)Serial1.read(); if(SerialData[TelLen]!=0) {TelLen++;} while(Serial1.available()) { SerialData[TelLen] = (char)Serial1.read(); TelLen++; delay(1); } } if(SerialData[TelLen]==0) {TelLen--;} // в порт мониторинга шлю ответ от контроллера Serial.print(TelLen); Serial.print(" -> "); for(byte i=0;i<TelLen;i++) { Serial.print(SerialData[i], HEX); Serial.print(" "); } Serial.println(" "); }Пока так. Не ругайтесь на меня за аппаратную ошибку, виноват. В следующий раз буду внимательнее.
3,5 символа - это признак окончания передачи. Каждый байт посылки можно передавать с паузой до 3.5 символа, если вы превысите этот интервал, то приемная сторона будет считать это окончанием передачи. Отсюда и получается алгоритм приёма: ждём каждый байт 3.5 символа и не нужны ни какие лишние проверки, они делаются уже по факту приёма полного пакета. Насколько мне помнится такой алгоритм используется в freemodbus.
Так, похоже я ошибался. Решил ещё раз вернуться к стандарту (MODBUS over Serial Line Specification and Implementation Guide V1.0). Почему-то я раньше считал, что интервал 3.5 относится к битовой скорости. Судя по всему 1 символ = 11 битам (включая служебные), иначе не понять как детектировать межсимвольные ошибки (интервал t1.5).
Если у вас есть доступ к прерываниям по принятию байта, то алгоритм можно реализовать по описанию тут. Цитирую:
"Прошло t3.5 -> ждем старт-бита. Дождались старт-бита, принимаем символ. Если во время приема символа возникла ошибка t1.5 - отбрасываем и символ и фрейм, ждем t3.5 снова.
Если всё нормально -> принимаем следующий символ. Приняли фрейм без t1.5 ошибок -> ждем t3.5 и следующего фрейма."
Если у вас нет доступа к прерываниям, а работа идёт при помощи высокоуровневых функций чтения (fread(), к примеру, или приём реализован на скриптах), то низкоуровневый алгоритм вы реализовать не сможете, зато можно считать частью фрейма текущие данные в приёмном буфере и отсчитывать только 3,5 символьный интервал. В этом случае вы должны принимать данные до тех пор, пока не обнаружите 3,5 символьную "тишину" на линии. Это признак окончания передачи.
Конкретно в случае с Adruino, если не хотите писать свой обработчик прерывания, то нужно действовать по второму, описанному мной алгоритму. Сбрасываем приёмный буфер, ждём 3,5 символа, но мелкими интервалами, проверяя каждый раз есть ли данные в приёмном буфере, если есть, то добавляем их к ранее принятым и обнуляем счётчик ожидания, если нет, то продолжаем ждать все 3,5 символа. Если дождались до конца и приёмный буфер пуст - приняты все данные.
Описанный мною алгоритм приёма возникает из-за буферизации при приёме. Т.е. это чисто программная реализация. Если бы у нас была возможность точно знать момент приёма байта (используя прерывание), то мы могли бы что-нибудь придумать по поводу отслеживания 1,5 интервала. Поэтому мы используем 3,5 интервал для частей фрейма, которыми могут быть и отдельные байты.
Нужно ещё сделать оговорку. Ожидание в 3,5 символа при программной реализации работает только при реализации мастера или при единственном slave на линии. Мастер не ожидает других пакетов, поэтому может ждать сколько хочет. Единственный slave может спокойно ждать окончания текущего запроса от мастера на линии, т.к. он предназначен ему. В других ситуациях, описанных тут, такая реализация алгоритма для slave не подойдёт.
внимательно слежу за темой, так как у самого руки не доходят занятся передачей данных, вот у меня есть вопрос немного не в тему, как передать строку такого вида t1=24.2,t2=65,v1=5,v2=12.6
внимательно слежу за темой, так как у самого руки не доходят занятся передачей данных, вот у меня есть вопрос немного не в тему, как передать строку такого вида t1=24.2,t2=65,v1=5,v2=12.6
Создайте отдельную тему с полным описанием задачи. В modbus данные представляют из себя либо 16 разрядные регистры, либо биты. Для остальных случаев нужно придумывать функцию приёма/передачи строки и формат такой передачи, либо интерпретацию последовательности регистров, что не очень удобно. Это выходит за рамки типовых решений для mobus.
понял что со строкой можно наковыряться очень долго, а при помощи modbus как показания передать? если количество датчиков пока не известно (не больше 10-15) и тип у них будет int, float, bool ? возможно ли такое?
Ой, как хорошо! CRC чек отсеивает всякую ерунду и в монитор валятся только ПРАВИЛЬНЫЕ телеграммы !!!
Все жужжит как нужно, осталось:
а) оформить чтение модбас в виде функции (сейчас код в loop() )
б) написать функцию запись в регистры (думаю справлюсь, хотя черт его знает ... не серчайте, если что буду спрашивать)
в) подключить дисплей 1602 (вообще нет проблем)
г) даже не знаю что и писать. вроде все.
Вопрос: уважаемые Гуру! подскажите подавану, а зачем вообще нужны библиотеки работы с Modbus, если все действия (чтения/записи) осуществляются с помощью стандартных, нехитрых команд и алгоритмов? или я что то не понимаю?
Вопрос: уважаемые Гуру! подскажите подавану, а зачем вообще нужны библиотеки работы с Modbus, если все действия (чтения/записи) осуществляются с помощью стандартных, нехитрых команд и алгоритмов? или я что то не понимаю?
Ваш случай - частный. Master и один slave. Библиотеки содержат реализации для более сложных (общих) случаев. Там есть узкие места, которые требуют чётко придерживаться стандарта. Кроме того, в библиотеках реализован общий подход для разных функций Modbus, чтобы пользователь не думал о внутренней кухне, всех этих байтах, проверках, интервалах и пр.
Для простых нужд, как я писал выше, можно реализовать мастера и с помощью простого скрипта на bash в Linux.
понял что со строкой можно наковыряться очень долго, а при помощи modbus как показания передать? если количество датчиков пока не известно (не больше 10-15) и тип у них будет int, float, bool ? возможно ли такое?
Введение в протокол Modbus. Часть 1.
Введение в протокол Modbus. Часть 2.
понял что со строкой можно наковыряться очень долго, а при помощи modbus как показания передать? если количество датчиков пока не известно (не больше 10-15) и тип у них будет int, float, bool ? возможно ли такое?
Да. Возможно. Главное достоинство модбас очень простой, помехоустойчивый способ передачи информации между компьютером и множеством датчиков. Недостаток - только два типа данных - биты и 16 разрядные слова. Для передачи других типов их надо приводить к этим двум, а потом восстанавливать. Сделать это просто. Регистры MODBUS это просто массив uint16_t . Ничего не мешает заполнить этот массив вашей строкой t1=24.2,t2=65,v1=5,v2=12.6 и прочитать его. Или регистры заполнить данными, а строку сформировать после получения данных. Регистров более 65000. Пока не сталкивался с ситуацией чтобы их нехватало.
Или регистры заполнить данными, а строку сформировать после получения данных.
похоже самый удобный вариант подсказали, осталось разобраться как показания записать в регистр (причем несколько) а потом их считать, примерчик не подкинете случаем?
Выдалось полчасика, сделал набросок. Работает. Температуру читает и показывает. Приятно.
// // // все эксперименты на Arduino MEGA2560 // в арсенале: Ардуино Мега 2560, TTL to RS-485 module, программатор AVRISP MK II, термостат Pego EXPERT NANO 3CF // настройки порта термостата: 9600/None/8/One // протокол обмена: Modbus RTU (Req type = Raw, CRC order MSB -> LSB) // боевая задача: удаленно смотреть t и менять уставку (либо +30С либо +40С) // телеграммы термостата известны: // запрос температуры : 01 03 01 00 00 01 85 F6 // ответ термостата : 01 03 02 01 0C B9 D1 (01 0С = 268 = 26.8С) // запрос уставки : 01 03 03 00 00 01 84 4E // ответ термостата : 01 03 02 01 2C B8 09 (01 2С = 300 = 30.0С) // изменение уставки : 01 06 03 00 01 90 88 72 (01 90 = 400 = 40.0С) // ответ термостата : 01 06 03 00 01 90 88 72 (01 90 = 400 = 40.0С) // запрос уставки : 01 03 03 00 00 01 84 4E // ответ термостата : 01 03 02 01 90 B9 B8 (01 90 = 400 = 40.0С) // ... // и так далее ... // // unsigned char auchCRCLo[] = { 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 }; unsigned char auchCRCHi[] = { 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 }; byte TelLen; unsigned char SerialData[28]; unsigned char SendData[8]; String tempCurrent; unsigned short int checkSum; unsigned short int getOnlyData; byte checkSumHigh; byte checkSumLow; boolean notBad = false; // если CRC == Ok byte tryAgain = 0; // кол-во попыток чтения с термостата // // проверка контрольной суммы // unsigned short int mbCRC16(unsigned char* puchMsg, unsigned char usDataLen) { unsigned char uchCRCHi = 0xFF ; /* high byte of CRC initialized */ unsigned char uchCRCLo = 0xFF ; /* low byte of CRC initialized */ unsigned char uIndex ; uchCRCHi = 0xFF ; uchCRCLo = 0xFF ; while (usDataLen--) { uIndex = uchCRCHi ^ *puchMsg++; uchCRCHi = uchCRCLo ^ auchCRCHi[uIndex]; uchCRCLo = auchCRCLo[uIndex]; } return ( uchCRCLo<< 8 | uchCRCHi) ; } unsigned short int getModbus(unsigned char *getMsg, unsigned char LenTel) { unsigned char DataHi = 0xFF ; // Если не распознали ничего, то unsigned char DataLo = 0xFF ; // шлем 0xFF 0xFF tryAgain=0; while(tryAgain<10) // даю 10 попыток для чтения, если ошибки { tryAgain++; digitalWrite(13,HIGH); // включаем режим передачи по 485 интерфейсу for(byte i=0;i<LenTel;i++) { Serial1.write(getMsg[i]); delay(1); } digitalWrite(13,LOW); Serial1.flush(); delay(450); if (Serial1.available()) { TelLen = 0; SerialData[TelLen] = (char)Serial1.read(); if(SerialData[TelLen]!=0) {TelLen++;} while(Serial1.available()) { SerialData[TelLen] = (char)Serial1.read(); TelLen++; delay(1); } } if(SerialData[TelLen]==0) {TelLen--;} checkSum = mbCRC16(&SerialData[0],TelLen-2); checkSumLow = checkSum & 0xFF; // младший байт контрольной суммы checkSumHigh = checkSum>>8 & 0xFF; // старший байт контрольной суммы if(SerialData[TelLen-2] == checkSumLow && SerialData[TelLen-1]== checkSumHigh) { checkSum = 0; DataLo = SerialData[TelLen-4]; DataHi = SerialData[TelLen-3]; tryAgain=10; } else { DataLo = 0xFF; DataHi = 0xFF; } delay(100); } return ( DataLo<< 8 | DataHi); } void setup() { pinMode(13,OUTPUT); // пин, отвечающий за прием/передачу 485 модуля digitalWrite(13,LOW); // LOW = прием Serial.begin(9600); // мониторинг происходящего во время отладки Serial1.begin(9600); // к этому порту подключен преобразователь 485 интерфейса } void loop() { SendData[0]=0x01; SendData[1]=0x03; SendData[2]=0x01; SendData[3]=0x00; SendData[4]=0x00; SendData[5]=0x01; SendData[6]=0x85; SendData[7]=0xF6; getOnlyData = getModbus(&SendData[0],8); tempCurrent = String (getOnlyData, DEC); Serial.print(tempCurrent); Serial.println(" "); delay(3000); }Код далек от совершенства, но работает и достаточно прост для понимания "чайниками", такими как я. Завтра буду писать функцию записи (CRC нужно будет вычислять до передачи в функцию записи, а в остальном думаю не сложно .......)
Или регистры заполнить данными, а строку сформировать после получения данных.
похоже самый удобный вариант подсказали, осталось разобраться как показания записать в регистр (причем несколько) а потом их считать, примерчик не подкинете случаем?
https://github.com/smarmengol/Modbus-Master-Slave-for-Arduino/blob/maste...
Посмотрите здесь. Хорошая библиотека. В примере выдаётся массив 16 элементов по запросу мастера. Если в цикле loop массиву присваивать значения датчиков, то мастер будет получать актуальные значения. По стандарту массив может иметь более 65000 элементов, но считывать за один раз можно не более 100. Если нужно больше то частями по 100.
Кому не спится в ночь глухую? ... таксисту!, жулику! и ....! я тоже между прочим не сплю!
Вот что получилось в итоге (пока мониторю через сериал порт):
вот что на рабочем столе:
ну и код соответственно (може кто чего для себя полезного узнает ... хотя и так все понятно, особенно теперь):
// // // все эксперименты на Arduino MEGA2560 // в арсенале: Ардуино Мега 2560, TTL to RS-485 module, программатор AVRISP MK II, термостат Pego EXPERT NANO 3CF // настройки порта термостата: 9600/None/8/One // протокол обмена: Modbus RTU (Req type = Raw, CRC order MSB -> LSB) // боевая задача: удаленно смотреть t и менять уставку (либо +30С либо +40С) // телеграммы термостата известны: // запрос температуры : 01 03 01 00 00 01 85 F6 // ответ термостата : 01 03 02 01 0C B9 D1 (01 0С = 268 = 26.8С) // запрос уставки : 01 03 03 00 00 01 84 4E // ответ термостата : 01 03 02 01 2C B8 09 (01 2С = 300 = 30.0С) // изменение уставки : 01 06 03 00 01 90 88 72 (01 90 = 400 = 40.0С) // ответ термостата : 01 06 03 00 01 90 88 72 (01 90 = 400 = 40.0С) // запрос уставки : 01 03 03 00 00 01 84 4E // ответ термостата : 01 03 02 01 90 B9 B8 (01 90 = 400 = 40.0С) // ... // и так далее ... // // unsigned char auchCRCLo[] = { 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 }; unsigned char auchCRCHi[] = { 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 }; byte TelLen; unsigned char SerialData[28]; unsigned char SendData[8]; String tempCurrent; unsigned short int checkSum; unsigned short int getOnlyData; byte checkSumHigh; byte checkSumLow; byte tryAgain = 0; // кол-во попыток чтения с термостата // // проверка контрольной суммы // unsigned short int mbCRC16(unsigned char* puchMsg, unsigned char usDataLen) { unsigned char uchCRCHi = 0xFF ; /* high byte of CRC initialized */ unsigned char uchCRCLo = 0xFF ; /* low byte of CRC initialized */ unsigned char uIndex ; uchCRCHi = 0xFF ; uchCRCLo = 0xFF ; while (usDataLen--) { uIndex = uchCRCHi ^ *puchMsg++; uchCRCHi = uchCRCLo ^ auchCRCHi[uIndex]; uchCRCLo = auchCRCLo[uIndex]; } return ( uchCRCLo<< 8 | uchCRCHi) ; } unsigned short int getModbus(unsigned char *getMsg, unsigned char LenTel) { unsigned char DataHi = 0xFF ; // Если не распознали ничего, то unsigned char DataLo = 0xFF ; // шлем 0xFF 0xFF tryAgain=0; // добавляем к телеграмме контрольную сумму (последние 2 байта - младший и старший) checkSum = mbCRC16(&getMsg[0],LenTel); checkSumLow = checkSum & 0xFF; // младший байт контрольной суммы checkSumHigh = checkSum>>8 & 0xFF; // старший байт контрольной суммы getMsg[LenTel]=checkSumLow; // добавляем в массив телеграммы младший байт контрольной суммы getMsg[LenTel+1]=checkSumHigh; // добавляем в массив телеграммы старший байт контрольной суммы LenTel=LenTel+2; while(tryAgain<10) { tryAgain++; digitalWrite(13,HIGH); // включаем режим передачи по 485 интерфейсу for(byte i=0;i<LenTel;i++) { Serial1.write(getMsg[i]); delay(2); //Serial.print(getMsg[i],HEX); } digitalWrite(13,LOW); Serial1.flush(); delay(450); if (Serial1.available()) { TelLen = 0; SerialData[TelLen] = (char)Serial1.read(); if(SerialData[TelLen]!=0) {TelLen++;} while(Serial1.available()) { SerialData[TelLen] = (char)Serial1.read(); TelLen++; delay(1); } } if(SerialData[TelLen]==0) {TelLen--;} checkSum = mbCRC16(&SerialData[0],TelLen-2); checkSumLow = checkSum & 0xFF; // младший байт контрольной суммы checkSumHigh = checkSum>>8 & 0xFF; // старший байт контрольной суммы if(SerialData[TelLen-2] == checkSumLow && SerialData[TelLen-1]== checkSumHigh) { checkSum = 0; DataLo = SerialData[TelLen-4]; DataHi = SerialData[TelLen-3]; tryAgain=10; } else { DataLo = 0xFF; DataHi = 0xFF; } // Serial1.flush(); delay(100); } return ( DataLo<< 8 | DataHi); } void setup() { pinMode(13,OUTPUT); // пин, отвечающий за прием/передачу 485 модуля digitalWrite(13,LOW); // LOW = прием Serial.begin(9600); // мониторинг происходящего во время отладки Serial1.begin(9600); // к этому порту подключен преобразователь 485 интерфейса } void loop() { // запрашиваем значение температуры термостата SendData[0]=0x01; SendData[1]=0x03; SendData[2]=0x01; SendData[3]=0x00; SendData[4]=0x00; SendData[5]=0x01; getOnlyData = getModbus(&SendData[0],6); tempCurrent = String (getOnlyData, DEC); Serial.print("t: "); Serial.print(tempCurrent); Serial.println(" "); delay(500); // запрашиваем значение уставки термостата SendData[0]=0x01; SendData[1]=0x03; SendData[2]=0x03; SendData[3]=0x00; SendData[4]=0x00; SendData[5]=0x01; getOnlyData = getModbus(&SendData[0],6); tempCurrent = String (getOnlyData, DEC); Serial.print("hi t: "); Serial.print(tempCurrent); Serial.println(" "); delay(500); // запрашиваем значение гистерезиса термостата SendData[0]=0x01; SendData[1]=0x03; SendData[2]=0x03; SendData[3]=0x01; SendData[4]=0x00; SendData[5]=0x01; getOnlyData = getModbus(&SendData[0],6); tempCurrent = String (getOnlyData, DEC); Serial.print("r0: "); Serial.print(tempCurrent); Serial.println(" "); delay(500); // запрашиваем значение мин температуры (авария) термостата SendData[0]=0x01; SendData[1]=0x03; SendData[2]=0x03; SendData[3]=0x02; SendData[4]=0x00; SendData[5]=0x01; getOnlyData = getModbus(&SendData[0],6); tempCurrent = String (getOnlyData, DEC); Serial.print("A1 t: "); Serial.print(tempCurrent); Serial.println(" "); delay(500); // запрашиваем значение макс температуры (авария) термостата SendData[0]=0x01; SendData[1]=0x03; SendData[2]=0x03; SendData[3]=0x03; SendData[4]=0x00; SendData[5]=0x01; getOnlyData = getModbus(&SendData[0],6); tempCurrent = String (getOnlyData, DEC); Serial.print("A2 t: "); Serial.print(tempCurrent); Serial.println(" "); delay(3000); }Здравствуйте. Не могли бы Вы, написать контакты, по которым можно с Вами связаться? Очень нужно у Вас уточнить кое-какие вопросы. Спасибо.
оживлю немного темку.
есть некое устройство, назовем его контроллер. мастер. его можно спросить... он должен ответить... все верно ?
тоже интересно, например как настроить com port
Протокол как бы стандартный? т.е. в ячейке 0х85 например всегда данные температуры.
битый час пытаюсь заставить устройство отвечать..
Дело не в том как настроить порт. Главное какие байты послать для того,что бы устройство ответило. Поставте на комп программу QMODBUS. Установите скорость порта, выберите команду читать, выберите ячейку 85 и отправте запрос. Еслиустройство ответит,то в логах на экране будут цифры посланные для запроса и цифры ответа. Ихбудет гораздо больше чем вы ожидаете. Это потому что протокол. Их и надо посылать,что бы устройство ответило.
Подниму старую тему, она очень схожа с моей проблемой. Так же пытаюсь управлять терморегулятором по RS485 через ModBus RTU. С компьютера через терминал устройства отлично работают. Но при попытке ими управлять через Arduino, что то идет не так, в терминале видно что передача исправно идет с верными данными, но несмотря на это термостат не отвечает. Байты отправляю на прямую с интервалом 10 мс, но пробовал разные значения
byte SendData[8]; void setup() { Serial.begin(9600); } void loop() { SendData[0]=0x01; SendData[1]=0x03; SendData[2]=0x01; SendData[3]=0x00; SendData[4]=0x00; SendData[5]=0x01; SendData[6]=0x85; SendData[7]=0xF6; digitalWrite(13,HIGH); for(byte i=0;i<8;i++){ Serial.write(SendData[i]); delay(10); } digitalWrite(13,LOW); Serial.flush(); delay(1450); }Подозреваю что проблема в таймингах, подскажите, пожалуйста, как будет правильнее отправлять запрос и получать ответ? Стоит использовать готовую библиотеку? Какую посоветуете?
Спасибо!
Делей лишний. Почитайте стандарт. Я не точно не помню, но чтотто типа 2.5 мс между символами это ошибка передачи.
byte SendData[8]; void setup() { Serial.begin(9600); } void loop() { SendData[0]=0x01; SendData[1]=0x03; SendData[2]=0x01; SendData[3]=0x00; SendData[4]=0x00; SendData[5]=0x01; SendData[6]=0x85; SendData[7]=0xF6; digitalWrite(13,HIGH); for(byte i=0;i<8;i++){ Serial.write(SendData[i]); } delay(9); // тут придется поэксперементировать digitalWrite(13,LOW); delay(100); while (Serial.available()){ // читаем полученные данные } }Юморист :) А чтение у вас где ?
Кроме того, нога чтение-запись, вы где ее дергаете ? У вас шилд какой ? Если это нога 13, то как вы убеждаетесь, что у вас все данные ушли ?
Чтение от сюда убрал, разобраться бы сначала с отправкой, нога 13 все верно, убеждаюсь подключаясь через usb-rs485 конвертер вижу в терминале верную посылку, но термостат на это не реагирует. По всему видимо проблема в таймингах, терминалу то на них все равно, а термостату важно.. Какую библиотеку попробовать, чтобы иметь возможность отправлять просто произвольные 8 байт?
Вы что думаете я вам ваш код скопировал. Посмотрите внимательнее.
Немного отличается задержками, но результат тот же, в терминал приходит, но термостат такие команды игнорирует.
Прочитать 1 регистр первого слейва с адреса 1 будет последовательность байт ( без контрольной суммы) 01 03 00 01 00 01 . У Вас 01 03 01 00 00 01 - с адреса 4096. Точно по этому адресу у слейва есть информация?
У моего термостата своеобразный взгляд на ModBus RTU, и даже на подсчет контрольной суммы, или просто я не понимаю их.. https://ae01.alicdn.com/kf/HTB1.1GEKFXXXXXpXVXXq6xXFXXXl/220662474/HTB1.1GEKFXXXXXpXVXXq6xXFXXXl.jpg?size=392926&height=1852&width=1000&hash=0f7201225c6cd1c424e54a58e9d192b4
Удалось достучаться до него, и получить какой то ответ, не очень стабильно но что то получается, буду разбираться в этом протоколе, и пытаться извлечь температуру..
Это не rtu. Ни слова про тайминги и кодировку.
Да там об этом нет, но в названии термостата упоминалось именно ModBus RTU, так что предполагаю это такая вариация, с измененным порядком байт и другим способом подсчета контрольной суммы..
Вариации быть не может. Модбас это стандарт с точным описанием. А то как в анекдоте - ...и не преф а в очко.
У вас устройство работает на расширении мод баса. Иными словами, модбас допускает использование расширенного перечня команд, но должно поддерживать и стандартные. Ваше устройство стандартные не поддерживает.
Из вашего описания видно, что термостат принимает принимает команды от 0xA0 до 0хA7. Эти команды не описаны в стандарте модбас, но допускается , что такие команды могут быть активированы производителем. Далее контрольная сумма вычисляется по правилам модбас (не стал углубляться, но очень похоже). Далее, в руководстве же написано , что дефолтная скорость передачи 4800.
Теперь ответьте на вопросы:
ПОЧЕМУ ВЫ НАСТРАИВАЕТЕ ПОРТ НА СКОРОСТЬ 9600 ?
ПОЧЕМУ ВЫ ВЫДАЕТЕ ФУНКЦИЮ 1, тогда как судя по описанию устройство этих функций не обрабатывает ?
ПОЧЕМУ ВЫ СЧИТАЕТЕ, ЧТО АДРЕС ВАШЕГО ТЕРОМОСТАТА 1 ?
ПОЧЕМУ ВЫ СПРАШИВАЕТЕ, имея описание, но не читая его ?
Устройство перевёл на 9600, это допускается по описанию, и удобнее учитывая другие термостаты на 9600 на линии, но так же пробовал соединяться и на исходных 4800, оба варианта работают одинаково не стабильно.
Запросы посылал совершенно разные, отвечает на A0 01 01 00 00 00 00 07 и устанавливает температуру 25 градусов: A6 01 01 00 00 19 00 64, при этом, контрольные суммы тут не сходятся с теми что должны быть по стандарту ModBus.
Адрес моего термостата состоит из двух байт оба 01, адрес отправляется вторым и третьим байтом запроса.
Читал, но плохо понимаю, не могу понять как считать контрольную сумму, это какой то стандарт? Существует ли готовый калькулятор? Не понимаю как вытащить из ответа 50 01 01 71 00 19 17 56 температуру и режим работы.
Контрольная сумма, чего уж проще:
uint8_t cs(uint8_t* data, uint8_t len){ uint8_t ret=0; for(uint8_t i=0;i<len;i++){ ret+=data[i]; } return ret^0xA5; }Читал, но плохо понимаю, не могу понять как считать контрольную сумму, это какой то стандарт? Существует ли готовый калькулятор? Не понимаю как вытащить из ответа 50 01 01 71 00 19 17 56 температуру и режим работы.
На какой запрос пришел этот ответ ?
Запросить все данные, судя по описанию, вы можете командой A0 01 01 00 00 00 00 07 , в ответ должен прийти пакет 50 01 01 ?? ?? ?? ?? CS
А вот расшифровка ответа именно на команду A0 в вашем руководстве отсутствует.
Да спасибо, 50 01 01 71 00 19 17 56 получаю в ответ на A0 01 01 00 00 00 00 07, соответственно 71 00 19 содержит всю информацию об устройстве..
Нет вся инфа будет в 4 байтах.
typedef enum { tAUTO = 0, tHIGH, tMEDIUM, tLOW } termostate_mode; typedef struct{ uint8_t data[4]={0}; termostate_mode getMode(){ return (termostate_mode)(data[0]&0x3);} bool isPanelLock() {return data[0]&0x4;} bool isStandby() {return data[0]&0x8;} bool isPowerOn() {return data[0]&0x10;} bool isCooling() {return data[0]&0x20;} uint8_t getCompensationTemp(){return (int8_t)data[1];} uint8_t getCurrentTemp(){return (int8_t)data[2];} uint8_t getStanbyTemp(){return (int8_t)data[3];} } termostate; termostate* inTermData; void setup() { Serial.begin(115200); } void loop() { uint8_t getData[]={0x50, 0x01, 0x01, 0x71, 0x00, 0x19, 0x17, 0x56}; inTermData=(termostate*)&getData[3]; Serial.print("Temperature:");Serial.println(inTermData->getCurrentTemp()); Serial.print("Power:"); if(inTermData->isPowerOn()){Serial.println("ON");}else{Serial.println("OFF");} Serial.print("Mode:"); switch (inTermData->getMode()) { case tAUTO: Serial.println("AUTO");break; case tHIGH: Serial.println("HIGH");break; case tMEDIUM: Serial.println("MEDIUM");break; default: Serial.println("LOW"); } Serial.print("Working mode:"); if(inTermData->isCooling()){Serial.println("COLLING");}else{Serial.println("HEATING");} Serial.print("Temperature now:");Serial.println(inTermData->getCurrentTemp()); Serial.print("Stanby temperature:");Serial.println(inTermData->getStanbyTemp()); Serial.print("Compensation temperature:");Serial.println(inTermData->getCompensationTemp()); Serial.print("Panel:"); if(inTermData->isPanelLock()){Serial.println("LOCK");}else{Serial.println("ACTIVE");} Serial.println(); delay(10000); }Не ну я не понял - угадал я или нет ?