Connect two esp32 via UART

[salarizadi]

Hi.

I want to connect two esp32/nodemcu via uart and send and receive data, how can I do this?

[phoddie]

The Serial Echo example could be a good place to start. It uses ECMA-419 Serial I/O.

[salarizadi]

I tried this but I don't know exactly how it works and I even have to use -i instead of -d to see the output which either crashes or doesn't show any of the received information.

If you have time and can write a complete sample code of Slave and Master, that would be great

[phoddie]

I even have to use -i instead of -d to see the output which either crashes or doesn't show any of the received information.

I see. The debugger connection uses a serial port, as you know. On ESP32, the debugger uses port UART_NUM_0. A project that uses the debugger and Serial needs to choose a serial port that doesn't conflict. The "buffer" path in the echo example sets the port to 2, so there should be no conflict.

	let serial = new device.io.Serial({
		...device.Serial.default,
		baud: 115200,
		port: 2,
		format: "buffer",
		onReadable: function(count) {
			this.write(this.read());
		},
	});

The "bytes" code path, however, uses the default. If you are using that case, you may want to change it as follows:

	let serial = new device.io.Serial({
		...device.Serial.default,
		baud: 115200 * 8,
		port: 2,
		onReadable: function(count) {
			while (count--)
				this.write(this.read());
		},
	});

[andycarle]

@salarizadi How do you have your two ESP32 devices connected? If you're to a point where you think everything should be working but you're seeing sporadic results, make sure you have Ground pins on the two ESP32s tied together. So at least three connections between the two devices:

• RX->TX
• TX->RX
• Ground->Ground

[salarizadi]

My code In both esp32 :

let serial = new device.io.Serial({
    ...device.Serial.default,
    baud: 115200,
    port: 2,
    format: "buffer",
    onReadable: function(count) {
        const str = String.fromArrayBuffer(this.read());
        if ( str === "t" ) {
            this.write(ArrayBuffer.fromString("Hello Slave"))
        }
        this.write(ArrayBuffer.fromString(str.toUpperCase() + "\r\n"));
    },
});

The code works correctly, what I write does not transfer to each other.

Pins :
RX2 -> TX2 (17)
TX2 -> RX2 (16)
GND-> GND

[andycarle]

I'm not sure I follow your code, but the wiring seems reasonable.

This is the sort of problem that one would generally look into more deeply with a logic analyzer or an oscilloscope. If you are planning on doing this sort of work a lot and don't already have one, I recommend picking one up.

[phoddie]

