Re: MODBUS RTU - SLAVE

2024-11-09T15:17:34+01:00

Cześć,
Mirku dziękuję za sprostowanie, faktycznie napisałem to dość nie precyzyjnie, bo faktycznie z mojego opisu wynika, że w skład ramki wchodzi ten odstęp:)
Tak dokładnie chciałem przekazać, że czas pomiędzy ramkami nie może być krótszy niż 3,5 znaku.
Generalnie chciałem przekazać jak na poniższym rysunku:

Dzięki:)

Pozdrawiam
Serdecznie

Statystyki: Napisane przez Artur_26 — 9 lis 2024, o 15:17

Re: MODBUS RTU - SLAVE

2024-11-09T11:41:55+01:00

No to kolega ślicznie pojechał z opisem i teorią modbusa, brawo.

Jedyne co podpowiem to odnośnie samego początku, bo napisałeś troszkę może nieprecyzyjnie:

Artur_26 napisał(a):

Każdą wiadomość rozpoczyna i kończy tzw. cisza na łączu. Jest to czas bezczynności,
trwający 3,5 x czas pojedynczego znaku.

Wynikałoby z tego opisu że po pierwsze ta cisza to składnik ramki a gorsze, że musi wystąpić dwa razy, chyba że źle rozumiem twoje słowa.

CISZA w modbus rtu to rzeczywiście 3,5 znaku ale nie ma to nic wspólnego z samą ramką. To chodzi o CZAS między ramkami, i to czas MINIMALNY, nie powinien być krótszy niż 3,5 znaku, za to może być czas ciszy swobodnie dłuższy niż 3,5 znaku.

Oznacza to że np przy 9600 minimalny czas >= 3,5ms musi być zapewniony między ramkami

Statystyki: Napisane przez mirekk36 — 9 lis 2024, o 11:41

MODBUS RTU - SLAVE

2024-11-09T02:41:44+01:00

Hej,
witam wszystkich forumowiczów, dawno mnie tu nie było
Chciałbym się z wami podzielić tym czego dowiedziałem się na temat MODBUS RTU.
Tworzę sobie mały układ, który będzie Serwerem MODBUS i przy okazji musiałem trochę wgryźć się w temat:)

Może komuś się przyda, a po drugie może ktoś zweryfikuje czy nie piszę głupot:)

Przepraszam za nie uporządkowany wygląd postu ale miałem ładnie poukładane, to jak wkleiłem treść, wszystko się porozjeżdżało
Jest na to jakiś sposób??

Wszystko co tu opisałem jest na podstawie :

strony http://www.modbus.org

MODBUS APPLICATION PROTOCOL SPECIFICATION V1.1b3

oraz https://www.modbustools.com/modbus.html

Założenie : serwer MODBUS RTU nie musi posiadać obsługi wszystkich rozkazów MODBUS wymienionych
w standardzie.

