How can I use PA9 and PA10 pins as serial port for STM32F030 board?

[rtek1000]

Hello,

I tried using different means to trigger PA9/PA10 pins as serial port but there seems to be some blocking (The LED does not blink if you try to use the PA9/PA10 pins).

I also noticed that I2C port may be available for these PA9/PA10 pins, in that case how to disable or remap these I2C pins to use PA9/PA10 pins as serial port?

uint32_t ledcnt1 = 0;

//                      RX    TX
HardwareSerial SerialMy1(PA10, PA9);
HardwareSerial SerialMy2(PA3, PA2);

void setup() {
  pinMode(PA4, OUTPUT);

  SerialMy1.begin(9600);
  SerialMy2.begin(9600);
}

void loop() {
  if ((millis() - ledcnt1) > 100) {
    ledcnt1 = millis();

    //SerialMy1.write(48);
    SerialMy2.write(48);

    digitalWrite(PA4, !digitalRead(PA4));
  }
}

[fpistm]

PA4 is configured output so use digitalToggle api.
While you do not use Wire pins are not used for I2C.

Finally, there is only one USART instance USART1. So as you defined 2 Hardware Serial on the same USART only the last one instantiate works. So remove SerialMy2 and use only SerialMy1.

Arduino_Core_STM32/variants/STM32F0xx/F030F4P/PeripheralPins.c

Line 93 in eebd0e3

{PA_2, USART1, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF1_USART1)},

[rtek1000]

Thanks for the explanation, how can I operate with both serial (PA2/3 and PA9/10) ports if there is only one instance? Or is there no way to operate two serial ports at the same time with Arduino IDE?

The goal is to make an adapter, I have a camera that operates at 9600 baud and a pan-tilt support that operates at 2400 baud, so I need two hardware serial ports.

With this code the LED doesn't blink, maybe I should have understood how to make both ports work, but I still haven't:

uint32_t ledcnt1 = 0;

//                      RX    TX
HardwareSerial SerialMy1(PA10, PA9);

void setup() {
  // initialize digital pin LED_BUILTIN as an output.
  pinMode(PA4, OUTPUT);

  SerialMy1.begin(9600);
  Serial.begin(9600);
}

void loop() {
  if ((millis() - ledcnt1) > 100) {
    ledcnt1 = millis();

    SerialMy1.write(48);
    //Serial.write(48);

    digitalToggle(PA4);
  }
}

[rtek1000]

Ok, I understand, this uC has only one hardware:

[rtek1000]

In case anyone needs this,

The data leaves the camera at 9600 baud, passes through the Bluepill and arrives at the support at 2400 baud. The Bluepill running at 72MHz is losing data.

The Arduino system seems too slow to process the data, which is not much.

I bought a stand in China and it wasn't specified that it was 2400 baud in the ad, so I need an adaptation.

I managed to make the support move, but it is losing data. Even though it is just sending data (9600 --> 2400), the Pelco D protocol provides for a response from support, so it still needs the other party, from 2400 to 9600 serial ports.

uint32_t ledcnt1 = 0;

//                      RX    TX
HardwareSerial SerialMy2(PA3, PA2);

void setup() {
  // initialize digital pin LED_BUILTIN as an output.
  pinMode(PC13, OUTPUT);

  Serial.begin(9600);
  SerialMy2.begin(2400);
}

void loop() {

}

void serialEvent() {
  while (Serial.available()) {
    SerialMy2.write(Serial.read());
    //digitalWrite(PC13, !digitalRead(PC13));
  }
}

[fpistm]

I advise to not use serialEvent as it is not a real handler.... Arduino also think to remove it.
Do it is the loop. You can also add a SerialMy2.flush() after the write.

[rtek1000]

I found the code generated in the DeepSeek chat interesting:

Below is a program for the ESP32 microcontroller that implements a speed converter for serial communication. The program uses two serial ports: Serial1 (9600 baud) and Serial2 (2400 baud). It also uses two 16-byte circular buffers to ensure that data is not lost when transferring between the two ports.

#include <Arduino.h>

