ATNEL tech-forum

Re: Modbus + LCD

2017-01-18T11:44:53+01:00

Dla potomnych
Więc biblioteka SimpleModbusSlave.h obsługuje funkcje F16 oraz liczby ujemne... ale w głównym programie należy sobie zmienić z unsigned int holdingRegs[HOLDING_REGS_SIZE]; na int holdingRegs[HOLDING_REGS_SIZE];

Ale co do wyświetlania po przecinku to mam pytanie bo chce przesłać liczbę -22,22 to chciałem zrobić w ten sposób że mnożę x100 i mam -2222 którą wysyłam po modbasie ale jest problem z odwroceniem
[syntax=c]int x = holdingRegs[reg1_VAL];
int y = x/100;
int z = x%100;
tft.print(y); tft.print("."); tft.print(z); tft.print(" ");[/syntax]

bo jest problem ze znakiem "-" który pojawia się w całości i reszcie

a może jest inny sposób na zrobienie tego??

Mam jeszcze jedno pytanie odnośnie komendy modbus_update();
Mimo że nie wysyłam nic po modbus-sie to on wyświetla ostatnią zapamiętaną wartość jak sie tego pozbyć?

Statystyki: Napisane przez endurasek — 18 sty 2017, o 11:44

Re: Modbus + LCD

2017-01-12T21:34:01+01:00

No i fajnie, że działa. Musi działać. Modbus jest fajny.

F16 i liczby ujemne to już z górki

Statystyki: Napisane przez skalarro — 12 sty 2017, o 21:34

Re: Modbus + LCD

2017-01-12T21:23:48+01:00

Co do zmiany adresu miałeś rację ale trochę inny miał być a wynika to z tego...

Read Holding Registers (FC=03)

Request

This command is requesting the content of analog output holding registers # 40108 to
40110 from the slave device with address 17.

11 03 006B 0003 7687

11: The Slave Address (11 hex = address17 )
03: The Function Code 3 (read Analog Output Holding Registers)
006B: The Data Address of the first register requested.
( 006B hex = 107 , + 40001 offset = input #40108 )
0003: The total number of registers requested. (read 3 registers 40108 to 40110)
7687: The CRC (cyclic redundancy check) for error checking.

Response

11 03 06 AE41 5652 4340 49AD

11: The Slave Address (11 hex = address17 )
03: The Function Code 3 (read Analog Output Holding Registers)
06: The number of data bytes to follow (3 registers x 2 bytes each = 6 bytes)
AE41: The contents of register 40108
5652: The contents of register 40109
4340: The contents of register 40110
49AD: The CRC (cyclic redundancy check).

A działający kod wygląda tak:

[syntax=c]//wyswietlacz
#include

//modbus
#include
#include
#include
#include
#include
//dotyczy obslugi modbus
modbusDevice regBank;
modbusSlave slave;

// piny wyswietlacza LCD
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);

void setup()
{
regBank.setId(10); // ID slave 10

regBank.add(40002); //adres 1 w programie nalezy ustawic slave=10 ,function= 06 write single register, adres=1
regBank.add(40001); //adres 0

slave._device = ®Bank;
slave.setBaud(9600); //predkosc transmisji danych 9600.8.N.1

lcd.begin(16, 2); // wyswietlacz 16x2
lcd.print ("Modbus LCD slave");

lcd.clear();

}

void loop()
{

lcd.setCursor(0,0);
lcd.print("40002 ") ; lcd.print(regBank.get(40002)); lcd.print(" "); //slave 10 , adres 1
lcd.setCursor(0,1);
lcd.print("40001 "); lcd.print(regBank.get(40001)); lcd.print(" "); //slave 10,adres 0

delay(100);
slave.run();

}[/syntax]

Dzięki wielkie za pomoc !!!! a teraz muszę się pobawić w liczby ujemne i z funkcja 16 write multiple register

Statystyki: Napisane przez endurasek — 12 sty 2017, o 21:23

Re: Modbus + LCD

2017-01-10T09:26:39+01:00

Masz rację co do adresu ale jego dopiero sprawdzę w piątek jak wrócę z delegacji i na pewno dam znać.

Statystyki: Napisane przez endurasek — 10 sty 2017, o 09:26

Re: Modbus + LCD

2017-01-09T21:32:46+01:00

Troche jaśniej please bo zaczynam się gubić.

Wyswietla ale co? Tak jak Ci pisałem po wpisie przez regBank.set tak? i wyswietla wartosć taką jaką wpisujesz? Wyswietlasz przez lcd.print(regBank.get())??

-----------------------

