Hi saramic 

hey - yeah I saw your post Forum #5: Proposed Design — Adaptive Sentinel: Security & Environmental Intelligence Hub and I presume you are trying to communicate between 2 MAX32630FTHR edge nodes to a master UNO Q via UART. I am no expert and have mostly used it to:

• communicate to a peripheral (like the fingerprint reader) (master/slave give a command and wait for response) OR
• to read output via a serial monitor on a computer (hence receive only)

The rule of thumb of UART seems to be

• RX of one device to TX of other device
• between 2 devices
• table top distance < 1m
• set the same baud rate - probably start with 9600 and move to 57600 if it works
• Same voltage 1V8 OR 3V3 OR 5V otherwise you may need a level shifter

Reading https://docs.arduino.cc/tutorials/uno-q/user-manual/

> WARNING: This interface operates at 1.8 V logic levels and must be used with a compatible USB-to-TTL converter to avoid hardware damage.

and the MAX32630FTHR is 3V3

Once you have that sorted, you would need to decide on how you want to communicate, there seem to be 3 approaches:

1. Request/Response - one device is mater and sends requests and then listens - simple and predictable
2. Turn-taking with a token/flag byte - decide on a special token (e.g. 0xFF) to decide who should be sending or listening
3. Asychronous/event-driven - dependent on UART being full-duplex - but you need start/end framing markers and buffering so you can assemble complete messages from the stream

Maybe you can get away with the UNO Q being master and asking the edge MAX32630FTHR to send back a response?

The most flexible would be the asynchronous/event-driven approach, so assuming they are hooked up like

RX on EDGE 1 wire A goes to TX on EDGE 1 wire A

+--------------+        +--------------+
| MAX32630FTHR |        | MAX32630FTHR |
|  EDGE 1      |        |  EDGE 2      |
|              |        |              |
|  RX P3_0    A|---\/---|B RX P3_0     |
|  TX P3_1    B|---/\___|A TX P3_1     |
|  GND         |--------|  GND         |
+--------------+        +--------------+

but asynchronous means you will need to define a message etc. I tried to get this working with LPSDK, Mbed and ESP32 - LPSDK working code below

Here we are using STX 0X02 (Start of Text) and ETX 0X03 (End of Text) to signify the start and end of the message

#define MSG_START   0x02    // ASCII STX
#define MSG_END     0x03    // ASCII ETX
#define BUF_SIZE    128

// -------------------------------------------------------------------------
// Send a framed message over UART2
// -------------------------------------------------------------------------
static void send_message(const char *msg)
{
    uint8_t start = MSG_START;
    uint8_t end   = MSG_END;
    UART_Write(MXC_UART2, &start, 1);
    UART_Write(MXC_UART2, (uint8_t *)msg, strlen(msg));
    UART_Write(MXC_UART2, &end, 1);

    debug_print("[TX] --> ");
    debug_print(msg);
    debug_print("\r\n");
}

in the main loop, I send a PING message every ~1 second

#define TICK_MS     10      // loop cadence
#define TICKS_PER_PING  100 // 10ms * 100 = ~1s

int main(void)
{
    while (1) {
        // TMR_Delay is blocking for TICK_MS but the hardware RX FIFO
        // (32 bytes) holds incoming bytes while we wait.
        TMR_Delay(MXC_TMR0, MSEC(TICK_MS));

        if (++tick >= TICKS_PER_PING) {
            tick = 0;
            char msg[32];
            snprintf(msg, sizeof(msg), "PING %lu", ping_count++);
            send_message(msg);
        }
    }
}

that's the easy bit - of course I can send any information like this, temperature, accelerometer values, etc

Then you need to be able to read these messages

#define MSG_START   0x02    // ASCII STX
#define MSG_END     0x03    // ASCII ETX
#define BUF_SIZE    128

// -------------------------------------------------------------------------
// Non-blocking drain of UART2 RX FIFO — call on every loop tick
// -------------------------------------------------------------------------
static void read_incoming(void)
{
    while (UART_NumReadAvail(MXC_UART2)) {
        uint8_t b;
        int     n = 0;
        UART_Read(MXC_UART2, &b, 1, &n);
        if (n != 1)
            break;

        if (b == MSG_START) {
            rx_pos     = 0;
            in_message = 1;

        } else if (b == MSG_END) {
            if (in_message && rx_pos > 0)
                handle_message(rx_buf, rx_pos);
            rx_pos     = 0;
            in_message = 0;

        } else if (in_message) {
            if (rx_pos < BUF_SIZE - 1) {
                rx_buf[rx_pos++] = b;
            } else {
                debug_print("[WARN] RX overflow, discarding\r\n");
                rx_pos     = 0;
                in_message = 0;
            }
        }
    }
}

int main(void)
{
    while (1) {
        read_incoming();
    }
}

I managed to make this work between an ESP32 and the LPSDK code above running on MAX32630FTHR - in this case the ESP32 was connected to my computer and the output was showing the ESP32 PING to the outside and the incoming PING from the MAX32630FTHR - the output looks like this (ping count dependent on restart)

[DEBUG] UART bridge ready
[RX] <-- PING 1931
[TX] --> PING 1000
[RX] <-- PING 1932
[TX] --> PING 2000
[RX] <-- PING 1933
[TX] --> PING 3000
[RX] <-- PING 1934

so there you have it - I hope the issue is not that you hooked up 1V8 on the UNO Q to the 3V3 on the MAX32630FTHR

UART is fine for 2 boards on a desk

Other alternatives are

• CAN bus
  • 128 (CAN) nodes or unlimited with CAN FD
  • 500m @125kbps or 40m @1Mbps
  • CRC + ACK + error frames
  • 2 wires twisted pair + GND
  • needs MCP2515 or similar chip
  • needs 120Ω termination resistors to prevent reflection corrupting the signal
• I2C
  
  • can have up to 127 devices
  • short distances <1m
  • Master/Slave topology fits
  • may need pull-up resistors 4.7kΩ at 100kHz
  • SDA/SCL share bus so needs collision management
• RS-485
  
  • can have 32 nodes
  • cheap MAX485 or SP3485 chips
  • still UART underneath
  • 100m+ at 100kbps
  • differential signaling means it is noise immune

there is also: LIN Bus, Modbus, EtherCAT, 1-Wire, SPI

All code can be found:

• github.com/.../src

Including some Mbed code

• github.com/.../main-mbed-uart.cpp

slight correction here - the 1.8V UART seems to be the ONLY the JCTL headers - the 5x2 header near the USB-C connector. This is if you want to connect via UART "JCTL is directly connected to the Qualcomm Dragonwing QRB2210" – MPU (Microprocessor Unit ie the Linux box) - this would let you see the Linux console etc I presume - so maybe not the most useful for connecting the device to other devices.

The MPU does not seem to have any GPIO pins connected. They all seem to be connected via the MCU (Microcontroller Unit ie. STM32U585) via JDIGITAL and JANALOG. There is also a JSPI. Keeping to the UART theme - you could communicate with your edge nodes and UART via JDIGITAL pins and the MCU - but you would still need to communicate between the MCU and the MPU if you wanted to display values on the dashboard etc. I am yet to look into this but it sounds like there might be some kind of SPI connection between the MPU's /dev/spidev0.0 and the MCU? the alternative is the RPC (Remote Procedure Call)

> "A built-in RPC library (i.e., Arduino Bridge) brings together the MPU running Linux and the microcontroller"

I am sure I will run into working this out soon as I start trying to connect my UNO Q via CAN Bus

Good to know i have a fellow developer in LPSDK