#define BUFFER_SIZE 16

// Circular buffer for Serial1 (9600 baud)
uint8_t buffer1[BUFFER_SIZE];
volatile uint8_t head1 = 0;
volatile uint8_t tail1 = 0;

// Circular buffer for Serial2 (2400 baud)
uint8_t buffer2[BUFFER_SIZE];
volatile uint8_t head2 = 0;
volatile uint8_t tail2 = 0;

void setup() {
  // Initialize Serial1 at 9600 baud
  Serial1.begin(9600);

  // Initialize Serial2 at 2400 baud
  Serial2.begin(2400);
}

void loop() {
  // Check if data is available on Serial1
  if (Serial1.available()) {
    // Read data from Serial1
    uint8_t data = Serial1.read();

    // Store data in buffer1
    buffer1[head1] = data;
    head1 = (head1 + 1) % BUFFER_SIZE;

    // If buffer is full, discard the oldest data (tail)
    if (head1 == tail1) {
      tail1 = (tail1 + 1) % BUFFER_SIZE;
    }
  }

  // Check if data is available on Serial2
  if (Serial2.available()) {
    // Read data from Serial2
    uint8_t data = Serial2.read();

    // Store data in buffer2
    buffer2[head2] = data;
    head2 = (head2 + 1) % BUFFER_SIZE;

    // If buffer is full, discard the oldest data (tail)
    if (head2 == tail2) {
      tail2 = (tail2 + 1) % BUFFER_SIZE;
    }
  }

  // Send data from buffer1 to Serial2 (9600 -> 2400)
  if (tail1 != head1) {
    Serial2.write(buffer1[tail1]);
    tail1 = (tail1 + 1) % BUFFER_SIZE;
  }

  // Send data from buffer2 to Serial1 (2400 -> 9600)
  if (tail2 != head2) {
    Serial1.write(buffer2[tail2]);
    tail2 = (tail2 + 1) % BUFFER_SIZE;
  }
}

Explanation:
Circular Buffers:

Two circular buffers (buffer1 and buffer2) are used to store data received from Serial1 and Serial2, respectively.

Each buffer has a head and tail index to manage the circular nature of the buffer.

If the buffer is full, the oldest data is discarded to make room for new data.

Serial Ports:

Serial1 is initialized at 9600 baud, and Serial2 is initialized at 2400 baud.

Data received on Serial1 is stored in buffer1, and data received on Serial2 is stored in buffer2.

Data Transfer:

The program continuously checks if there is data available on either serial port.

If data is available, it is read and stored in the corresponding buffer.

The program then checks if there is data in the buffers to be sent to the other serial port.

Data from buffer1 is sent to Serial2, and data from buffer2 is sent to Serial1.

Priority:

The priority is implicitly given to Serial1 because the program checks Serial1 first in the loop() function. However, both ports are handled in a non-blocking manner, so data is processed as it arrives.

Notes:
The circular buffer size is set to 16 bytes (BUFFER_SIZE). You can adjust this size based on your specific requirements.

The program assumes that the ESP32 has two hardware serial ports (Serial1 and Serial2). If your ESP32 model has different serial port configurations, you may need to adjust the code accordingly.

This code does not include error handling for buffer overflows or other potential issues. You may want to add additional checks depending on your application's requirements.

Upload this code to your ESP32 using the Arduino IDE, and it should work as a speed converter between the two serial ports.

My request:

Hello, could you help me with a microcontroller program? The program should serve as a speed converter for serial communication, with one port being 9600 and the other 2400, the priority should be port 1; data should be received on both ports, with the help of a 16-byte circular buffer, so that data is not lost. Arduino IDE compiler, ESP32 microcontroller. The ESP32 needs to receive data via serial port 1 at 9600 baud, and send the data received via serial port 2 at 2400 baud. Similarly, data received via serial port 2 needs to be sent via serial port 1.

(I put ESP32 in the chat, due to the greater number of examples than STM32)

• I haven't tested the code yet. But the idea of ​​Flush after Write, it's interesting that the chat didn't suggest it.