/*****************************************************************************************************************

Opis budowy ramki MODBUS RTU
[syntax=c]| START | Adres | Funkcja | Dane | CRC | STOP |

| 3,5 ramki UART | 1 bajt | 1 bajt | n x bajtów | 2 bajty | 3,5 ramki UART |[/syntax]

Każdą wiadomość rozpoczyna i kończy tzw. cisza na łączu. Jest to czas bezczynności,
trwający 3,5 x czas pojedynczego znaku.

Odstęp pomiędzy wysyłanymi znakami nie może być dłuższy niż 1,5 x czas pojedynczego znaku.

Czas ten jest zależny od ustawienia transmisji:

- BAUDRATE
- ilość bitów danych danych (założenie - 8 bitów)
- czy jest bit parzystości (założenie - brak)
- ile jest bitów stopu (założenie - 1 bit)

Najdłuższa ramka UART 12 bitów:

| START | Bit 1 | Bit 2 | Bit 3 | Bit 4 | Bit 5 | Bit 6 | Bit 7 | Bit 8 | parzystość | STOP | STOP |

przy założeniu założeniach podanych wyżej, długość ramki wynosi: 10 bitów

| START | Bit 1 | Bit 2 | Bit 3 | Bit 4 | Bit 5 | Bit 6 | Bit 7 | Bit 8 | STOP |

obliczenie czasu trwania jednej ramki UART:

t = (1/BAUDRATE)[s]

t3,5 = 3,5 * t = 3,5 * (1/BAUDRATE)

Przykładowo dla BAUDRATE = 9600 i długości ramki 10 bitów:

t = (1/9600) = 1041,6667 mikro sekundy
t1,5 = 1,5 * 1041,6667 = 1562,5 mikro sekundy
t3,5 = 3,5 * 1041,6667 = 3645,8333 mikro sekundy

Maksymalna długość ramki MODBUS RTU dla RS232 / RS485 to: 256 bajtów

- 1 bajt adres SLAVE
- 1 bajt kod funkcji (rozkaz)
- 252 bajty dane
- 2 bajty suma kontrolna CRC

Co reprezentują przesyłane wartości w polu "DANE" zależy od konkretnej funkcji, która ma być wykonana.
Np. adres początkowy, liczbę zmiennych, offsets, dane do zapisu rejestrów itp.

Dane mogą być 8 bitowe lub 16 bitowe.

Dane 16 bitowe dzielone są na bajty i wysyłane w kolejności: Hi Lo

Suma CRC jest 16 bitowa i wysyłana w kolejności: Lo Hi

przykład ramki:
[syntax=c]| Adres | Funkcja | Dane | CRC |
| 0x02 | 0x03 | Hi Dana1 | Lo Dana1| Hi Dana2 | Lo Dana2| Hi Dana3 | Lo Dana3| Hi Danan| Lo Danan| Lo CRC | Hi CRC|[/syntax]

Ramki MODBUS RTU podzielone są na 3 rodzaje:

- zapytanie, {adres slave, kod fukcji, dane, CRC}

- odpowiedź, {adres slave, kod fukcji, dane, CRC}

- odpowiedź na "wyjątek" - zwraca się kod błędu {adres slave, kod funkcji wyjątku, kod błędu }

kod funkcji wyjątku = 0x80 + kod funkcji MODBUS np. 0x80 + 0x03 = 0x83
kod błędu - opisane poniżej

Kiedy klient wysyła zapytanie do serwera, to oczekuje poprawnej odpowiedzi.
Mogą być 4 odpowiedzi:

1. Jeśli serwer otrzyma zapytanie bez błędu komunikacji, to zwraca poprawną odpowiedź

2. Jeśli serwer nie otrzyma zapytania z powodu błędu komunikacji, to nie zwraca żadnej odpowiedzi
Klient stwierdzi, że został przekroczony TIME-OUT.

3. Jeśli serwer otrzyma zapytanie ale sumy CRC nie będą się zgadzać, to nie zwraca żadnej odpowiedzi
Klient stwierdzi, że został przekroczony TIME-OUT.

4. jeśli serwer otrzyma zapytanie bez błędu komunikacji, ale nie może go obsłużyć, to zwróci
odpowiedź z kodem błędu.

Kody błędów:

0x01 ILLEGAL FUNCTION serwer nie obsługuje kodu funkcji zawartego w zapytaniu
0x02 ILLEGAL DATA ADDRESS adres danych otrzymany w zapytaniu jest nie poprawny lub podany
adres z ilością rejestrów do odczytu jest nie poprawny.
Np. serwer ma 100 rejestrów (adresy od 0 do 99), a w zapytaniu
podajemy adres 101 lub podajemy adres 90 a ilość rejestrów
do odczytu 20.

0x03 ILLEGAL DATA VALUE dana (dane) zawarte w zapytaniu nie są dopuszczalne dla serwera
Np. przekroczona wartość jakiejś nastawy

0x04 SERVER DEVICE FAILURE Wystąpił nieodwracalny błąd, gdy serwer próbował wykonać
żądaną akcję

0x05 ACKNOWLEDGE opis str. 48 dokumentu źródłowego
0x06 SERVER DEVICE BUSY opis str. 48 dokumentu źródłowego
0x08 MEMORY PARITY ERROR opis str. 48 dokumentu źródłowego
0x0A GATEWAY PATH UNAVAILABLE opis str. 49 dokumentu źródłowego
0x0B GATEWAY TARGET DEVICE opis str. 49 dokumentu źródłowego
FAILED TO RESPOND

Typy danych w MODBUS (Teoria)

W protokole MODBUS zdefiniowano 2 rodzaje danych
- cewki
- rejestry

Każdy rodzaj danych ma przypisane zakresy adresów.

UWAGA: TO JAKIE DANE I W JAKICH ADRESACH BĘDĄ WYKOŻYSTANE DANE OKREŚLONE JEST PRZEZ TWÓRCĘ "SLAVE"

Cewki - reprezentują bity - mogą reprezentować stany fizyczne wejść, wyjść
Rejestry - 16 bitowe - mogą być tylko odczytywane lub odczytywane i zapisywane.
Jakie mają znaczenie to zależy od twórcy

[syntax=c]+-----------------------------------------------------------------------------------------------------------------------------------+
| Typ zmiennej | Rodzaj zmiennej | operacja | Zastosowanie | Nr cewki/rejestru | Adres w HEX |
|-----------------------+-------------------+---------------------+---------------------------+----------------------+--------------|
| Cewka wejściowa | 1 bit | tylko do odczytu | wejścia/wyjścia | 1 - 9999 | 0000 - 270E |
| Discretes Input | | | urządzeń | | |
|-----------------------+-------------------+---------------------+---------------------------+----------------------+--------------|
| Cewka wyjściowa | 1 bit | odczyt / zapis | wyjścia urządzeń | 10001 - 19999 | 0000 - 270E |
| Coils | | | wewnętrzne flagi | | |
|-----------------------+-------------------+---------------------+---------------------------+----------------------+--------------|
| Rejestry wejściowe | 16 bitów | tylko do odczytu | liczbowa reprezentacja | 30001 - 39999 | 0000 - 270E |
| Input Registers | | | stanów wejść/wyjść | | |
|-----------------------+-------------------+---------------------+---------------------------+----------------------+--------------|
| Rejestry pamiętające | 16 bitów | odczyt / zapis | odczyty i zapisy | 40001 - 49999 | 0000 - 270E |
| Holding Registers | | | rejestró wewnętrznych | | |
| | | | parametryzacja urządzenia | | |
+-----------------------------------------------------------------------------------------------------------------------------------+[/syntax]

TAK NAPRAWDĘ TO OD NAS ZALEŻY JAK SOBIE ZORGANIZUJEMY PAMIĘĆ, ALE MUSIMY SIĘ TRZYMAĆ ZASAD
I PRZEDEWSZYSTKIM OPISAĆ M A P Ę P A M I Ę C I, CZYLI OKREŚLIĆ CO ZA CO ODPOWAIDA
A TO WSZYSTJKO ZALEŻY OD TEGO CO DANY UKŁAD MA ROBIĆ.

Opisy kodów funkcji MODBUS - nie wszystkie są wymienione

Kody funkcji mogą przyjmować wartość od 1 do 127

Kody funkcji dzielimy na:
- Public Function Codes - kody funkcji publiczne zakres 1 - 64 i 111 - 127
- User-Defined Function Codes - definiowane przez użytkownika zakres 65 - 72 i 100 - 110
- Reserved Function Codes - kody zastrzeżone

KODY PUBLICZNE - najbardziej przydatne (moim zdaniem) a i tak nie wszystkie się wykorzystuje

0x01 Read Coils - odczyt wyjść bitowych
0x02 Read Discrete Inputs - odczyt wejść bitowych
0x03 Read Holding Registers - odczyt rejestrów z podanego zakresu
0x04 Read Input Register - odczyt rejestrów wejściowych
0x05 Write Single Coil - zapis pojedynczego bitu
0x06 Write Single Register - zapis pojedynczego rejestru
0x07 Read Exception status - odczyt statusu wyjątku urządzenia SLAVE
0x08 Diagnostic - test diagnostyczny
0x0F Write Multiple Coils - zapis bitów z podanego zakresu
0x10 Write Multiple Registers - zapis rejestrów z podanego zakresu
0x11 Report Server ID - identyfikacja urządzenia SLAVE
0x17 Read/Write Multiple Registers

Pozostałe kody w tabeli na stronie 11 podanego wcześniej dokumentu.

Przykłady jak wyglądają ramki dla konkretnych kodów funkcji: źródło https://www.modbustools.com/modbus.html

Przykład kod funkcji 0x03

Zapytanie z MASTER: HEX

Slave Address 01
Function 03
Starting Address Hi 00
Starting Address Lo 00
Quantity of Registers Hi 00
Quantity of Registers Lo 02
Error Check Lo C4
Error Check Hi 0B

Total Bytes 8

Wyliczenie adresu początkowego : Adres, który chcemy odczytać - Adres pierwszego rejestru
czyli 4001 - 4001 = 0 dlatego :
Starting Address Hi 0x00
Starting Address Lo 0x00

jeśli chcielibyśmy czytać od adresu 4020 to robimy obliczenie : 4020 - 4001 = 19 (0x13) i wtedy byłoby:
Starting Address Hi 0x00
Starting Address Lo 0x13

Odpowiedź od SLAVE: HEX

Slave Address 01
Function 03
Byte Count 04
Data Hi 00
Data Lo 06
Data Hi 00
Data Lo 05
Error Check Lo DA
Error Check Hi 31

Total Bytes 9

Przykład kod funkcji 0x16

Zapytanie z MASTER: HEX

Slave Address 11
Function 10
Starting Address Hi 00
Starting Address Lo 01
Quantity of Registers Hi 00
Quantity of Registers Lo 02
Byte Count 04
Data Hi 00
Data Lo 0A
Data Hi 01
Data Lo 02
Error Check Lo C6
Error Check Hi F0

Total Bytes 13

Wyliczanie sumy CRC

Sumę CRC wylicza się z:
- Adresu SLAVE
- kodu funkcji
- danych

np: HEX
Slave Address 11
Function 10
Starting Address Hi 00
Starting Address Lo 01
Quantity of Registers Hi 00
Quantity of Registers Lo 02
Byte Count 04
Data Hi 00
Data Lo 0A
Data Hi 01
Data Lo 02

Wynikiem obliczeń jest :
HEX
Error Check Lo C6
Error Check Hi F0

******************************************************************************************************************/