teraz mnie oswieciło. Rejestry 3xxxx to tzw Input registers. Holding Registers to 1xxxx chyba.
W C można sobie przypisywać dowolne zakresy. W arduino chyba jest na stałe o ile dobrze widzę. Jeżeli tak jest to do InputRegisters nie możesz nic zapisać z poziomu magistrali. Rejestry te przechowują dane otrzymane bezposrednio w module czyli czujniki itp. Możesz je odpytać ale nie zapisać do nich. Nie wiem czy nie powinienes dostać odpowiedź z kodem błędu illegal operation ale może w arduino nie ma tak. sprobuj zapisac do np.:
regBank.set(10001,100)
i wyswiel=tlic na lcd:
lcd.print(regBank.get(10001))

daj znac co sie dzieje

Statystyki: Napisane przez skalarro — 9 sty 2017, o 21:32

Re: Modbus + LCD

2017-01-09T15:58:46+01:00

Tak wyświetla, ale dalej szukam miejsca gdzie te dane przychodzą... i nie potrafię znaleźć

Statystyki: Napisane przez endurasek — 9 sty 2017, o 15:58

Re: Modbus + LCD

2017-01-09T09:14:10+01:00

Kurczaki....
Jak dostajesz odpowiedź taką samą, znaczy, że slave przyjął dane i tak włąśnie to potwierdza. Ramka też jest prawidłowa
0A 06 75 32 00 6F 73 5E

0A - adres slave'a w hex 10
06 - funkcja Write Single Reg
75 32 - adres rejestru w hex 30002
00 6F - 2x8bit wartości - 6f czyli 111
73 5E - CRC
----------------------
czyli komunikacja jest ok. Teraz trzeba poszukać dlaczego nie wyświetla. Na początku spróbuj na sztywno ustawić ten rejestr przez
regBank.set(30002,111); przed pętlą while, najlepiej zaraz po inicjalizacji modbusa i rejestrów
zoczacz czy wyświetli.

Statystyki: Napisane przez skalarro — 9 sty 2017, o 09:14

Re: Modbus + LCD

2017-01-09T06:18:43+01:00

Wiec wyświetla cały czas "0" a jak w programie modbus poll wysyłam jakąś liczbę to w tej samej sekundzie dostaje odpowiedz o takiej samej treści jak zapytanie .

Statystyki: Napisane przez endurasek — 9 sty 2017, o 06:18

Re: Modbus + LCD

2017-01-08T21:07:31+01:00

a funkcja lcd.print wyświetla co? wszystko?? czy czasem nie tylko stringi??

jak nie działa?? nie kompiluje się?? nic nie wyswietla? wyswietla 0?

Statystyki: Napisane przez skalarro — 8 sty 2017, o 21:07

Re: Modbus + LCD

2017-01-08T20:51:44+01:00

Zrobiłem jak napisałeś chyba....
[syntax=c]//wyswietlacz
#include

//modbus
#include
#include
#include
#include
#include
//dotyczy obslugi modbus
modbusDevice regBank;
modbusSlave slave;

// piny wyswietlacza LCD
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);

void setup()
{
regBank.setId(10); // ID slave 10
//regBank.add(30001); //tu wpisze wartosc temp z ds18b20_1 WAZNE odczyt ma byc int16 w plc
regBank.add(30002); //tu wpisze wartosc temp z ds18b20_2 WAZNE odczyt ma byc int16 w plc

slave._device = ®Bank;
slave.setBaud(9600); //predkosc transmisji danych 9600.8.N.1

lcd.begin(16, 2); // wyswietlacz 16x2
lcd.print ("Modbus LCD slave");

}

void loop()
{

//regBank.set(30002);
lcd.setCursor(0,1);
lcd.print("wart 30002 ") , lcd.print(regBank.get(30002));

delay(100);
slave.run();

}[/syntax]

ale funkcja regBank.set(30002); nie dziala

Statystyki: Napisane przez endurasek — 8 sty 2017, o 20:51

Re: Modbus + LCD

2017-01-08T19:59:30+01:00

Jak master (PLC lub komputer) wyśle dane i nie dostanie odpowiedzi z błędem ani timeouta, możesz śmiało założyć, że dane dotarły do modułu i ten je poprawnie odebrał. Połowa roboty za Tobą. Załóżmy, że wysyłasz dane do adresów - Temp1 do 30001, Temp2 do 30002. W module z wyświetlaczem nie msz czujników temperatury, więc te adresy są wolne i możesz ich użyć prawda?

I teraz kolej na Ciebie. Dane trafiają do tablicy modbusa, którą na pewno gdzieś definiowałeś i podawałeś jej rozmiar oraz adres początkowy. U Ciebie adresy zaczynają się od 0 czyli to co zapiszesz pod adres 30001 trafi do procesora pod element [01] w Twojej tablicy.

Nie znam arduino jak już pisałem, ale szukałbym tutaj:

[syntax=c]word modbusRegBank::get(word addr)
{
if(addr < 20000)
{
modbusDigReg * regPtr;
regPtr = (modbusDigReg *) this->search(addr);
if(regPtr)
return(regPtr->value);
else
return(NULL);
}
else
{
modbusAnaReg * regPtr;
regPtr = (modbusAnaReg *) this->search(addr);
if(regPtr)
return(regPtr->value);
else
return(NULL);
}
}[/syntax]
domyślam się, że to:
[syntax=c]regBank.add(30001)[/syntax] rezerwuje miejsce na dane a to
[syntax=c]regBank.set(30001,xxxdanexxx)[/syntax]zapisuje dane do konkretnej komórki pamięci.

zauważ, że funkcja regBank.get() zwraca wynik w postaci uint16t

spróbuj czegoś w stylu: LCD_long(regBank.get(30001));
Nie wiemy do teraz jakiego lcd używasz ale to nie istotne. pamiętaj, że wyświetlasz danle 16-to bitowe.

Statystyki: Napisane przez skalarro — 8 sty 2017, o 19:59

Re: Modbus + LCD

2017-01-08T19:15:31+01:00

Tak działa wysyłanie temperatury do komputera

Zrobiłem też twoim programem ale na innych ustawieniach bo tak dziwactwa wysyłał

Co do drugiej części to za bardzo nie wiem jak wyświetlić te dane na wyświetlaczu bo wyśle ale jak je odebrać i wyświetlić ?

Statystyki: Napisane przez endurasek — 8 sty 2017, o 19:15

Re: Modbus + LCD

2017-01-08T17:41:52+01:00

A spróbuj inaczej. Ściągnij sobie program np. modbus poll i podepnij się rs'em pod Twoje arduino z wgranym wsadem. Może być nawet Twój moduł, który już działa ten od temperatur. W programie na komputerze odpytuj moduł o temperatury i zobacz czy odpowiada.
w modbus poll wduś:

i w okienku, które się ukażeustaw:
slave ID 10, funkcja 03, adress 3000, quantity 2.

Jeżeli działa Tobie modbus tak jak pisałeś w 1 poście, powinieneś uzyskać komunikację z modułem i otrzymywać temperatury w komputerze.

Jak zadziała, miożesz iść dalej:
Wybierz funkcję 06

i w okienku ustaw swoje parametry:

zobacz czy program wysyła dane do modułu i nie ma błędów.

Da Ci to obraz, czy Twój moduł obsługuje F06,16.

Jak bedzie ok, pójdziemy dalej

Oczywiście pamiętaj o ustawieniu parametrów RS w programie zgodnie z Twoim modułem

Statystyki: Napisane przez skalarro — 8 sty 2017, o 17:41

Re: Modbus + LCD

2017-01-08T17:02:33+01:00