You are using pins 16 & 17. The default for esp32/nodemcu is 1 for transmit and 3 for receive in device.io.Serial (taken from here). You can see that in the xsbug. As noted above you should set the receive and transmit properties in the constructor options object for the pins you are using:

	let serial = new device.io.Serial({
		...device.Serial.default,
		transmit: 17,
		receive: 16,
		...etc

[salarizadi]

@andycarle

Unfortunately, I don't have an oscilloscope to check further.

I don't care if I connect the two esp32 with uart, i2c or spi, all that matters is sending and receiving text data between the two esp32, any ideas? Have you done this before? I would appreciate it if you could help me

[salarizadi]

@phoddie
This seems to work and I haven't tried it, of course I mean changing the send and receive pins of the code for each esp32, interesting, I will definitely test.🙏

[salarizadi]

You are using pins 16 & 17. The default for esp32/nodemcu is 1 for transmit and 3 for receive in device.io.Serial (taken from here). You can see that in the xsbug. As noted above you should set the receive and transmit properties in the constructor options object for the pins you are using:

	let serial = new device.io.Serial({
		...device.Serial.default,
		transmit: 17,
		receive: 16,
		...etc

It's done 🎊😍 Now I connected two esp32 via uart and as expected they send and receive text at high speed.
Thank you🙏

[salarizadi]

@phoddie There is a new problem and I did everything I could but I could not solve this problem. When one of the two esp32 is off, the other one from the command:

const message = String.fromArrayBuffer(this.read());

It shows an error (FromArrayBuffer: Invalid UTF-8!) and it also crashes.

Note : And even the try catch command cannot prevent it from crashing

[phoddie]

As the error indicates, String.fromArrayBuffer requires a buffer that contains valid UTF-8 data. The buffer you have passed apparently does not. An alternative is to use the TextDecoder which has the option of accepting invalid UTF-8 data. For example:

const decoder = new TextDecoder
let serial = new device.io.Serial({
	...device.Serial.default,
	baud: 115200,
	port: 2,
	format: "buffer",
	onReadable: function(count) {
		const str = decoder.decode(this.read(), {stream: true});
		this.write(ArrayBuffer.fromString(str + "\r\n"));
	},
});

The TextDecoder API follows the Web standard found in browsers. You will need to include the TextDecoder manifest in your project to use it and import the module as described in the documentation.

Note : And even the try catch command cannot prevent it from crashing

Important Note

When you report a problem, you are obliged to also share the code to reproduce it. Otherwise, we are left to guess. That is inefficient.

When String.fromArrayBuffer is passed invalid data, it throws an exception. The exception can be caught normally. Here's an example:

let s;
try {
	let bytes = Uint8Array.of(255, 254);
	s = String.fromArrayBuffer(bytes.buffer);
}
catch (e) {
	trace(`Exception ${e}\n`);
}

trace(`String: ${s}\n`);

[salarizadi]

@phoddie

When you report a problem, you are obliged to also share the code to reproduce it. Otherwise, we are left to guess. That is inefficient.

Yes, you are right, I apologize for this negligence

The code was this

try and catch did not work here

try {
  const message = String.fromArrayBuffer(this.read());
} catch ( e ) {
   trace(e)
}

The work is finished

During this time, while I was waiting for your answer, I came up with solutions and I was able to fix it, and now we can generally say that we were able to successfully establish a connection between two esp32.

onReadable: function(count) {
          if ( count ) {
                const read = this.read();
                if ( read && read.byteLength ) {
                    let string = "", bytes = new Uint8Array(read), length = bytes.length;
                    for (let i = 0; i < length; i++) {
                        string += String.fromCodePoint(bytes[i])
                    }
                    trace(`New message : ${string}`)
                }
         }
}

With this, at least there is no need to import or add anything and it's exactly what I wanted. Thanks for your help.
Now that it's done, I'll be releasing a new module for the Moddable SDK in a few minutes.

[phoddie]

try and catch did not work here

Thanks for the fragment. Unfortunately, I'm not able to reproduce the crash you report.

I came up with solutions...

Your approach will work with a couple of caveats:

• The data must always be 7-bit ASCII. Any other characters will be improperly converted.
• The data rate should be low. Creating a string one byte at a time is inefficient. For high speed transfer of lots of data, it will eventually be a problem.

Using standard TextDecoder solves both of those.

it's exactly what I wanted

Great news!

[salarizadi]

@phoddie Thanks for your help, looks like I need to spend some time to release a new version of the module I just released and follow your solution with what you described, but my method works fine However, I will try more

[salarizadi]

@phoddie I did it with your method (TextDecoder). It's really great, now it supports Persian UTF-8 characters and has a really high transfer and reception speed. Thank you. Now I will update the module I wrote.🙏

[phoddie]

Thanks for giving it a try. Glad it worked out.

[salarizadi]

@phoddie Hi. First of all, let me say that this matter has nothing to do with this discussion, I just didn't want to open a new discussion, that's why I'm asking you here. I want to connect the CH376 module to ESP32 using UART, but I ran into a problem. According to the CH376 datasheet, I transferred the commands to the module through UART and it worked correctly until I wrote it with JavaScript, then it stopped working.

These are commands that should be sent to the module via UART in the form of bytes, but I could not send these bytes with JavaScript code :

const serial = new device.io.Serial({
        ...device.Serial.default,
        transmit: 17,
        receive: 16,
        baud: 9600,
        port: 2
 })

serial.write(0x57)
serial.write(0xAB)
serial.write(0x05)

It worked correctly with ESP IDF C code :

#define ECHO_UART_PORT_NUM UART_NUM_2
#define ECHO_TEST_RTS (UART_PIN_NO_CHANGE)
#define ECHO_TEST_CTS (UART_PIN_NO_CHANGE)
#define ECHO_UART_BAUD_RATE   (9600)
#define ECHO_TASK_STACK_SIZE  (CONFIG_EXAMPLE_TASK_STACK_SIZE)

uart_config_t uart_config = {
        .baud_rate = ECHO_UART_BAUD_RATE,
        .data_bits = UART_DATA_8_BITS,
        .parity    = UART_PARITY_DISABLE,
        .stop_bits = UART_STOP_BITS_1,
        .flow_ctrl = UART_HW_FLOWCTRL_DISABLE,
        .source_clk = UART_SCLK_APB,
};
    int intr_alloc_flags = 0;
    if (uart_param_config(ECHO_UART_PORT_NUM, &uart_config) != ESP_OK) {
        xsTrace("\nFailed uart_param_config");
    }
    if (uart_set_pin(ECHO_UART_PORT_NUM,17,16, ECHO_TEST_RTS, ECHO_TEST_CTS) != ESP_OK) {
        xsTrace("\nFailed uart_set_pin");
    }
    if (uart_driver_install(ECHO_UART_PORT_NUM, 1024 * 2, 0, 0, NULL, intr_alloc_flags) != ESP_OK) {
        xsTrace("\nFailed uart_driver_install");
    }
    xsTrace("\nSuccess ch376 uart config");

uint8_t hexdata[3] = {0x57,0xAB,0x05};
uart_write_bytes(ECHO_UART_PORT_NUM,&hexdata[0],(size_t)1);
uart_write_bytes(ECHO_UART_PORT_NUM,&hexdata[1],(size_t)1);
uart_write_bytes(ECHO_UART_PORT_NUM,&hexdata[2],(size_t)1);

What is wrong?

[phoddie]

The uart_config_t is basically the same between the two cases. Here's the ESP32 Serial IO:

moddable/modules/io/serial/esp32/serial.c

Lines 146 to 151 in 1614168

	uartConfig.baud_rate = baud;
	uartConfig.data_bits = UART_DATA_8_BITS;
	uartConfig.parity = UART_PARITY_DISABLE;
	uartConfig.stop_bits = UART_STOP_BITS_1;
	uartConfig.flow_ctrl = UART_HW_FLOWCTRL_DISABLE;
	uartConfig.rx_flow_ctrl_thresh = 120; // unused. no hardware flow control.

Your C example also sets .source_clk to UART_SCLK_APB. The value of UART_SCLK_APB is 0, and the uartConfig is initialized to zero, so that shouldn't be a problem. You could try setting it, just to be sure.

Is it possible that the ch376 is sensitive to the timing of those three bytes? If so, you could try sending them all at once:

serial.format = "buffer";
serial.write(Uint8Array.of(0x57,0xAB,0x05));

[salarizadi]

You are really great, thank you. I was able to mount the USB. I will complete the library soon and upload it so that everyone can use it.

This method worked but with specific timing :

this.serial = new device.io.Serial({
        ...device.Serial.default,
        transmit: 17,
        receive: 16,
        baud: 9600,
        port: 2,
        format: "buffer",
        onReadable: function(count) {
                const buffer = this.read()
                const array  = new Uint8Array(buffer)
                trace("\nReadable : " + JSON.stringify(array))
                this.write(buffer);
            }
      })

this.serial.write(Uint8Array.of(0x57, 0xAB, 0x05)); // Reset All
Timer.delay(200)

this.serial.write(Uint8Array.of(0x57, 0xAB, 0x15, 0x06)); // USB Mode
 Timer.delay(20)

//...Other commands

[phoddie]

Cool. Glad that helped.

I guess your onReadable function is just a placeholder? It is currently echoing all bytes it receives back to the CH376S.

[salarizadi]

According to the tests I did again, this.write is not needed, but onReadable, as you know, is needed to read information, for example, 0x14 is received from CH376, which means the operation has been successfully completed.

const buffer = this.read()
const array  = new Uint8Array(buffer)
trace("\nReadable : " + JSON.stringify(array))

Readable : {"0":81,"1":21,"2":20} // success reset
Readable : {"0":20} // success usb mode
Readable : {"0":21} // USB mounted
Readable : {"0":22} // USB unmount
Readable : {"0":21} // USB mounted

[phoddie]

According to the tests I did again, this.write is not needed

OK, good.

but onReadable, as you know, is needed to read information

Of course.