i jeszcze funkcja do obliczania CRC na podstawie http://www.modbus.org
wynik 16 bitowy - przy czym starszy bajt to Lo CRC a młodszy bajt to Hi CRC

[syntax=c]ifndef CRC16_MODBUS_H_
#define CRC16_MODBUS_H_

uint16_t CRC16(volatile char *adres, uint8_t usDataLen); // dlatego volatile, bo przekazuję bufor z UARTA, który jest volatile

#endif /* CRC16_MODBUS_H_ */[/syntax]

[syntax=c]#include
#include
#include "CRC16_MODBUS.h"

const uint8_t tab_CRCHi[] PROGMEM = {
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
};

const uint8_t tab_CRCLo[] PROGMEM = {
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
};

uint16_t CRC16(volatile char *adres, uint8_t DataLen)
{
uint8_t CRCHi = 0xFF; /* high byte of CRC initialized */
uint8_t CRCLo = 0xFF; /* low byte of CRC initialized */
uint8_t Index; /* will index into CRC lookup table */

while (DataLen--)
{
Index = CRCHi ^ *adres++; /* calculate the CRC */
CRCHi = CRCLo ^ pgm_read_byte(tab_CRCHi + Index);
CRCLo = pgm_read_byte(tab_CRCLo + Index);
}

return ((uint16_t) (CRCHi << 8) | (uint16_t) CRCLo);
}[/syntax]

Statystyki: Napisane przez Artur_26 — 9 lis 2024, o 02:41

ATNEL tech-forum

Re: MODBUS RTU - SLAVE

Re: MODBUS RTU - SLAVE

MODBUS RTU - SLAVE