Tak wiem ze slave nie poprosi o dane z mastera ale może wyłapywać dane jakie master wysyła i z tym mam problem.
Z wyświetlaniem nie ma problemów tylko nie wiem skąd mam je pobrać ;-(
Co do języka C hmmm kilka razy próbowałem ale dla mnie to jest sklep Torebkami i damskimi butami... po prostu nie wiem o co w tym chodzi ;p

modbus.h
[syntax=c]#include
#ifndef _MODBUSPROTOCOL
#define _MODBUSPROTOCOL

//Maximum device list for network
#define DEVMAX10
//Maximum control register que size
#define QUEMAX10
//Maximum serial wait in micro seconds
#define SERIALMAXDELAY100
#define SERIALBAUD9600
//the total silence time needed to signify an EOM or SOM in RTU mode

//Modbus function codes
#define READ_DO 0x01
#define READ_DI0x02
#define READ_AO 0x03
#define READ_AI0x04

#define WRITE_DO0x05
#define WRITE_AO0x06

#define RTU 0x01
#define ASCII0x02

#define MASTER0x01
#define SLAVE0x02

#define DO0x00
#define DI0x01
#define AI0x03
#define AO0x04

#endif[/syntax]

modbusDevice.ccp
[syntax=c]#include

modbusDevice::modbusDevice(void)
{
_id=NULL;
}

void modbusDevice::setId(byte id)
{
_id=id;
}

byte modbusDevice::getId(void)
{
return(_id);
}[/syntax]

modbusDevice.h
[syntax=c]#include

modbusDevice::modbusDevice(void)
{
_id=NULL;
}

void modbusDevice::setId(byte id)
{
_id=id;
}

byte modbusDevice::getId(void)
{
return(_id);
}[/syntax]

modbusRegBank.ccp
[syntax=c]#include
#include

modbusRegBank::modbusRegBank(void)
{
_digRegs= 0;
_lastDigReg= 0;
_anaRegs= 0;
_lastAnaReg= 0;
}

void modbusRegBank::add(word addr)
{
if(addr<20000)
{
modbusDigReg *temp;

temp = (modbusDigReg *) malloc(sizeof(modbusDigReg));
temp->address = addr;
temp->value= 0;
temp->next= 0;

if(_digRegs == 0)
{
_digRegs = temp;
_lastDigReg = _digRegs;
}
else
{
//Assign the last register's next pointer to temp;
_lastDigReg->next = temp;
//then make temp the last register in the list.
_lastDigReg = temp;
}
}
else
{
modbusAnaReg *temp;

temp = (modbusAnaReg *) malloc(sizeof(modbusAnaReg));
temp->address = addr;
temp->value = 0;
temp->next = 0;

if(_anaRegs == 0)
{
_anaRegs = temp;
_lastAnaReg = _anaRegs;
}
else
{
_lastAnaReg->next = temp;
_lastAnaReg = temp;
}
}
}

word modbusRegBank::get(word addr)
{
if(addr < 20000)
{
modbusDigReg * regPtr;
regPtr = (modbusDigReg *) this->search(addr);
if(regPtr)
return(regPtr->value);
else
return(NULL);
}
else
{
modbusAnaReg * regPtr;
regPtr = (modbusAnaReg *) this->search(addr);
if(regPtr)
return(regPtr->value);
else
return(NULL);
}
}

void modbusRegBank::set(word addr, word value)
{
//for digital data
if(addr < 20000)
{
modbusDigReg * regPtr;
//search for the register address
regPtr = (modbusDigReg *) this->search(addr);
//if a pointer was returned the set the register value to true if value is non zero
if(regPtr)
if(value)
regPtr->value = 0xFF;
else
regPtr->value = 0x00;
}
else
{
modbusAnaReg * regPtr;
//search for the register address
regPtr = (modbusAnaReg *) this->search(addr);
//if found then assign the register value to the new value.
if(regPtr)
regPtr->value = value;
}
}

void * modbusRegBank::search(word addr)
{
//if the requested address is 0-19999
//use a digital register pointer assigned to the first digital register
//else use a analog register pointer assigned the first analog register

if(addr < 20000)
{
modbusDigReg *regPtr = _digRegs;

//if there is no register configured, bail
if(regPtr == 0)
return(0);

//scan through the linked list until the end of the list or the register is found.
//return the pointer.
do
{
if(regPtr->address == addr)
return(regPtr);
regPtr = regPtr->next;
}
while(regPtr);
}
else
{
modbusAnaReg *regPtr = _anaRegs;

//if there is no register configured, bail
if(regPtr == 0)
return(0);

//scan through the linked list until the end of the list or the register is found.
//return the pointer.
do
{
if(regPtr->address == addr)
return(regPtr);
regPtr = regPtr->next;
}
while(regPtr);
}
return(0);
}[/syntax]

modbusRegBank.h
[syntax=c]#include
#include

#ifndef _MODBUSREGBANK
#define _MODBUSREGBANK

#include
//#include

struct modbusDigReg
{
word address;
byte value;

modbusDigReg *next;
};

struct modbusAnaReg
{
word address;
word value;

modbusAnaReg *next;
};

class modbusRegBank
{
public:

modbusRegBank(void);

void add(word);
word get(word);
void set(word, word);

private:
void * search(word);

modbusDigReg*_digRegs,
*_lastDigReg;

modbusAnaReg*_anaRegs,
*_lastAnaReg;
};
#endif[/syntax]

modbusSlave.cpp
[syntax=c]#include
#include
#include
#include

modbusSlave::modbusSlave()
{
}
/*
Set the Serial Baud rate.
Reconfigure the UART for 8 data bits, no parity, and 1 stop bit.
and flush the serial port.
*/
void modbusSlave::setBaud(word baud)
{
_baud = baud;
//calculate the time perdiod for 3 characters for the given bps in ms.
_frameDelay = 24000/_baud;

Serial.begin(baud);

// defaults to 8-bit, no parity, 1 stop bit
//clear parity, stop bits, word length
//UCSR0C = UCSR0C & B11000001;
//UCSR0B = UCSR0B & B11111011;

//Set word length to 8 bits
//UCSR0C = UCSR0C | B00000110;

//No parity
//UCSR0C = UCSR0C | B00000000;

//1 Stop bit
//UCSR0C = UCSR0C | B00000100;

Serial.flush();
}

/*
Retrieve the serial baud rate
*/
word modbusSlave::getBaud(void)
{
return(_baud);
}

/*
Generates the crc for the current message in the buffer.
*/

void modbusSlave::calcCrc(void)
{
byteCRCHi = 0xFF,
CRCLo = 0x0FF,
Index,
msgLen,
*msgPtr;

msgLen = _len-2;
msgPtr = _msg;

while(msgLen--)
{
Index = CRCHi ^ *msgPtr++;
CRCHi = CRCLo ^ _auchCRCHi[Index];
CRCLo = _auchCRCLo[Index];
}
_crc = (CRCHi << 8) | CRCLo;
}

/*
Checks the UART for query data
*/
void modbusSlave::checkSerial(void)
{
//while there is more data in the UART than when last checked
while(Serial.available()> _len)
{
//update the incoming query message length
_len = Serial.available();
//Wait for 3 bytewidths of data (SOM/EOM)
//delayMicroseconds(RTUFRAMETIME);
delay(_frameDelay);
//Check the UART again
}
}

/*
Copies the contents of the UART to a buffer
*/
void modbusSlave::serialRx(void)
{
byte i;

//allocate memory for the incoming query message
_msg = (byte*) malloc(_len);

//copy the query byte for byte to the new buffer
for (i=0 ; i < _len ; i++)
_msg[i] = Serial.read();
}

/*
Generates a query reply message for Digital In/Out status update queries.
*/
void modbusSlave::getDigitalStatus(byte funcType, word startreg, word numregs)
{
//initialize the bit counter to 0
byte bitn =0;

//if the function is to read digital inputs then add 10001 to the start register
//else add 1 to the start register
if(funcType == READ_DI)
startreg += 10001;
else
startreg += 1;

//determine the message length
//for each group of 8 registers the message length increases by 1
_len = numregs/8;
//if there is at least one incomplete byte's worth of data
//then add 1 to the message length for the partial byte.
if(numregs%8)
_len++;
//allow room for the Device ID byte, Function type byte, data byte count byte, and crc word
_len +=5;

//allocate memory of the appropriate size for the message
_msg = (byte *) malloc(_len);

//write the slave device ID
_msg[0] = _device->getId();
//write the function type
_msg[1] = funcType;
//set the data byte count
_msg[2] = _len-5;

//For the quantity of registers queried
while(numregs--)
{
//if a value is found for the current register, set bit number bitn of msg[3]
//else clear it
if(_device->get(startreg))
bitSet(_msg[3], bitn);
else
bitClear(_msg[3], bitn);
//increment the bit index
bitn++;
//increment the register
startreg++;
}

//generate the crc for the query reply and append it
this->calcCrc();
_msg[_len - 2] = _crc >> 8;
_msg[_len - 1] = _crc & 0xFF;
}

void modbusSlave::getAnalogStatus(byte funcType, word startreg, word numregs)
{
word val;
word i = 0;

//if the function is to read analog inputs then add 30001 to the start register
//else add 40001 to the start register
if(funcType == READ_AI)
startreg += 30001;
else
startreg += 40001;

//calculate the query reply message length
//for each register queried add 2 bytes
_len = numregs * 2;
//allow room for the Device ID byte, Function type byte, data byte count byte, and crc word
_len += 5;

//allocate memory for the query response
_msg = (byte *) malloc(_len);

//write the device ID
_msg[0] = _device->getId();
//write the function type
_msg[1] = funcType;
//set the data byte count
_msg[2] = _len - 5;

//for each register queried
while(numregs--)
{
//retrieve the value from the register bank for the current register
val = _device->get(startreg+i);
//write the high byte of the register value
_msg[3 + i * 2] = val >> 8;
//write the low byte of the register value
_msg[4 + i * 2] = val & 0xFF;
//increment the register
i++;
}

//generate the crc for the query reply and append it
this->calcCrc();
_msg[_len - 2] = _crc >> 8;
_msg[_len - 1] = _crc & 0xFF;
}

void modbusSlave::setStatus(byte funcType, word reg, word val)
{
//Set the query response message length
//Device ID byte, Function byte, Register byte, Value byte, CRC word
_len = 8;
//allocate memory for the message buffer.
_msg = (byte *) malloc(_len);

//write the device ID
_msg[0] = _device->getId();
//if the function type is a digital write
if(funcType == WRITE_DO)
{
//Add 1 to the register value and set it's value to val
_device->set(reg + 1, val);
//write the function type to the response message
_msg[1] = WRITE_DO;
}
else
{
//else add 40001 to the register and set it's value to val
_device->set(reg + 40001, val);

//write the function type of the response message
_msg[1] = WRITE_AO;
}

//write the register number high byte value
_msg[2] = reg >> 8;
//write the register number low byte value
_msg[3] = reg & 0xFF;
//write the control value's high byte
_msg[4] = val >> 8;
//write the control value's low byte
_msg[5] = val & 0xFF;

//calculate the crc for the query reply and append it.
this->calcCrc();
_msg[_len - 2]= _crc >> 8;
_msg[_len - 1]= _crc & 0xFF;
}

void modbusSlave::run(void)
{

byte deviceId;
byte funcType;
word field1;
word field2;

int i;

//initialize mesasge length
_len = 0;

//check for data in the recieve buffer
this->checkSerial();

//if there is nothing in the recieve buffer, bail.
if(_len == 0)
{
return;
}

//retrieve the query message from the serial uart
this->serialRx();

//if the message id is not 255, and
// and device id does not match bail
if( (_msg[0] != 0xFF) &&
(_msg[0] != _device->getId()) )
{
return;
}
//calculate the checksum of the query message minus the checksum it came with.
this->calcCrc();

//if the checksum does not match, ignore the message
if ( _crc != ((_msg[_len - 2] << 8) + _msg[_len - 1]))
return;

//copy the function type from the incoming query
funcType = _msg[1];

//copy field 1 from the incoming query
field1= (_msg[2] << 8) | _msg[3];

//copy field 2 from the incoming query
field2 = (_msg[4] << 8) | _msg[5];

//free the allocated memory for the query message
free(_msg);
//reset the message length;
_len = 0;

//generate query response based on function type
switch(funcType)
{
case READ_DI:
this->getDigitalStatus(funcType, field1, field2);
break;
case READ_DO:
this->getDigitalStatus(funcType, field1, field2);
break;
case READ_AI:
this->getAnalogStatus(funcType, field1, field2);
break;
case READ_AO:
this->getAnalogStatus(funcType, field1, field2);
break;
case WRITE_DO:
this->setStatus(funcType, field1, field2);
break;
case WRITE_AO:
this->setStatus(funcType, field1, field2);
break;
default:
return;
break;
}

//if a reply was generated
if(_len)
{
int i;
//send the reply to the serial UART
//Senguino doesn't support a bulk serial write command....
for(i = 0 ; i < _len ; i++)
Serial.write(_msg[i]);
//free the allocated memory for the reply message
free(_msg);
//reset the message length
_len = 0;
}
}[/syntax]

modbusSlave.h
[syntax=c]#include
#include

#ifndef MODBUSSLAVE
#define MODBUSSLAVE

#include
#include
//#include

/* Table of CRC values for high–order byte */
const byte _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};

