UART communication between Nucleo F401RE and Teensy 4.1

[alyssaForum]

Hello everyone,

I am trying to establish a serial communication between a Teensy 4.1 and a Nucleo F401RE board. The Nucleo board reads data from some VL53L7CX ToF sensors (this part works) and send them via Serial to the Teensy (this one doesn't work).

Indeed, the Teensy never receives any data, except after the end of the initialization of the ToF sensors: it receives a 0 integer. However, at this moment of the code, no data are supposed to be sent by the Nucleo. So I don't understand where that could come from and why I can't receive the actual data written on the Serial port. Do you have any idea about that please?

I have made the following wiring:

• Pin 0 of Teensy linked to pin PA_9 (D8) of the Nucleo
• Pin 1 of the Teensy linked to pin PA_10 (D2) of the Nucleo
• GND of the Teensy linked to the GND of Nucleo

Also, here are my two codes (both were developed with the Arduino platform). The 1st one is the Nucleo's code and the 2nd one is the Teensy's code:

NUCLEO

 

/**
 ******************************************************************************
 * @file ToF_sensor_new.ino
 * @author alyssa agnissan
 * @version V1.0.0
 * @date 17 August 2023
 * @brief Read ranging data from several VL53L7CX sensor with a multiplexer
 ******************************************************************************

/************************** INCLUDES **************************/
#include <Arduino.h>
#include <Wire.h>
#include <vl53l7cx_class.h>
#include <stdio.h>

#ifdef ARDUINO_SAM_DUE
 #define DEV_I2C Wire1
#else
 #define DEV_I2C Wire
#endif
#define SerialPort Serial

#define LED_PIN PC13

#define multiplexer 0x70 // PCA9548A device I2C address 

#define TOF 4 // number of ToF
 
#define LPN_PIN1 4 // sensor #1 wiring 
#define PWREN_PIN1 A0
#define I2C_RST_PIN1 9

#define LPN_PIN2 5 // sensor #2 wiring 
#define PWREN_PIN2 A2

#define LPN_PIN3 7 // sensor #3 wiring 
#define PWREN_PIN3 A4

#define LPN_PIN4 8 // sensor #4 wiring 
#define PWREN_PIN4 A5

// #define PRINT
// #define TIME
// #define MEAN_TIME
// #define INIT

/************************** PARAMETERS **************************/
// Components.
VL53L7CX sensor1(&DEV_I2C, LPN_PIN1);
VL53L7CX sensor2(&DEV_I2C, LPN_PIN2);
VL53L7CX sensor3(&DEV_I2C, LPN_PIN3);
VL53L7CX sensor4(&DEV_I2C, LPN_PIN4);
VL53L7CX* tab_sensor[] = {&sensor1, &sensor2, &sensor3, &sensor4};

// Tabs for wiring
int PWREN_PIN[] = {PWREN_PIN1, PWREN_PIN2, PWREN_PIN3, PWREN_PIN4}; // INUTILE POUR MINI PCB

// UART port Nucleo
HardwareSerial Serial1(PA10, PA9);

// Global param.
uint8_t res = VL53L7CX_RESOLUTION_4X4;
uint8_t ranging_mode = VL53L7CX_RANGING_MODE_CONTINUOUS; // advised mode for fast ranging measurements or high performances
uint8_t address[] = {0x54, 0x56, 0x58, 0x60}; // sensors' I2C address 

char report[256];
int target_detected = 0;
int32_t sum = 0;
uint8_t status;
int time = 0; int k = 1;


/************************** FUNCTIONS **************************/
void tcaselect(byte i);
int tof_init();
void display_commands_banner(void);
void print_result(VL53L7CX_ResultsData *Result, int num_sensor);


/************************** MAIN **************************/
void setup()
{
 // Initialize serial for output.
 SerialPort.begin(115200);
 Serial1.begin(9600);
 SerialPort.println("------- BEGIN INITIALISATION -------\n");
 
 // Initialize I2C bus.
 DEV_I2C.begin();

 // ToF initialisation
 #ifdef INIT
 // unsigned long startTime = millis(); // init timer
 #endif

 if(tof_init() == -1) return;

 #ifdef INIT
 unsigned long endTime = millis();
 unsigned long elapsedTime = endTime - startTime;
 SerialPort.print("TIME FOR INITIALISATION : "); SerialPort.print(elapsedTime); SerialPort.print(" ms\n\n");
 #endif

 // Indicate end of initialisation
 pinMode(LED_PIN, OUTPUT);
 digitalWrite(LED_PIN, LOW);

 Serial.println("------- INITIALISATION DONE -------\n\n");
}


void loop()
{
 VL53L7CX_ResultsData Results;
 uint8_t NewDataReady = 0;
 target_detected = 0;
 sum = 0;

 #ifdef MEAN_TIME
 unsigned long startTime = millis(); // init timer
 #endif

 // For each sensor
 for(size_t i = 0; i < TOF; i++) {
 #ifdef TIME
 unsigned long startTime = millis(); // init timer
 #endif

 // Select the MUX pin
 tcaselect(i);
 delay(100);

 // Check if data ready
 do {
 status = tab_sensor[i]->vl53l7cx_check_data_ready(&NewDataReady);
 } while (!NewDataReady);

 // If yes, read and print it
 if ((!status) && (NewDataReady != 0)) {
 status = tab_sensor[i]->vl53l7cx_get_ranging_data(&Results);
 delayMicroseconds((1000000 * 9) / 9600);
 print_result(&Results, i);
 }

 #ifdef TIME
 // Compute the measurement time for 1 sensor
 unsigned long endTime = millis();
 unsigned long elapsedTime = endTime - startTime;
 SerialPort.print("MEASUREMENT TIME FOR ONE SENSOR : "); SerialPort.print(elapsedTime); SerialPort.print(" ms\n\n");
 #endif

 // delay(3000);
 }
 #ifdef MEAN_TIME
 // Compute the measurement time for all sensors
 unsigned long endTime = millis();
 unsigned long elapsedTime = endTime - startTime;
 time += elapsedTime;

 if(k == 50){
 SerialPort.print("MEASUREMENT TIME FOR ALL THE SENSORS : "); SerialPort.print(time/50); SerialPort.print(" ms\n\n");
 time = 0; k = 1;
 }
 k++;
 #endif
}


/************************** FUNCTIONS **************************/
// Enable requested I2C channel (0..7)
void tcaselect(byte i) {
 if (i > 7) return;
 DEV_I2C.beginTransmission(multiplexer);
 DEV_I2C.write(1 << i);
 DEV_I2C.endTransmission();
}


// ToF initialisation
int tof_init(){
 // For each ToF sensor
 for(size_t i = 0; i < TOF; i++){
 // Enable PWREN pin if present
 if (PWREN_PIN[i] >= 0) {
 pinMode(PWREN_PIN[i], OUTPUT);
 digitalWrite(PWREN_PIN[i], HIGH);
 delay(10);
 }
 }

 for(size_t i = 0; i < TOF; i++){
 // Begin sensor
 tab_sensor[i]->begin();
 SerialPort.print("Begin sensor #"); SerialPort.print(i); SerialPort.print(" OK\n");

 // Select the MUX pin
 tcaselect(i);
 SerialPort.print("MUX pin #"); SerialPort.print(i); SerialPort.print(" selected\n");
 delay(100);

 // Init sensor
 status = tab_sensor[i]->init_sensor(address[i]);
 if(status == 0) {SerialPort.print("Init sensor OK\n");}
 else {SerialPort.print("ERROR INIT SENSOR\n"); return -1;}

 // Ranging mode
 status = tab_sensor[i]->vl53l7cx_set_ranging_mode(ranging_mode);
 if(status == 0) SerialPort.print("Ranging mode OK\n");
 else {SerialPort.print("ERROR RANGING MODE\n"); return -1;}

 // Resolution
 status = tab_sensor[i]->vl53l7cx_set_resolution(res);
 if(status == 0) SerialPort.print("Resolution initialisation OK\n");
 else {SerialPort.print("ERROR RESOLUTION INITIALISATION\n"); return -1;}

 // Start Measurements
 status = tab_sensor[i]->vl53l7cx_start_ranging();
 if(status == 0) SerialPort.print("Start ranging OK\n");
 else {SerialPort.print("ERROR START RANGING\n"); return -1;}

 SerialPort.print("Initialisation sensor #"); SerialPort.print(i); SerialPort.print(" done\n\n");
 }

 return 0;
}


// Compute and print mean distance in mm
void print_result(VL53L7CX_ResultsData *Result, int num_sensor)
{
 int8_t i, j, k, l;
 uint8_t zones_per_line;
 uint8_t number_of_zones = res;

 zones_per_line = (number_of_zones == 16) ? 4 : 8;

 #ifdef PRINT
 SerialPort.print("TABLE FOR SENSOR #"); SerialPort.print(num_sensor); SerialPort.print("\n\n");
 #endif

 // For each line of the ROI
 for (j = 0; j < number_of_zones; j += zones_per_line)
 {
 #ifdef PRINT
 for (i = 0; i < zones_per_line; i++) 
 SerialPort.print(" -------");
 SerialPort.print("\n");
 
 for (i = 0; i < zones_per_line; i++)
 SerialPort.print("| ");
 SerialPort.print("|\n");
 #endif

 // For each target of the zone to study
 for (l = 0; l < VL53L7CX_NB_TARGET_PER_ZONE; l++) // VL53L7CX_NB_TARGET_PER_ZONE = 1 by default
 {
 // For each column of the studied line of the ROI
 for (k = (zones_per_line - 1); k >= 0; k--)
 {
 // If target is detected for zone positionned line j and column k
 if (Result->nb_target_detected[j+k]>0)
 {
 #ifdef PRINT
 // Print distance
 snprintf(report, sizeof(report),"| \033%5ld\033",
 (long)Result->distance_mm[(VL53L7CX_NB_TARGET_PER_ZONE * (j+k)) + l]);
 SerialPort.print(report);
 #endif

 // Add the current measured distance to all the previous ones
 sum += Result->distance_mm[(VL53L7CX_NB_TARGET_PER_ZONE * (j+k)) + l];
 target_detected ++;
 }
 #ifdef PRINT
 else
 {
 snprintf(report, sizeof(report),"| %5s ", "X");
 SerialPort.print(report);
 }
 #endif
 }
 #ifdef PRINT
 SerialPort.print("|\n");
 #endif
 }
 }
 #ifdef PRINT
 for (i = 0; i < zones_per_line; i++)
 SerialPort.print(" -------");
 SerialPort.print("\n\n");
 #endif

 // Compute and print mean distance for all the targets detected in the ROI 
 Serial1.write(sum/target_detected);
 Serial.print(sum/target_detected); Serial.print("\n");
 delay(100);
}

 

TEENSY

 

/**
 ******************************************************************************
 * @file ToF_sensor_new.ino
 * @author alyssa agnissan
 * @version V1.0.0
 * @date 17 August 2023
 * @brief Read ranging data from several VL53L7CX sensor with a multiplexer
 ******************************************************************************

/************************** INCLUDES **************************/
#include <Arduino.h>
#include <Wire.h>

/************************** PARAMETERS **************************/
bool initialisation = false;

/************************** MAIN **************************/
void setup() {
 // Initialize serial for output.
 Serial1.begin(9600);
 Serial.begin(115200);
 
 Serial.println("------- INITIALISATION DONE -------\n\n");
}

void loop() {
 int data;

 if (Serial1.available() > 0) {
 data = Serial1.read();
 Serial.print("Donnée reçue : ");
 Serial.println(data, DEC);
 }

 delay(100);
}

 

PS: I tried to use different UART pins but the problem remains the same. Also, I have seen that a bad synchronisation between receiver and transmitter could cause wrong readings. So I tried to add the line

 

delayMicroseconds((1000000 * 9) / 9600);

 

, in the Nucleo's code, to create a "silence time" in the communication to synchronise it again. No results...

Thank you very much for your help! :)

[jiangfan]

check and ensure both sides work at same baud rate first:

- Nucleo F401RE board sends specific data, such as 0x55, at 115200 or any desired baud, verify with oscilloscope

- if possible, receiver side, Teensy for you, also sends specific data, at same baud rate, verify with oscilloscope

[alyssaForum]

Hello, thanks for your answer! After a deeper look, it turned out I was sending uint8_t data via Serial, which the Teensy "didn’t like" and thus didn’t read correctly.. I changed it to int and everything works perfectly now!