RP2040 serielle Schnittstellen und CDC zeitgleich verwenden (C-SDK)

[Peter W. (petwey)]

Hallo Forum,

Ich will einen Pi Pico als Kommunikationsmodul verwenden. Über CDC 
sollen Kommandos vom PC zum Pico geschickt werden und später auch 
entsprechende Antworten zurückkommen. An den beiden anderen seriellen 
Schnittstellen hängen zwei weitere Geräte (kabelgebundene Fernsteuerung, 
Motorregler).

Das ganze habe ich momentan nur soweit aufgebaut, dass am PC alle 
Schittstellen ankommen (1x CDC, 2xRS232).
Dem Pico habe ich ein entsprechendes Programm verpasst, dass wenn auf 
einer Schnittstelle Daten eintreffen, diese an die nächste gesendet 
werden. Ich kann also am PC von einer auf die andere Schnittstelle 
senden. Das klappt soweit wenn ich 3x putty aufmache.

Das ist aber nicht das reale Leben. Also habe ich ein Lazarus-Programm 
geschrieben mit dem ich alle drei Schnittstellen mit Zufallstexten und 
Timergesteuert in zufälligen Intervallen zw. 20 und 90 ms versorge. 
Allen drei Schnittstellen habe ich beigebracht ein Ende-Zeichen ~ zu 
senden, damit ich die Daten besser auswerten kann.

Am PC lausche ich auf das was an den drei Schnittstellen eintrifft und 
vergleiche es mit dem was ich gesendet habe. Dabei liefert mir der 
Eingang der CDC (USB) - Schnittstelle immer Fehler -> es werden immer 
wieder einige Zeichen verschluckt. Das tritt nur an dieser Schnittstelle 
auf. Das Problem scheint mir im Pico zu liegen, aber ich verstehe nicht 
wieso die Daten nicht vollständig vom Pico Empfangen bzw. Gesendet 
werden. Wenn ich die Sende-Timer der anderen beiden Schnittstellen 
deaktiviere tritt der Fehler nicht auf.

Meine Vermutung liegt darin, dass während ich den printf der 
CDC-Schnittstelle ausführe ein Interrupt auf einer der seriellen 
Schnittstellen die Übertragung stört.

Für mich ist eine saubere Kommunikation sehr wichtig. Bitte um Hilfe 
anbei der Code:
Controlbox.c:

#include <stdio.h>
#include <string.h>
#include "pico/stdlib.h"
#include "hardware/uart.h"
#include "hardware/irq.h"
#include "hardware/gpio.h"

// UART defines
// UART0
#define UART_ID0 uart0
#define BAUD_RATE0 115200  // 230400
// UART1
#define UART_ID1 uart1
#define BAUD_RATE1 115200  // 230400

// Pin-Connections for
// UART0
#define UART_TX_PIN0 0
#define UART_RX_PIN0 1
// UART1
#define UART_TX_PIN1 8
#define UART_RX_PIN1 9

// Datenstruktur für Befehle von HB -> ControlBox
struct __attribute__ ((__packed__)) HB_Cmd {
    char Cmd[1];
    char Buf[8];
};
union HB_InUnion {
    char In[10];
    struct HB_Cmd Cmb;
} HB_In;
uint8_t HB_InCnt = 0;
bool HB_InRd = false;
bool HB_InDo = false;

// RX interrupt handler für UART0
void on_uart_rx0() {
    // Solange Zeichen im Puffer sind -> Zeichen einlesen
    while (uart_is_readable(UART_ID0)) {
        uint8_t ch = uart_getc(UART_ID0);
        // Startzeichen / initiert den Befehlsempfang
        if (ch == '/') {
            HB_InCnt = 0;                  // Zeichen-Zähler ist 0
            strcpy(HB_In.In,"         ");  // Input-String ist LEER
            HB_InRd = false;              // Lesevorgang ist nicht fertig.
            HB_InDo = true;                // Daten einfügen
        } 
        // Endezeichen ~ beendet den Befehlsempfang
        else if (ch == '~') {  
            HB_InRd = true;               // Lesevorgang ist fertig      
            HB_InDo = false;               // Daten einfügen beendet      
        }
        else if (HB_InDo){
            HB_In.In[HB_InCnt++] = ch;
        }
    }
    // Verarbeiten des Kommandos wenn vollständig
    if (HB_InRd) {
        HB_InRd = false;                  // Flag für die Datenverarbeitung zurücksetzen.
        HB_In.In[HB_InCnt] = 0;            // Nullterminierung einfügen
        char Out[13];
        // Daten für Testausgabe vorbereiten und ...
        strcpy(Out, HB_In.In);
        strcat(Out, "~");
        // ... auf anderem Port ausgeben
        while (!uart_is_writable(UART_ID1)) {}
        uart_puts(UART_ID1, Out);
    }
}

