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

Peter W. (petwey) OP 11.07.2023 11:22 #7452332

Lesenswert?

•

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

  Classes, SysUtils, Forms, Controls, Graphics, Dialogs, StdCtrls, ExtCtrls,

  SdpoSerial, LazSerial;

  { 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;

  Form1: TForm1;

implementation

  Math;

{$R *.lfm}

{ TForm1 }

function TForm1.RandStr(Min, Max : Integer) : string;

  i, j : Integer;

begin

  j := RandomRange(Min, Max);

  result := '';

  for i := 1 to j do

    result := result + Chr(RandomRange(65,90))

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);

procedure TForm1.CheckBox1Change(Sender: TObject);

begin

  PC.Active := CheckBox1.Checked;

  HB.Active := CheckBox1.Checked;

  MR.Active := CheckBox1.Checked;

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;

procedure TForm1.FormCreate(Sender: TObject);

begin

  Randomize;

  PC_Buf := '';

  HB_Buf := '';

  MR_Buf := '';

  RecvCnt := 0;

end;

procedure TForm1.HBRxData(Sender: TObject);

  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);

  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);

  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.

Antwort Zitieren Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Beitrag melden

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

Antwort schreiben