Please help to setup Throughserial between 2 Arduino DUE

[sublimethe]

I wired arduinos like this:
19(Tx1)---4.7kOhm---18(Rx1) (without resistor boards halt)
18(Rx1)---4.7kOhm---19(Tx1)
gnd---gnd

My test code is

Asking side (A):

#include <PJON.h>
#include <strategies/ThroughSerial/ThroughSerial.h>
PJON<ThroughSerial> bus(44); //HardwareSerial &uartPort = Serial1;
void receiver(uint8_t *payload, uint16_t length, const PJON_Packet_Info &info);
void setup() {  Serial.begin(115200);
                Serial1.begin(2400); //uartPort.begin(9600);//bus.strategy.set_RS485_txe_pin(18);
                bus.strategy.set_serial(&Serial1);  //bus.strategy.set_enable_RS485_pin(18);
                bus.set_communication_mode(PJON_HALF_DUPLEX); //PJON_HALF_DUPLEX PJON_SIMPLEX  
                bus.set_acknowledge(true);//bus.set_crc_32(true);
                bus.set_receiver(receiver);  //bus.set_acknowledge(false);                
                bus.begin(); //bus.strategy.set_RS485_rxe_pin(18);//  bus.strategy.set_RS485_txe_pin(19);
                Serial.println("bus.begin");}

void loop() { while (!Serial1) ;
              bus.update();
              const char req[] = "REQ";
              uint16_t result = bus.send_packet_blocking(45, req, sizeof(req));
              bus.receive(200);
              Serial.print(" Result "); // PJON_ACK (6) if a correct reception occurred
              Serial.println(result);   // PJON_NAK (21) if a mistake is found in CRC
              Serial.println("----");   // PJON_BUSY (666) if a transmission for other devices is occurring
                                        // PJON_FAIL (65535) if no data is received
              } //delay(20);

void receiver(uint8_t *payload, uint16_t length, const PJON_Packet_Info &info) {
  Serial.print("Получено: ");
  Serial.write(payload, length);
  Serial.println(); 
 }

Responding side (R):

#include <PJON.h>
#include <strategies/ThroughSerial/ThroughSerial.h>
PJON<ThroughSerial> bus(45);
void receiver(uint8_t *payload, uint16_t length, const PJON_Packet_Info &info);
void setup() {Serial.begin(115200);
              Serial1.begin(2400);//bus.strategy.set_RS485_txe_pin(19);
              bus.strategy.set_serial(&Serial1);//  bus.strategy.set_RS485_txe_pin(19);
              bus.set_communication_mode(PJON_HALF_DUPLEX); //PJON_HALF_DUPLEX PJON_SIMPLEX
              //bus.set_crc_32(true);
              bus.set_acknowledge(true);
              bus.set_receiver(receiver);//  bus.strategy.set_RS485_rxe_pin(18);
              bus.begin();
              Serial.println("bus2.begin");}

void loop() {bus.update(); bus.receive(500); } //delay(114);

void receiver(uint8_t *payload, uint16_t length, const PJON_Packet_Info &info) {
  if (strncmp((char*)payload, "REQ", 3) == 0) {
   char data[6]; 
    for (int i = 0; i < 5; i++) {data[i] = random('0', '9' + 1);} data[5] = '0';     
    uint16_t result = bus.reply_blocking(data, sizeof(data)); // bus.send_packet_blocking(44, data, sizeof(data));
    Serial.print("Data sent: ");Serial.println(data);
    Serial.print(" Result ");Serial.println(result);
    Serial.println("----");  
    } 
}

What it does - the A side terminal print "Result 6" right after it starts. After few seconds the R terminal prints "Data sent: 208800� Result 666", next the A side terminal prints "result 666"
I think it should work like this: A sends "REQ", waits ASK(6) prints me 6 to terminal
Next R recieves REQ, forms random number send it to A, wait for ASK from A

What i see is A never sends ASK back to R, but it tells me that he see ASK from R after sending REQ to it.

I BOUGHT oscilloscope for this and this how it looks there.
Full signal

Zoom in