// Datenstruktur für Feedbacks vom Motorregler -> ControlBox
struct __attribute__ ((__packed__)) MR_Cmd {
    char Cmd[1];
    char Buf[8];
};
union MR_InUnion {
    char In[13];
    struct HB_Cmd Cmb;
} MR_In;
uint8_t MR_InCnt = 0;
bool MR_InRd = false;

// RX interrupt handler für UART1
void on_uart_rx1() {
    // Solange Zeichen im Puffer sind -> Zeichen einlesen
    while (uart_is_readable(UART_ID1)) {
        uint8_t ch = uart_getc(UART_ID1);
        // Startzeichen gibt es hier nicht !!!!!
        if (ch == ';') {  
            MR_InRd = true;               // Lesevorgang ist fertig      
        }
        else {
            MR_In.In[MR_InCnt++] = ch;
            if (MR_InCnt > 13) {
                strcpy(MR_In.In,"            ");
                MR_InRd = false;
                MR_InCnt = 0;
            }
        }
    }
    // Verarbeiten des Kommandos wenn vollständig
    if (MR_InRd) {
        MR_InRd = false;                  // Flag für die Datenverarbeitung zurücksetzen.
        MR_In.In[MR_InCnt] = 0;            // Nullterminierung einfügen
        char Out[16];
        // Daten für Testausgabe vorbereiten und ...
        strcpy(Out, MR_In.In);
        strcat(Out, "~");
        // ... auf anderem Port ausgeben
        printf(Out);
        //puts(Out);
        strcpy(MR_In.In,"            ");
        MR_InCnt = 0;
    }
}

// GPIO defines
// Example uses GPIO 2
#define GPIO 2


// Datenstruktur für Befehle von PC -> ControlBox
struct __attribute__ ((__packed__)) PC_Cmd {
    char Cmd[1];
    char CRC[2];
    char Buf[16];
};
union PC_InUnion {
    char In[20];
    struct PC_Cmd Cmb;
} PC_In;
uint8_t PC_InCnt = 0;
bool PC_InRd = false;
bool PC_InDo = false;


// RX interrupt handler für VCOM
void on_uart_rx2() {
    // Liest schnellstmöglich ein Zeichen ein.
    int i = getchar_timeout_us (0);
    // Solange die Lese-Aktion keinen Timeout hat -> Zeichen verarbeiten
    while (i != PICO_ERROR_TIMEOUT) {
        uint8_t ch = i;
        // Startzeichen / initiert den Befehlsempfang
        if (ch == '/') {
            PC_InCnt = 0;                            // Zeichen-Zähler ist 0
            strcpy(PC_In.In,"                   "); // Input-String ist LEER
            PC_InRd = false;                        // Lesevorgang ist nicht fertig.
            PC_InDo = true;                          // Daten einfügen
        } 
        // Endezeichen ~ beendet den Befehlsempfang
        else if (ch == '~') {  
            PC_InRd = true;                         // Lesevorgang ist fertig      
            PC_InDo = false;                         // Daten einfügen beendet      
        }
        else if (PC_InDo){
            PC_In.In[PC_InCnt++] = ch;
        }
        i = getchar_timeout_us (0);                  // Nächstes Zeichen lesen
    }
    // Verarbeiten des Kommandos wenn vollständig
    if (PC_InRd) {
        PC_InRd = false;                            // Flag für die Datenverarbeitung zurücksetzen.
        PC_In.In[PC_InCnt] = 0;                      // Nullterminierung einfügen
        char Out[22];
        // Daten für Testausgabe vorbereiten und ...
        strcpy(Out, PC_In.In);
        strcat(Out, "~");
        // ... auf anderem Port ausgeben
        while (!uart_is_writable(UART_ID0)) {}
        uart_puts(UART_ID0, Out);
    }
}

const uint LED_PIN = PICO_DEFAULT_LED_PIN;
bool led_state = 0;

// Callback-Routine für den Repeating-timer
bool repeating_timer_callback(struct repeating_timer *t) 
{
    gpio_put(LED_PIN, led_state);
    led_state = !led_state;
    return true;
}

