Tasmota ESP32 Berry script for UART1/2

[raduigret]

I want to write a serial bridge between UART1 (GPIO9/10) and UART2 (GPIO16/17) that passes data between UART1<>UART2. When a special command is detected on UART1 for example, I won't pass it to UART2, but reply with custom text. Could someone please give some working example how to use uart 1 and 2 with Berry and all steps needed to configure Tasmota device for it?

For example, I use below berry code to test UART1:

class UartBridge
  var uart1

  def init()
    print("Initializing UART1")
    self.uart1 = serial(9, 10, 115200)  # UART1 RX=9, TX=10
    print("UART1 initialized")
    print("Checking RX on UART1")
    if self.uart1.available() > 0
      print("UART1 RX:", self.uart1.read(self.uart1.available()))
    else
      print("No RX data on UART1")
    end
    print("Attempting TX on UART1")
    try
      self.uart1.write(bytes("UART1 TX Test\r\n"))
      print("Sent UART1 TX Test")
    except .. as e, m
      print("TX Error:", e, m)
    end
    print("Init complete")
  end
end

bridge = UartBridge()

I run it in Tasmota Berry Console and get this:

Initializing UART1
UART1 initialized
Checking RX on UART1
No RX data on UART1
Attempting TX on UART1
Sent UART1 TX Test
Init complete

So looks like working, but I don't get any output on physical uart. I also write data in a loop from PC terminal and data is not showing here (No RX data on UART1).
Maybe I'm doing something wrong in Template or Module configuration?
I set GPIO9 to SerialRX and GPIO10 to SerialTX. Is this enoug? I use ESP32 devkit v4

[sfromis]

Don't config those gpios as "Serial", as this is for Tasmota using it outside of Berry.

If you want visibility in gpio config and/or an abstraction level, you could reserve the gpios for Berry by configuring them as Input. In Berry you could then retrieve the physical gpio number (instead of hardcoding) using gpio.pin(gpio.GPIO_INPUT, 1) for the second (zero-based indexing). Of course, this does not make Tasmota behave differently.

If you want to follow input, you should be using polling at short intervals, typically by coding it as a driver and having a every_50ms callback. Then you should also take care of the risk of you getting partial messages, generally by collecting in a buffer until you are sure that you can peel off a complete message.

[raduigret]

Thanks for the reply. I don't want visibility in gpio config. I thought this is mandatory, but I just want berry script to work. I don't mind hardcoding. You mean instead of self.uart1 = serial(9, 10, 115200) to use self.uart1 = serial(gpio.pin(gpio.GPIO_INPUT, 9), gpio.pin(gpio.GPIO_INPUT, 10), 115200) ?
Anyway, even with hardcoding, it does not work. It does not output data on UART, so what am I doing wrong?

[sfromis]

The index in gpio.pin(gpio.GPIO_INPUT, 1) is not the gpio number, but if/when you configure the gpios as Input. Then index 0 is the first, and index 1 is the second, returning the physical gpio you configured as Input, like 9 and 10, respectively. This could allow the Berry code to be unchanged with different hardware setup, if gpios are configured the usual places.

Did you remove your gpio config with Serial Rx/Tx? That was the main point, the part with non-hardcoding was just an added bit of detail about keeping the code generalized without specific hardware config ties.

Anyway, here's a working POC for serial connection between two ESP32, with the gpio pairs configured as Input, and mt1.send('Hello world') working both ways, after the initialization.

class miniterm
  var ser, id, hex, start
  def init(rx, tx, baud, mode, inverted, hex)
    self.id = f'miniterm_instance_{rx}/{tx}'
    self.hex = hex
    tasmota.remove_driver(global.member(self.id))
    self.start =
      def ()
        self.msg('opening')
        self.ser = serial(rx, tx, baud==nil ? 115200 : baud, 
                                  mode==nil ? serial.SERIAL_8N1 : mode, 
                                  inverted==nil ? false : inverted)
        tasmota.add_driver(self)
        global.setmember(self.id, self)
        return self
      end
  end
  def send(msg)
    if ! self.ser return end
    self.msg('sending', msg)
    self.ser.write(self.hex ? bytes(msg) : bytes().fromstring(msg))
  end
  def close()
    if ! self.ser return end
    self.msg('closing')
    tasmota.remove_driver(self)
    self.ser.close()
    self.ser = nil
    self.id = 'closed'
  end
  def every_50ms()
    if ! self.ser return end
    if self.ser.available() == 0 return end
    var ba = self.ser.read()
    self.msg('received', self.hex ? ba.tohex() : ba.asstring())
  end
  def msg(tag, data)
    print('serial', self.id, tag, data ? data : '')
  end
end
mt1 = miniterm(gpio.pin(gpio.GPIO_INPUT,1), gpio.pin(gpio.GPIO_INPUT,0)).start()

Obviously, it also works with hardcoded gpio numbers instead of the indirection with Input.

Still, it lacks the part about handling data split in the middle of a packet (or multiple packets in sequence) and reassembling to get each message separately. It also does not cleanly close the old instance if reinitializing.

[raduigret]

Thank you very much. Is this POC in some documentation available online or you wrote it now?

[sfromis]

Just a bit of code from my stash.