So i see on the signal that A (blue) sends data. Immediatly next R sends smth short back (is it ASK?) and then a long time after A sends exact same data again, like it never recieves ASK from R. And at the exact same time R starts to send those random numbers. Maybe i need to tune some throughserial default timers?

Please HELP me with this. I dont understand why it is not working. My only thought is that in TSDL-specification-v3.0.md the logic 0 is a "free" state of the line, but mine is ALWAYS is 1 after the library takes control under serial1.

With all respect kindly waiting for any thoughts. It is needed for me to build an electric system in my motorhome where i currently live, having no place else.

[gioblu]

@sublimethe looking at the pictures I think the problem is that your side A is programmed to send packets continuously with a delay between each packet of 200 microseconds. Side R is programmed to respond something to a packet, it does so immediately after receiving, and it collides with the next transmission of side A, the solution is to put a longer delay between each transmission of side A to give time to side R to respond. Your oscilloscope shows you two packet transmissions occurring at the same time, that is a textbook example of a packet collision.

Remember to always wait on transmitter side for at least TS_RESPONSE_TIME_OUT (by default 45 milliseconds) between each transmission attempt.

[gioblu]

I think the changes suggested above will solve your issue, let me know how it goes @sublimethe

[sublimethe]

All day im trying to solve this on my own, using your hints. No luck so far - to many questions, but i am afraid to abuse your valuable time with my newbie problems) So i will do my best to find out how to make this work and post here the solution, or another butch of code, oscilograms and my prayers for help))
So far i am in situation where serial speed is set to 74880, TS_RESPONSE_TIME_OUT reduced to 7000us, and i am trying to pick up the bus.receive(22000) timings which are now around 22000us (more then twice as TS_RESPONSE_TIME_OUT) but still no stable communication.
Data now passing most of times, but never if R side uses reply_blocking function. I really need to know that my data has been received, so, as i understand, i need to use send_packed_blocking (or reply_blocking) on both sides. That's what i am fighting with now.

[gioblu]

Hi @sublimethe I suggest you to start simple:

Let's say you need to send a request to a device and expect an answer from that device. If this is the use case, you don't really need the acknowledgement, and you don't really need to use the send_packet_blocking function.

My suggestion is to program the sender not to use the acknowledgement and if you are transmitting cyclically, try to do that seldom, like once every 2 seconds, just to be sure to avoid any collission as the one shown in the pictures you shared. On receiver side you can just use reply. If the system occasionaly fails that may be because of induced interference.

[uzi18]

@sublimethe what about this simple lib https://github.com/madsci1016/Arduino-EasyTransfer

[sublimethe]

Well.. my project is a bit more complex, then part, i posted here. I have (for now, it is only a starting point) 3 i2c pressure sensors to measure pressure (to calculate water height) inside my boiler, main water tanks and waste tank and one i2c display. This all manages through one Arduino DUE and its works fine in laboratory, but in real life i2c wires are up to 3 meters long and system halts every second if a 220v inverter works, orr a dc water pumps. So i need to get rid of long i2c cables. So my new architecture will be: pressure sensor directly connected to attiny1616 (right there in the capsule under water), and attiny will convert i2c to PJON softwarebitbang or throughserial (i dont know what that controller capable of) If it will be softwarebitbang i need to connect 3 attiny to UNO to convert 3 softwarebitbang to throughserial because DUE incompatible with softwarebitbang. Next a link mainDUE and UNO. But there is display also, so i need to convert i2c link to display to. So i will place a lcdDUE right next to display and thats what i started from - i need to share mainDUE real-time data from sensors with lcdDUE and i need to transfer user settings from lcdDUE to mainDUE because lcdDUE will be equipped with encoder)
This lib, you are suggesting, supports i2c (which i need to cancel from my project) and serial. So it wont suit my needs)

[uzi18]

@sublimethe just add MAX485 for serial communication, there are also available PCA chips to extend I2C communication ...

[sublimethe]

Well. I got no luck making it work with blocking on both sides, but time goes and i have to move on with my project.
So far it works very stable with my code and timing tunings in it. If some one need a start to pair two DUEs, i guess here it is.
There is a long path ahead for me to make it work with i2c lcd and real sensors data, wish me luck) And thanks for hints)