/* Table of CRC values for low–order byte */
const byte _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};

class modbusSlave
{
public:
modbusSlave(void);
void setBaud(word);
word getBaud(void);
void calcCrc(void);
void checkSerial(void);
void serialRx(void);
void getDigitalStatus(byte, word, word);
void getAnalogStatus(byte, word, word);
void setStatus(byte, word, word);
void run(void);

modbusDevice *_device;

private:
byte *_msg,
_len;

word _baud,
_crc,
_frameDelay;
};
#endif[/syntax]

Statystyki: Napisane przez endurasek — 8 sty 2017, o 17:02

Re: Modbus + LCD

2017-01-08T15:29:31+01:00

Nie wiem co masz na myśli pisząc

endurasek napisał(a):

nie znalazłem tam możliwości pobierania danych z mastera i wyświetlania go na wyświetlaczu.

ale slave nigdy nie poprosi mastera o dane, więc takiej funkcji nie oczekuj. Ale na pewno master powinien mieć możliwość zapisu n-rejestrów do slavea. Sam modbus jako standard to zapewnia. Co innego czy Twoja biblioteka ma zaimplementowaną obsługę funkcji 16. Niestety biblioteki nie załączyłeś to musisz się sam pomęczyć.

Druga sprawa - wyświetlanie danych na wyświetlaczu to oddzielny temat - z tym chyba nie masz problemu??

