UART to port szeregowy – można go znaleźć na pinout RPi i wykorzystać do połączenia z innym urządzeniem – np. z STM32 lub drugim RPi.

Łączymy w tym celu:
RX – TX
TX – RX
GND – GND (UWAGA! przy różnych zasilaniach obu urządzeń musi być wspólna masa, łączymy je)

(na krzyż). Musimy ustawić wspólną szybkość transmisji (w przykładzie 9600 baud – bezpiecznie, ale można też 115200 lub inne standardowe wartości).

Włączamy transmisję UART w Rpi

W tym celu wpisz:

1
2
sudraspi-config
INTERFACING OPTIONS -> P6 Serial -> DISABLE!! logging via UART -> Enable hardware UART.

To ważne, aby wyłączyć konsolę przez UART, bo służy ona do logowania się przez UART (np. z terminala komputerowego przez FTDI).

Następnie restartujemy – mamy teraz nowe urządzenie:

1
/dev/serial0

i możemy się połączyć:

1
sudo screen /dev/serial0 9600

Zakończenie aplikacji: Ctrl A potem D

Jeśli już w systemie nam działa UART, teraz można działać w C:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
#include <stdio.h>
#include <string.h>


//Linux
#include <fcntl.h> // Contains file controls like O_RDWR
#include <errno.h> // Error integer and strerror() function
#include <termios.h> // Contains POSIX terminal control definitions
#include <unistd.h> // write(), read(), close()


int serial_port, //global port for TTY UART
    stopServer = 0; //global stopServer for ALL THREADS later
//char *save_buf_ptr;

int init_ttyUSB0()
{
 serial_port = open("/dev/serial0", O_RDWR); //devUSB0 if we use FTDI for external UART

  // Create new termios struct, we call it 'tty' for convention
  struct termios tty;

  // Read in existing settings, and handle any error
  if(tcgetattr(serial_port, &tty) != 0) {
      printf("ERR (203) Error %i from tcgetattr: %s - RUN AS A ROOT?!\n", errno, strerror(errno));
      return 203;
  }

  tty.c_cflag &= ~PARENB; // Clear parity bit, disabling parity (most common)
  tty.c_cflag &= ~CSTOPB; // Clear stop field, only one stop bit used in communication (most common)
  tty.c_cflag &= ~CSIZE; // Clear all bits that set the data size
  tty.c_cflag |= CS8; // 8 bits per byte (most common)
  tty.c_cflag &= ~CRTSCTS; // Disable RTS/CTS hardware flow control (most common)
  tty.c_cflag |= CREAD | CLOCAL; // Turn on READ & ignore ctrl lines (CLOCAL = 1)

  tty.c_lflag &= ~ICANON;
  tty.c_lflag &= ~ECHO; // Disable echo
  tty.c_lflag &= ~ECHOE; // Disable erasure
  tty.c_lflag &= ~ECHONL; // Disable new-line echo
  tty.c_lflag &= ~ISIG; // Disable interpretation of INTR, QUIT and SUSP
  tty.c_iflag &= ~(IXON | IXOFF | IXANY); // Turn off s/w flow ctrl
  tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP|INLCR|IGNCR|ICRNL); // Disable any special handling of received bytes

  tty.c_oflag &= ~OPOST; // Prevent special interpretation of output bytes (e.g. newline chars)
  tty.c_oflag &= ~ONLCR; // Prevent conversion of newline to carriage return/line feed
  // tty.c_oflag &= ~OXTABS; // Prevent conversion of tabs to spaces (NOT PRESENT ON LINUX)
  // tty.c_oflag &= ~ONOEOT; // Prevent removal of C-d chars (0x004) in output (NOT PRESENT ON LINUX)

  tty.c_cc[VTIME] = 10;    // Wait for up to 1s (10 deciseconds), returning as soon as any data is received.
  tty.c_cc[VMIN] = 0;

  // Set in/out baud rate to be 9600
  cfsetispeed(&tty, B9600);
  cfsetospeed(&tty, B9600);

 // Save tty settings, also checking for error
  if (tcsetattr(serial_port, TCSANOW, &tty) != 0) {
      printf("ERR (204) Error %i from tcsetattr: %s\n", errno, strerror(errno));

      return 204;
  }
  return 0;
}


int main()
{
     char read_buf [1024];

     int errNo = init_ttyUSB0(); //inicjacja UART USB
     if (errNo > 0) return errNo;

    fprintf(stderr, "\r\nUARTLinux by FX-Team 2023\r\n\r\n");

   while (!stopServer)
        {
                 memset(&read_buf, '\0', sizeof(read_buf));
                 int num_bytes = read(serial_port, &read_buf, sizeof(read_buf));
                 if (num_bytes < 0)
                 {
                        printf("UART Read (201) - server - Error reading: %s", strerror(errno));
                        stopServer = 1;
                        return 201;
                 }

                if (num_bytes > 0)
                {
                        fprintf( stderr, "%s", read_buf);
                }
        }//while


     close(serial_port);
     stopServer = 1;

        return 0;
}
Raspberry Pi