Asking side code

//#define TS_READ_INTERVAL 100     //100      // PJON_ACK (6) if a correct reception occurred
//#define TS_BYTE_TIME_OUT 1000000 //1000000  //PJON_NAK (21) if a mistake is found in CRC 
#define TS_RESPONSE_TIME_OUT 5000  //45000    // PJON_BUSY (666) if a transmission for other devices is occurring
//#define TS_BACK_OFF_DEGREE 4     //4        // PJON_FAIL (65535) if no data is received 
#define TS_MAX_ATTEMPTS   4 //20

#include <PJON.h>
#include <strategies/ThroughSerial/ThroughSerial.h>
PJON<ThroughSerial> bus(44); //HardwareSerial &uartPort = Serial1;
String AorB = "A";

void setup() {  Serial.begin(115200);
                Serial1.begin(19200); 
                bus.strategy.set_serial(&Serial1);  
                bus.set_communication_mode(PJON_HALF_DUPLEX); //PJON_HALF_DUPLEX PJON_SIMPLEX  
                bus.set_acknowledge(true);
                bus.set_receiver(receiver);              
                bus.begin(); 
                Serial.println("bus.begin");}                                      
void loop() { 
              bus.update(); Serial.println("----");
              //bus.receive(15000); Serial.println("recieved0");                            
              uint16_t result = bus.send_packet_blocking(45, AorB.c_str(), AorB.length()); //
              Serial.print("Result: "); Serial.println(result); 
              bus.receive(7000); Serial.println("recieved1"); //waiting ACK ?
              bus.receive(7000); Serial.println("recieved2"); // waiting data ?
              ;

              if (AorB == "A") {AorB = "B"; }  else {AorB = "A"; }   
              //delay(10);            //delayMicroseconds(15);                  
              } 
void receiver(uint8_t *payload, uint16_t length, const PJON_Packet_Info &info) 
{Serial.print("Recieved: "); Serial.write(payload, length); Serial.println();
                            bus.receive(7000); Serial.println("recieved3"); // Why no loop? But it needed here}  

Responding side

//#define TS_READ_INTERVAL 100        //100
#define TS_BYTE_TIME_OUT 1000000  //1000000 
#define TS_RESPONSE_TIME_OUT 5000  //45000 
//#define TS_BACK_OFF_DEGREE 4 //4
#define TS_MAX_ATTEMPTS   4 //20

#include <PJON.h>
#include <strategies/ThroughSerial/ThroughSerial.h>
PJON<ThroughSerial> bus(45);

void setup() {Serial.begin(115200);
              Serial1.begin(19200);//bus.strategy.set_RS485_txe_pin(19);
              bus.strategy.set_serial(&Serial1);//  bus.strategy.set_RS485_txe_pin(19);
              bus.set_communication_mode(PJON_HALF_DUPLEX); //PJON_HALF_DUPLEX PJON_SIMPLEX
              //bus.set_crc_32(true);
              bus.set_acknowledge(true);
              bus.set_receiver(receiver);//  bus.strategy.set_RS485_rxe_pin(18);
              bus.begin();
              Serial.println("bus2.begin");}

void loop() {bus.update();bus.receive(7000);   } //delay(114);

void receiver(uint8_t *payload, uint16_t length, const PJON_Packet_Info &info) {
  char buffer[50]; memcpy(buffer, payload, length); buffer[length] = '\0';
  String PJONreceived = buffer;
  String PJONsend; 
  if (PJONreceived == "A") {PJONsend = "Y";}
  else if (PJONreceived == "B") {PJONsend = "W";}    
  for (int i = 1; i < 3; i++) {PJONsend = PJONsend + random(0, 9);} //sendMSG = sendMSG + "0";
    uint16_t result = bus.reply(PJONsend.c_str(), PJONsend.length()); //_blocking  bus.send_packet_blocking(44, data, sizeof(data));
    bus.receive(7000);  // needed right after reply procedure, why no loop?
    Serial.print("Data sent: ");Serial.println(PJONsend);
    Serial.print(" Result ");Serial.println(result);
    Serial.println("----");     
}