Możesz się przesiąść na C w przypadku tego jednego modułu czy musi być arduino?

Statystyki: Napisane przez skalarro — 8 sty 2017, o 15:29

Re: Modbus + LCD

2017-01-08T14:52:02+01:00

Sprawdziłem bibliotekę którą używam i nie znalazłem tam możliwości pobierania danych z mastera i wyświetlania go na wyświetlaczu. Nie upieram się na moim przykładzie ale jeśli ktoś posiada jakiś inny to prosił bym o udostępnienie

Statystyki: Napisane przez endurasek — 8 sty 2017, o 14:52

Re: Modbus + LCD

2017-01-07T12:53:06+01:00

Nie znam arduino wogole więc ciężko mi się to czyta ale poszukaj w bibliotekach funkcji odpowiedniej.

Ogólnie zasada jest taka, że tutaj w programie odczytujesz czujniki temp i zapisujesz wynik do tablicy (chyba regBank 30001 i 30002) a PLC odpytuje je funkcją pewnie 03.

U ciebie w module z wyświetlaczem musisz odwrócić sytuację.
Używając w PLC funkcji np 16 musisz zapisać do tablicy (może być ta sama regBank(30001) - to i tak inny procek) liczby odpowiadające pomiarom temperatury.
Później juź w funkcji wyświetlającej liczby na wyświetlaczu wyświetlasz interesujące Cię dane. Pamiętaj, że zmienne z modbusa to słowa 16-to bitowe. Musisz użyć odpowiedniej funkcji lub przerobić je na stringi i wyświetlić jako tekst.