int main()
{
    gpio_init(LED_PIN);
    gpio_set_dir(LED_PIN, GPIO_OUT);
    
    stdio_init_all();

    // Set up our UART
    uart_init(UART_ID0, BAUD_RATE0);
    uart_init(UART_ID1, BAUD_RATE1);
    // Set the TX and RX pins by using the function select on the GPIO
    // Set datasheet for more information on function select
    gpio_set_function(UART_TX_PIN0, GPIO_FUNC_UART);
    gpio_set_function(UART_RX_PIN0, GPIO_FUNC_UART);
    gpio_set_function(UART_TX_PIN1, GPIO_FUNC_UART);
    gpio_set_function(UART_RX_PIN1, GPIO_FUNC_UART);
    
    // Turn off FIFO's - we want to do this character by character
    uart_set_fifo_enabled(UART_ID0, false);
    uart_set_fifo_enabled(UART_ID1, false);

    // Set up a RX interrupt
    // We need to set up the handler first
    // Select correct interrupt for the UART we are using
    int UART_IRQ0 = UART0_IRQ;
    int UART_IRQ1 = UART1_IRQ;

    // And set up and enable the interrupt handlers
    irq_set_exclusive_handler(UART_IRQ0, on_uart_rx0);
    irq_set_enabled(UART_IRQ0, true);
    irq_set_exclusive_handler(UART_IRQ1, on_uart_rx1);
    irq_set_enabled(UART_IRQ1, true);

    // Now enable the UART to send interrupts - RX only
    uart_set_irq_enables(UART_ID0, true, false);
    uart_set_irq_enables(UART_ID1, true, false);

    // GPIO initialisation.
    // We will make this GPIO an input, and pull it up by default
    gpio_init(GPIO);
    gpio_set_dir(GPIO, GPIO_IN);
    gpio_pull_up(GPIO);
    
    struct repeating_timer timer;
    bool rm_art = add_repeating_timer_ms(500, repeating_timer_callback, NULL, &timer);

    while (true) {
        on_uart_rx2();
    }
}

CMakeLists.txt:

# Generated Cmake Pico project file

cmake_minimum_required(VERSION 3.13)

set(CMAKE_C_STANDARD 11)
set(CMAKE_CXX_STANDARD 17)

# Initialise pico_sdk from installed location
# (note this can come from environment, CMake cache etc)
set(PICO_SDK_PATH "/home/peter/pico/pico-sdk")

set(PICO_BOARD pico CACHE STRING "Board type")

# Pull in Raspberry Pi Pico SDK (must be before project)
include(pico_sdk_import.cmake)

if (PICO_SDK_VERSION_STRING VERSION_LESS "1.4.0")
  message(FATAL_ERROR "Raspberry Pi Pico SDK version 1.4.0 (or later) required. Your version is ${PICO_SDK_VERSION_STRING}")
endif()

project(ControlBox C CXX ASM)

# Initialise the Raspberry Pi Pico SDK
pico_sdk_init()

# Add executable. Default name is the project name, version 0.1

add_executable(ControlBox ControlBox.c )

pico_set_program_name(ControlBox "ControlBox")
pico_set_program_version(ControlBox "0.1")

pico_enable_stdio_uart(ControlBox 0)
pico_enable_stdio_usb(ControlBox 1)

# Add the standard library to the build
target_link_libraries(ControlBox
        pico_stdlib)
#        pico_multicore)

# Add the standard include files to the build
target_include_directories(ControlBox PRIVATE
  ${CMAKE_CURRENT_LIST_DIR}
  ${CMAKE_CURRENT_LIST_DIR}/.. # for our common lwipopts or any other standard includes, if required
)

# Add any user requested libraries
target_link_libraries(ControlBox 
        hardware_spi
        hardware_i2c
        hardware_pio
        )

pico_add_extra_outputs(ControlBox)

Pascal-Programm:

unit Unit1;

{$mode objfpc}{$H+}

interface

uses
  Classes, SysUtils, Forms, Controls, Graphics, Dialogs, StdCtrls, ExtCtrls,
  SdpoSerial, LazSerial;

type

  { TForm1 }

  TForm1 = class(TForm)
    Button1: TButton;
    CheckBox1: TCheckBox;
    CheckBox2: TCheckBox;
    Label1: TLabel;
    Memo1: TMemo;
    Memo2: TMemo;
    PC: TSdpoSerial;
    HB: TSdpoSerial;
    MR: TSdpoSerial;
    THB: TTimer;
    TMR: TTimer;
    TPC: TTimer;
    procedure Button1Click(Sender: TObject);
    procedure CheckBox1Change(Sender: TObject);
    procedure CheckBox2Change(Sender: TObject);
    procedure FormCreate(Sender: TObject);
    procedure HBRxData(Sender: TObject);
    procedure MRRxData(Sender: TObject);
    procedure PCRxData(Sender: TObject);
    procedure THBTimer(Sender: TObject);
    procedure TMRTimer(Sender: TObject);
    procedure TPCTimer(Sender: TObject);
  private
    PC_Buf, HB_Buf, MR_Buf : string;
    PC_Snd, HB_Snd, MR_Snd : string;
    RecvCnt : Integer;
    function RandStr(Min, Max : Integer) : string;
  public

  end;