Statystyki: Napisane przez skalarro — 7 sty 2017, o 12:53

Re: Modbus + LCD

2017-01-07T12:18:08+01:00

Aktualnie korzystam z tego przykładu

[syntax=c]#include
#include
#include
#include

/* PINS
Add more registers if needed
Digital input pins 2,3,4,5,6,7
Digital output pins 8,9,12,13
Analog output pins 10,11 (PWM)
Analog input pins 0,1,2,3,4,5
*/

modbusDevice regBank;
modbusSlave slave;

int AI0,AI1,AI2,AI3,AI4,AI5;

void setup()
{
regBank.setId(10); ///Set Slave ID

//Add Digital Input registers
regBank.add(10002);
regBank.add(10003);
regBank.add(10004);
regBank.add(10005);
regBank.add(10006);
regBank.add(10007);
// Add Digital Output registers
regBank.add(8);
regBank.add(9);
regBank.add(12);
regBank.add(13);
//Analog input registers
regBank.add(30001);
regBank.add(30002);
regBank.add(30003);
regBank.add(30004);
regBank.add(30005);
regBank.add(30006);
//Analog Output registers
regBank.add(40010);
regBank.add(40011);

slave._device = ®Bank;
slave.setBaud(9600);

pinMode(2,INPUT);
pinMode(3,INPUT);
pinMode(4,INPUT);
pinMode(5,INPUT);
pinMode(6,INPUT);
pinMode(7,INPUT);
pinMode(8,OUTPUT);
pinMode(9,OUTPUT);
pinMode(12,OUTPUT);
pinMode(13,OUTPUT);

//ustawiam sobie wejscia w stan wysoki i steruje to 0
digitalWrite(2, HIGH);
digitalWrite(3, HIGH);
digitalWrite(4, HIGH);
digitalWrite(5, HIGH);
digitalWrite(6, HIGH);
digitalWrite(7, HIGH);
}
void loop(){

while(1){
//Digital Input
byte DI2 = digitalRead(2);
if (DI2 >= 1)regBank.set(10002,1);
if (DI2 <= 0)regBank.set(10002,0);
byte DI3 = digitalRead(3);
if (DI3 >= 1)regBank.set(10003,1);
if (DI3 <= 0)regBank.set(10003,0);
byte DI4 = digitalRead(4);
if (DI4 >= 1)regBank.set(10004,1);
if (DI4 <= 0)regBank.set(10004,0);
byte DI5 = digitalRead(5);
if (DI5 >= 1)regBank.set(10005,1);
if (DI5 <= 0)regBank.set(10005,0);
byte DI6 = digitalRead(6);
if (DI6 >= 1)regBank.set(10006,1);
if (DI6 <= 0)regBank.set(10006,0);
byte DI7 = digitalRead(7);
if (DI7 >= 1)regBank.set(10007,1);
if (DI7 <= 0)regBank.set(10007,0);

//Digital output
int DO8 = regBank.get(8);
if (DO8 <= 0 && digitalRead(8) == HIGH)digitalWrite(8,LOW);
if (DO8 >= 1 && digitalRead(8) == LOW)digitalWrite(8,HIGH);
int DO9 = regBank.get(9);
if (DO9 <= 0 && digitalRead(9) == HIGH)digitalWrite(9,LOW);
if (DO9 >= 1 && digitalRead(9) == LOW)digitalWrite(9,HIGH);
int DO12 = regBank.get(12);
if (DO12 <= 0 && digitalRead(12) == HIGH)digitalWrite(12,LOW);
if (DO12 >= 1 && digitalRead(12) == LOW)digitalWrite(12,HIGH);
int DO13 = regBank.get(13);
if (DO13 <= 0 && digitalRead(13) == HIGH)digitalWrite(13,LOW);
if (DO13 >= 1 && digitalRead(13) == LOW)digitalWrite(13,HIGH);

//Analog input ***READ Twice deliberately
AI0 = analogRead(0);
delay(10);
AI0 = analogRead(0);
regBank.set(30001, (word) AI0);
delay(10);

AI1 = analogRead(1);
delay(10);
AI1 = analogRead(1);
regBank.set(30002, (word) AI1);
delay(10);

AI2 = analogRead(2);
delay(10);
AI2 = analogRead(2);
regBank.set(30003, (word) AI2);
delay(10);

AI3 = analogRead(3);
delay(10);
AI3 = analogRead(3);
regBank.set(30004, (word) AI3);
delay(10);

AI4 = analogRead(4);
delay(10);
AI4 = analogRead(4);
regBank.set(30005, (word) AI4);
delay(10);

AI5 = analogRead(5);
delay(10);
AI5 = analogRead(5);
regBank.set(30006, (word) AI5);
delay(10);

//Analog output
word AO10 = regBank.get(40010);
analogWrite(10,AO10);
delay(10);
word AO11 = regBank.get(40011);
analogWrite(11,AO11);
delay(10);

slave.run();
}
}[/syntax]

Do moich potrzeb przerobiłem go na odczyt dwóch czujników DS18B20 których wartość wysyła po modbasie np. 25,34C jako 2534
[syntax=c]//wyswietlacz
#include
//ds18b20
#include
#include
//modbus
#include
#include
#include
#include

//dotyczy obslugi modbus
modbusDevice regBank;
modbusSlave slave;

// ds18b20 podlaczony pod 2 i 3 pin
#define ONE_WIRE_BUS_1 2
#define ONE_WIRE_BUS_2 3

//znak stopnia
byte stopienCelc[8] =
{
B01000,
B10100,
B01000,
B00000,
B00000,
B00000,
B00000,
B00000
};

byte sygPraca[8] = {
B00111,
B00111,
B00111,
B00000,
B00000,
B00000,
B00000,
B00000
};

// Setup a oneWire instance to communicate with ANY OneWire devices
OneWire oneWire_1(ONE_WIRE_BUS_1);
OneWire oneWire_2(ONE_WIRE_BUS_2);

// Set oneWire reference to Dallas Temperature sensor.
DallasTemperature sensors_1(&oneWire_1);
DallasTemperature sensors_2(&oneWire_2);

// piny wyswietlacza LCD
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);

void setup()
{
regBank.setId(10); // ID slave 10
regBank.add(30001); //tu wpisze wartosc temp z ds18b20_1 WAZNE odczyt ma byc int16 w plc
regBank.add(30002); //tu wpisze wartosc temp z ds18b20_2 WAZNE odczyt ma byc int16 w plc

slave._device = ®Bank;
slave.setBaud(9600); //predkosc transmisji danych 9600.8.N.1

lcd.begin(16, 2); // wyswietlacz 16x2
sensors_1.begin();
sensors_2.begin();

lcd.createChar(1, stopienCelc); //znak specjalny
lcd.createChar(2, sygPraca); //znak specjalny
}

void loop()
{
lcd.setCursor(15,0); //miga kursor w prawym rogu
lcd.write(2);

//odczytanie temp z obu czujnikow
sensors_1.requestTemperatures();
sensors_2.requestTemperatures();

//wyswietla pierwsza wartosc i zamazuje reszte
lcd.setCursor(0,0);
lcd.print("T.Piec "); lcd.print(sensors_1.getTempCByIndex(0)); lcd.write(1); lcd.print(" "); //wyswietla cala temp z ds18b20_1 z ulamikiem

lcd.setCursor(0,1);
lcd.print("T.Boj ") , lcd.print (sensors_2.getTempCByIndex(0)); lcd.write(1); lcd.print(" "); //wyswietla cala temp z ds18b20_2 z ulamikiem

lcd.setCursor(15,0); // kasuje kursor w rogu
lcd.print(" ");

regBank.set(30001, sensors_1.getTempCByIndex(0)*100); //przesowam przecinek o dwie pozycje i wpisuje je do rejestru
regBank.set(30002, sensors_2.getTempCByIndex(0)*100); //przesowam przecinek o dwie pozycje i wpisuje je do rejestru
delay(100);

slave.run();

}[/syntax]

W moim przykładzie nie mam takiej opcji czy muszę mieć inna bibliotekę ? w jaki sposób na wyswietlaczu slave mam odczytać tą wartość która jest zapisana pod 30001

Statystyki: Napisane przez endurasek — 7 sty 2017, o 12:18

Re: Modbus + LCD

2017-01-07T11:26:32+01:00

Tak, Wyświetlacz robisz jako trzecie urządzenie slave ze swoim adresem, podłączasz go pod magistralę i zapisujesz do niego dane które chcesz wyświetlić.

Oczywiście wyświetlacz to będzie moduł z własnym mikrokontrolerem, zasilaniem i RS485. Zapis robisz za pomocą funkcki 16 - write N-registers

Statystyki: Napisane przez skalarro — 7 sty 2017, o 11:26

Modbus + LCD

2017-01-07T10:24:20+01:00

Witam
mam podłączone arduino z PLC gdzie PLC pracuje jako master a arduino jako slave. Plc odpytuje dwa urządzenia slave o stan pinow oraz temperaturę. I teraz chciał bym na tej samej lini RS485 podłączyć wyświetlacz(slave) który by wyświetlał wybrane dane na wyświetlaczu które są przesyłane między pozostałymi urządzeniami. Czy ma ktoś jakis pomysł jak to zrobić?

Statystyki: Napisane przez endurasek — 7 sty 2017, o 10:24