var
  Form1: TForm1;

implementation

uses
  Math;

{$R *.lfm}

{ TForm1 }

function TForm1.RandStr(Min, Max : Integer) : string;
Var
  i, j : Integer;
begin
  j := RandomRange(Min, Max);
  result := '';
  for i := 1 to j do
    result := result + Chr(RandomRange(65,90))
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
  PC_Snd := RandStr(3,16)+'~';
  HB_Snd := RandStr(3,12)+'~';
  MR_Snd := RandStr(3,10);
  Memo1.Lines.Add('PC_Snd: '+PC_Snd);
  Memo1.Lines.Add('HB_Snd: '+HB_Snd);
  PC.WriteData('/'+PC_Snd);
  HB.WriteData('/'+HB_Snd);
  MR.WriteData(MR_Snd+';');
  MR_Snd := MR_Snd + '~';
  Memo1.Lines.Add('MR_Snd: '+MR_Snd);
end;

procedure TForm1.CheckBox1Change(Sender: TObject);
begin
  PC.Active := CheckBox1.Checked;
  HB.Active := CheckBox1.Checked;
  MR.Active := CheckBox1.Checked;
end;

procedure TForm1.CheckBox2Change(Sender: TObject);
begin
  Memo1.Lines.Add('Start/Stopp: '+FloatToStr(Now));
  TPC.Enabled := CheckBox2.Checked;
  THB.Enabled := CheckBox2.Checked;
  TMR.Enabled := CheckBox2.Checked;
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
  Randomize;
  PC_Buf := '';
  HB_Buf := '';
  MR_Buf := '';
  RecvCnt := 0;
end;

procedure TForm1.HBRxData(Sender: TObject);
Var
  s : string;
begin
  HB_Buf := HB_Buf + HB.ReadData;
  if Pos('~',HB_Buf) <> 0 then
  begin
    inc(RecvCnt);
    //Memo1.Lines.Add('HB: '+HB_Buf);
    if PC_Snd <> HB_Buf then
    begin
      s := FloatToStr(Now) + ': PC (' + PC_Snd + ') <> HB (' + HB_Buf + ')';
      Memo1.Lines.Add(s);
    end;
    HB_Buf := '';
    label1.Caption := IntToStr(RecvCnt);
  end;
end;

procedure TForm1.MRRxData(Sender: TObject);
Var
  s : string;
begin
  MR_Buf := MR_Buf + MR.ReadData;
  if Pos('~',MR_Buf) <> 0 then
  begin
    inc(RecvCnt);
    //Memo1.Lines.Add('MR: '+MR_Buf);
    if HB_Snd <> MR_Buf then
    begin
      s := FloatToStr(Now) + ': HB (' + HB_Snd + ') <> MR (' + MR_Buf + ')';
      Memo1.Lines.Add(s);
    end;
    MR_Buf := '';
    label1.Caption := IntToStr(RecvCnt);
  end;
end;

procedure TForm1.PCRxData(Sender: TObject);
Var
  s : string;
begin
  s := PC.ReadData;
  Memo2.Lines.Add('Recv ' + s);
  PC_Buf := PC_Buf + s;
  if Pos('~',PC_Buf) <> 0 then
  begin
    inc(RecvCnt);
    //Memo1.Lines.Add('PC: '+PC_Buf);
    if MR_Snd <> PC_Buf then
    begin
      s := FloatToStr(Now) + ' MR (' + MR_Snd + ') <> PC (' + PC_Buf + ')';
      Memo1.Lines.Add(s);
    end;
    PC_Buf := '';
    label1.Caption := IntToStr(RecvCnt);
  end;
end;

procedure TForm1.THBTimer(Sender: TObject);
begin
  THB.Enabled := False;
  HB_Snd := RandStr(3,12)+'~';
  HB.WriteData('/'+HB_Snd);
  THB.Interval :=  RandomRange(20,90);
  THB.Enabled := True;
end;

procedure TForm1.TMRTimer(Sender: TObject);
begin
  TMR.Enabled := False;
  MR_Snd := RandStr(3,9);
  //MR_Snd := CalcCRC8(MR_Snd) + MR_Snd;
  MR.WriteData(MR_Snd+';');
  MR_Snd := MR_Snd + '~';
  Memo2.Lines.Add('Send ' + MR_Snd);
  TMR.Interval :=  RandomRange(20,90);
  TMR.Enabled := True;
end;

procedure TForm1.TPCTimer(Sender: TObject);
begin
  TPC.Enabled := False;
  PC_Snd := RandStr(3,16)+'~';
  PC.WriteData('/'+PC_Snd);
  TPC.Interval :=  RandomRange(20,90);
  TPC.Enabled := True;
end;

end.