Zurück (C) Christof Ermer, Regensburg
Gästebuch (public. sonst besser Email)



10.07.2014
neuer Anlauf
16.092021

Raspberry Pi

Nach längerer Zeit starte ich nochmal mit einem Projekt in ANSI-C,
UART, SD Card Lesen und Kommandos + Daten an externe MPU senden:
#C_Programm_UART_File_Befehle
#DHCP_Geht_nicht   am Uni Regensburg Netz. DHCP problem . IPV6 deaktivieren
Fundus:
Sehr gut brauchbare INFOs zum RaspBerry: https://www.elektronik-kompendium.de/sites/raspberry-pi/
https://www.notebookcheck.com/Iconikal-Diese-10-Dollar-Platine-ist-schneller-als-ein-Raspberry-Pi-und-bringt-Zubehoer-mit.493477.0.html

Projekte
HAM Clock
Uhr mit Weltkarte:   https://www.youtube.com/watch?v=JTH1QKqCu3c


mit BCM2835   Multimedia Chip für Smartphones Tabletts oder Satreceiver

Model A

  • •

    Modellbezeichnung:

    Raspberry Pi Mod A

  • •

    Typ:

    Mini-PC

  • •

    Technologie:

    ARM

  • •

    Ausführung:

    256 MB

  • •

    USB:

    ja

  • •

    HDMI:

    ja

  • •

    Länge:

    85,6 mm

  • •

    Breite:

    53,98 mm

  • •

    Höhe:

    17 mm

 Model B

  • •

    Modellbezeichnung:

    Raspberry Pi Mod B

  • •

    Typ:

    Mini-PC

  • •

    Technologie:

    ARM

  • •

    Ausführung:

    512 MB

  • •

    USB:

    ja

  • •

    HDMI:

    ja

  • •

    Länge:

    85,6 mm

  • •

    Breite:

    53,98 mm

  • •

    Höhe:

    17 mm

Raspberry_Pi_Model_A (habe aber auch B als Bezeichnung gefunden)
PI Model B/ B+)  512MB

Anmerkung; RaspBerry P2 ist ohne WLAN....
Daher gleich P3, P4
  PI-3 --> PI 3 Model B oder B+
Pi 4

PI -3



Projekte Fundus:
Projekt Raspberry PI Radio ,it RTL USB2382U  http:/ /www.watterott.net/
Raspberry Pi: UART senden und empfangen in C https://www.einplatinencomputer.com/raspberry-pi-uart-senden-und-empfangen-in-c/
Raspberry Pi: Serielle Schnittstelle Sehr gute Beschreibung: http://www.netzmafia.de/skripten/hardware/RasPi/RasPi_Serial.html#:~:text=Sie%20rufen%20raspi%2Dconfig%20auf,zum%20Deaktivieren%20der%20seriellen%20Konsole.


Wichtige Kurzbefehle unter Linux

 Betriebssystem:
Standard  System und Password
pi
Password: raspberry
Note changed password! 
sudo passwd root    This will set the root account password, so you can then use root
root  =   Der Systemverwalter
sudo raspi-config

Nice to Know
aus https://www.elektronik-kompendium.de/sites/raspberry-pi/2006071.htm
Folgendes Kommando gibt aus, welches Modell genau verwendet wird.
cat /sys/firmware/devicetree/base/model

Um umfangreiche Hardware-Informationen zu bekommen eignet sich das Tool "lshw", dass man in der Regel nachträglich installieren muss.
sudo apt-get install lshw

Informationen über dieNetzwerk-Schnittstelle:
sudo lshw | tail -n 9 | grep -iE "size|capacity|capabilities|speed"

Die aktuelle Konfiguration kann man sich wie folgt ausgeben lassen.
vcgencmd get_config int


WIE GEHT AUSSCHALTEN ?  sudo shutdown now
oder mit Batch         in Textatei "Runterfahren" schreiben und mit chmod als Ausführbar kennzeichnen
# chmod a+x /home/pi/Desktop/BASHs/Runterfahren

#! /bin/bash
echo Shutdown
sudo shutdown now

Mit Neustart   sudo shutdown -r now


BATCH:   Beispiel  Datum
#! /bin/bash
# /home/pi/Desktop/BASHs
# chmod a+x /home/pi/Desktop/BASHs/Hello
cd /home/pi/Desktop/BASHs/
ls -l
PI=3.1415926
echo ..........................
echo "Hello World!"
echo "Datum="$(date  "+%D    Uhr=%H:%M:%S")
echo 'PI='$PI
echo ..........................


DHCP Geht nicht
Netzwerk Problem. DHCP ( an der Uni-Regensburg ) geht nicht. ? Warum?  recherche->
1.
Analystool --> ethtool
Code
sudo apt-get update
sudo apt-get install ethtool
sudo ethtool eth0
iconfig
interface 
 LAN = eth0

Probiere:
sudo ifup eth0
oder
sudo dhclient -v eth0

Die IPv4-Adressen der folgenden Beispiel sind an die jeweiligen Erfordernisse anzupassen.
IP-Adresse und Subnetzmaske:
sudo ip addr add 192.168.1.5/24 dev eth0
#Standard-Gateway:
sudo ip route add default via 192.168.1.1
#Oder:
sudo route add default gw 192.168.1.1 eth0
#Der DNS-Server muss fest in die Datei "/etc/resolv.conf" eingetragen werden:
sudo echo "nameserver 192.168.0.1" >> /etc/resolv.conf

Bedeutung subnetmask
Die Netzmaske, Netzwerkmaske oder Subnetzmaske ist eine Bitmaske, die im Netzwerkprotokoll IPv4 bei der Beschreibung von IP-Netzen angibt, welche Bit-Position innerhalb der IP-Adresse für die Adressierung des Netz- bzw. Host-Anteils genutzt werden soll.
Beispiel:
subnetmask=        255.255.248.0
IP Adresse Bsp:    132.199.100.88
255 = 0b1111 1111  
248 = 0b1111 1000
100 = 0b0110 0100
                                               NETZ 132          199            100  |        88 (Host)
IP Adresse =    132.199.100.88 =    10000100 -  11000111 - 01100100 - 01011000       
subnetmask =    255.255.248.0  =    11111111  - 11111111 - 11111000 - 00000000
                                                          255            255            248               0
                                                      |...... NETZ.Anteil............... | ---- HOST -----|

es können also xxxxx000.000.0000   = 2047 PCs adressiert werden

neu -->/etc/dhcpcd.conf

Klassische /etc/network/interfaces   sieht so aus:
***************HierGehtDasLos**********************
auto lo
iface lo inet loopback
auto eth0
iface eth0 inet dhcp
allow-hotplug wlan0
iface wlan0 inet manual
wpa-roam /etc/wpa_supplicant/wpa_supplicant.conf
iface default inet dhcp
***************HierIstDasZuEnde**********************

/etc/network/interfaces sieht so aus:
***************HierGehtDasLos**********************
auto lo
iface lo inet loopback
auto eth0
iface eth0 inet dhcp
allow-hotplug wlan0
iface wlan0 inet manual
wpa-roam /etc/wpa_supplicant/wpa_supplicant.conf
iface default inet dhcp
***************HierIstDasZuEnde**********************

1. Statische IP4 Adresse einfügen
sudo nano /etc/dhcpcd.conf # Example static IP configuration:
interface eth0
static ip_address=132.199.100.88
#99.168.0.10/24
#static ip6_address=fd51:42f8:caae:d92e::ff/64
static routers=132.199.103.254
#192.168.0.1
static domain_name_servers=194.94.152.1
#192.168.0.1 8.8.8.8 fd51:42f8:caae:d92e::1
2. und evtl noch: IPV6 entfernen
#  NO --> IPV6 Entfernen,  deaktivieren.
http://www.schroeter-edv.de/?Dokumentation___Raspberry_Pi___Diverse_Anleitungen_und_HowTo%27s___RPi_3_-_IPv6_Protokoll_dauerhaft_deaktivieren

TUE DAS NICHT --.. war sinnlos:
1. sudo nano /etc/modprobe.d/ipv6.conf alias net-pf-10 off
alias ipv6 off
# disabled ipv6 module
options ipv6 disable_ipv6=1
# not loading ipv6 driver
blacklist ipv6 2. sudo  nano /boot/cmdline.txt
ipv6.disable=1
..........................................
Ab dann ging Ipconf  mit richtiger Adresse

sudo nano /etc/dhcpcd.conf

BATCH
#! /bin/bash
sudo ip addr add 132.199.100.88 dev eth0
#Standard-Gateway:
sudo ip route add default via 132.199.103.254
#Oder:
sudo route add default gw 132.199.103.254 eth0
#Der DNS-Server muss fest in die Datei "/etc/resolv.conf" eingetragen werden:
sudo echo "nameserver 194.94.152.1" >> /etc/resolv.conf
ifconfig
read -p Druecke_Taste
Wlan PassPhrase

sudo -i
wpa_passphrase "WLAN-NAME" "WLAN-PASSWORT" >> /etc/wpa_supplicant/wpa_supplicant.conf
exit


Netzwerk DHCP testen
sudo service dhcpcd status
BEISPIEL:
RASPBERRY , for static routing use 
sudo nano /etc/dhcpcd.conf
interface eth0=132.199.100.88
static routers=132.199.103.254
static domain _name_servers=194.94.152.1

sudo ip address show

sudo nano /etc/network/interfaces
# Ethernet
auto eth0
allow-hotplug eth0
iface eth0 inet static
address 132.199.100.88
netmask 255.255.248.0
gateway 132.199.103.254
dns-nameservers 194.94.152.1

systemctl status dhcpcd
sudo netstat -ulpena | grep -i dhcp
ls -la /var/lib/dhcpcd5
dhcpcd -4 -U wlan0
cat /etc/dhcpcd.conf

Netzwerkmonitor
https://www.heise.de/ratgeber/Netzwerke-testen-mit-dem-Raspberry-Pi-4168922.html
https://www.raspberry-pi-geek.de/ausgaben/rpg/2018/04/das-lokale-netzwerk-immer-im-blick/

wget http://packages.ntop.org/apt/ntop.key
sudo apt-key add ntop.key
echo "deb http://apt.ntop.org/stretch_pi armhf/" | sudo tee -a /etc/apt/sources.list
echo "deb http://apt.ntop.org/stretch_pi all/" | sudo tee -a /etc/apt/sources.list
sudo apt update
sudo apt install ntopng nprobe
sudo systemctl enable ntopng
sudo systemctl start ntopng

Anschließend geben Sie den Befehl hostname ein, um den vollständigen Domainnamen zu ermitteln. Auf die Weboberfläche gelangen Sie dann über die URL http://Hostname:3000. Nach dem Aufruf der URL fordert Ntopng Sie auf, sich anzumelden. Dazu nutzen Sie den Benutzernamen admin und das gleichlautende Passwort.

Was tun bei Neuinstallation

Netzwerkkabel anschließen    Netzwerk, WLAN Stick.
dann:
sudo     eingeben...
( WARTEN NACH ENTER, Dauert etwas )
Für ein deutschsprachiges System braucht es de_DE.UTF-8
dort:     de_DE.UTF-8 UTF-8   auswählen für deutsch...

evtl.   $ sudo dpkg-reconfigure locales
…ausführen und dann die nachfolgenden Dialoge entsprechend beantworten.
Aktiviert im ersten Dialog die Generierung der Lokalisierung für “de_DE.UTF-8″
und im Zweiten wählt Ihr eure neue Sprache als Standard für das komplette System aus,LOGIN:

Beachtet bitte, dass das Passwort ein “y” enthält, das System aber eine englische Tastatur erwartet.Gebt also – wenn Ihr nicht sowieso mit einer englischen Tastatur arbeitet – raspberrz als Passwort ein.
sudo login login: pi
password:   raspberry
sudo shutdown now    für herunterfahren eingeben


$ sudo apt-get update
sudo apt-get update && sudo apt-get upgrade -y
$ sudo apt-get dist-upgrade

EXPAND File System
sudo raspi-config
-> 7 Advanced Options
-> A1 Expand Filesystem
https://www.simon42.com/raspberry-pi-sd-karte-klonen-unter-raspbian/#gs.eiyf3l

$ sudo adduser christof
$ sudo adduser christof admin        ( dies führt zu Meldung  gruppe admin existiert nicht   ???)
    siehe http://wiki.ubuntuusers.de/Benutzer_und_Gruppen?highlight=adduser%20Gruppe

    einen SSH Server sollte man auch gleich installieren
$ sudo apt-get install openssh-server         ist aber in neuen Systemen schon drin
startx      --> die GUI Oberfläche

Admin muss in sudoers file stehen !! http://wiki.ubuntuusers.de/sudo/Konfiguration
Die Datei /etc/sudoers sollte immer mit dem Befehl visudo bearbeitet werden, da so eine Syntaxüberprüfung gewährleistet ist. Bei der direkten Bearbeitung ohne Prüfung kann der kleinste Tippfehler dazu führen, dass man sich aus dem System aussperrt und nur über den Recovery Modus wieder Zugang erhalten kann.

Neuinstallation mit UART Nutzung
http://www.netzmafia.de/skripten/hardware/RasPi/RasPi_Serial.html#:~:text=Sie%20rufen%20raspi%2Dconfig%20auf,zum%20Deaktivieren%20der%20seriellen%20Konsole.

Auszug:
Per Voreinstellung ist auf der Schnittstelle, die unter Linux auf /dev/ttyAMA0 angesprochen wird, eine serielle Login-Konsole konfiguriert, auf der auch der gesamte Bootvorgang protokolliert wird. Deshalb kann man diese Schnittstelle nicht so ohne Weiteres für andere Zwecke verwenden. Das bedeutet, dass Sie zuerst die serielle Konsole abschalten müssen. Maßgeblich dafür sind zwei Dateien:

relevante Begriffe :
/dev/ttyAMA0
 /boot/cmdline.txt
/etc/inittab

sudio nano /boot/cmdline.txt
Aus diesen Optionen müssen Sie nun die Angaben zur Konsole "ttyAMA0" löschen, aber alles andere unbedingt unverändert lassen. 
Am Besten machen Sie zuerst ein Backup der Datei (cp /boot/cmdline.txt /boot/cmdline.bak).
 Dann ändern Sie in der Originaldatei die Zeile:dwc_otg.lpm_enable=0 console=ttyAMA0,115200 kgdboc=ttyAMA0,115200 
 console=tty1 root=/dev/mmcblk0p2 rootfstype=ext4 elevator=deadline rootwait
in die folgende Zeile (oben sind die zu löschenden Teile farbig hervorgehoben):dwc_otg.lpm_enable=0 
 console=tty1 root=/dev/mmcblk0p2 rootfstype=ext4 elevator=deadline rootwait
Bearbeiten /etc/inittab
Nun wird die Datei /etc/inittab bearbeitet. In ihr ist die serielle Schnittstelle als Login-Schnittstelle definiert. Dazu Öffnen Sie die Datei und bearbeiten den folgenden Eintrag:
#Spawn a getty on Raspberry Pi serial line
T0:23:respawn:/sbin/getty -L ttyAMA0 115200 vt100
Ändern Sie die Zeile durch ein davor gestelltes Kommentarzeichen in 
#Spawn a getty on Raspberry Pi serial line
# T0:23:respawn:/sbin/getty -L ttyAMA0 115200 vt100

Damit der User pi auch auf die Schnittstelle zugreifen darf, muss er zusätzlich in die Gruppe "dialout" aufgenommen werden.
Das erreichet man mit dem Kommando
sudo usermod -a -G dialout pi
WICHTIG REMOTE 
https://tutorials-raspberrypi.de/raspberry-pi-remote-desktop-verbindung/
https://tutorials-raspberrypi.de/raspberry-pi-remote-desktop-verbindung/
REMOTE   132.199.100.92              .
sudo apt-get install xrdp




Installationen für UART
sudo apt-get update && sudo apt-get upgrade -y

    EXPAND File System
sudo raspi-config
    -> 7 Advanced Options
    -> A1 Expand Filesystem
https://www.simon42.com/raspberry-pi-sd-karte-klonen-unter-raspbian/#gs.eiyf3l

sudo apt-get install xrdp

Terminal
sudo apt-get install minicom
Uasge:
minicom -b 9600 -o -D /dev/ttyS0

C-Compiler IDE
sudo apt-get install codelite
https://wiki.codelite.org/

https://developer-blog.net/raspberry-pi-cplusplus-entwicklungsumgebung

C_compiler installation sicherstellen
sudo apt-get install build-essential

PROBLEM
Codelite-Debugger-Fehler:
GDB konnte nicht gefunden werden! bei '/ usr / bin / gdb'
Lösung: https://stackoverflow.com/questions/28480199/codelite-debugger-error-failed-to-locate-gdb-at-usr-bin-gdb
Wenn Sie CodeLite 7.0 verwenden, wurde ein Fehler bei der automatischen Toolerkennung festgestellt 
(der in Git Master behoben wurde).
Das Problem ist, dass der GDB-Pfad /usr/bin/gdb am Ende einen zusätzlichen Speicherplatz enthielt
Um dies zu beheben, entfernen Sie den zusätzlichen Speicherplatz und das Problem wird behoben
Bei mir stand da: 
/usr/bin/arm-linux-gnueabihf-gdb
Das habe ich einfach gelöscht.
Dann ging es !!

WORKSPACE
home/pi/Documents/CodeLiteWorkSpace

Projekt  Rechte Maus Active schalten
https://wiki.codelite.org/pmwiki.php/Main/FileSystemWorkspace


pi.codelite
home/pi/Document/CodeLiteWorkSpace.workspace
/home/pi/Documents/CodeLiteWorkSpace
WirningPi-Bibliothek
http://wiringpi.com/pins
Python  RPi:GPIO   http://pypi.python.org/pypi/RPi.GPIO
C WiringPi-Bibliothek   http://wiringpi.com/pin
Alternative
Bcm2835


File Read von USB
http://openbook.rheinwerk-verlag.de/c_von_a_bis_z/016_c_ein_ausgabe_funktionen_017.htm
http://openbook.rheinwerk-verlag.de/c_von_a_bis_z/016_c_ein_ausgabe_funktionen_017.htm#mjd6205d099779f805fd974466f81d3e86
F:\texts\DasKapital.txt
/media/pi/USB16GERMER/texts/DasKapital.txt

Generelle Netzwerk-Einstellungen (Interfaces, IP, DNS, Gate) werden in der Datei interfaces abgelegt

Diese Datei /etc/network/interfaces sollte in etwa wie folgt aussehen:

# Used by ifup(8) and ifdown(8). See the interfaces(5) manpage or
# /usr/share/doc/ifupdown/examples for more information.
auto lo
iface lo inet loopback
iface eth0 inet static
address 192.168.0.244
netmask 255.255.255.0
network 192.168.0.0
broadcast 192.168.1.255
gateway 192.168.0.1

allow-hotplug wlan0
iface wlan0 inet manual
wpa-roam /etc/wpa_supplicant/wpa_supplicant.conf
iface default inet static
address 192.168.0.245
netmask 255.255.255.0
network 192.168.0.0
broadcast 192.168.0.255
gateway 192.168.0.1


WLAN-Einstellungen bzgl Verschlüsselung, SSID usw. werden in einer CFG-Datei unter /etc abgelegt
Diese Datei /etc/wpa_supplicant.conf sollte in etwa wie folgt aussehen:

ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
update_config=1
 
network={
        ssid="YOUR_SSID"
        psk="YOUR_WLAN_KEY"
        scan_ssid=1
        id_str="home"
        key_mgmt=WPA-PSK
        proto=WPA RSN
        pairwise=CCMP TKIP
        group=CCMP TKIP
        priority=5
}





Sammlung diverser Linsk und Informationen zu erfolgreichen Modul mit ARM Prozessor

Spiegel  Artikel

Tor-Router zum Selberbauen: Internet-Tarnkappe für 65 Euro

http://www.spiegel.de/netzwelt/gadgets/raspberry-pi-tor-router-onion-pi-anonymisiert-surfen-im-web-a-907567.html

http://www.spiegel.de/netzwelt/gadgets/raspberry-pi-bauanleitung-des-anonymisierenden-tor-routers-sponionpi-a-907568.html

Raspbmc   +  Xbpmc App als Fernbedinung
Mini-Rechner Raspberry Pi: So basteln Sie einen Smart-TV für 60 Euro 

mit der kostenlosen Linux-Distribution Raspbmc und dem 40 Euro teuren Mini-Computer Raspberry Pi lassen sich alte Fernseher leicht und schnell ans Netz bringen.

http://www.chip.de/video/Raspberry-Pi-als-Media-Player-mit-RaspBMC-Workshop-Video_61732892.html

download: http://www.chip.de/downloads/Raspbmc_56704181.html

http://www.chip.de/downloads/Raspbmc_56704181.htmlhttp://www.spiegel.de/netzwelt/gadgets/raspbmc-dieser-multimediaplayer-kostet-60-euro-a-893773.html
http://www.raspbmc.com/download/

RPi Beginners

http://elinux.org/RPi_Beginners

EIN MUSS!
Diesen Text lesen und bei der ersten Installation und benutzung die Tips durchführen !!!
http://linuxundich.de/de/hardware/klein-aber-fein-der-raspberry-pi-bei-linux-und-ich/

http://www.administrator.de/wissen/netzwerk-management-server-mit-raspberry-pi-191718.html

40+ Cool Ideas for your Raspberry PI Project

http://pingbin.com/2012/12/30-cool-ideas-raspberry-pi-project/

8 unglaubliche Raspberry-Pi-Projekte  http://t3n.de/news/8-unglaubliche-434138/


https://sourceforge.net/projects/mingw-w64/files/latest/download



Programm zur UART Kommunikation  und File-Read,
für eine externe Mikrocontrolleranbindung:
In diesem Fall eines AVR Mikrocontrollersm der die empfangenen Textblöcke Morst:
PIng<CR> sendet PONG<CR> und evtl einen Wert oder Text

MAIN.c
/*
 Christof Ermer 14.09.2020
*/

/*
https://wiki.codelite.org/pmwiki.php/Main/HomePage
http://www.netzmafia.de/skripten/hardware/RasPi/timer/index.html
https://tutorials-raspberrypi.de/raspberry-pi-autostart-programm-skript/
http://www.raspberry-projects.com/pi/programming-in-c/uart-serial-port/using-the-uart

UTF-8

sudo apt-get install minicom
 inicom -b 96000 -o -D /dev/serial0
/dev/ttyS0 refers to the mini UART
/dev/serial0
*/

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>  //usleep
#include <stdint.h>   //??
#include <bits/types.h>
#include <string.h>
#include <sys/time.h>
#include <unistd.h>            //Used for UART
#include <fcntl.h>            //Used for UART
#include <termios.h>        //Used for UART

#include "Uart_Rasp_Pi3.h"
#include "FileBlkRead.h"
#include  "debug.h"
#include "Befehle.h"
#include "Service.h"
#include "main.h"

//GLOBALS
PROGFLAG_TYPE gbCtrlFlag;
//unsigned char gu8CtrlFlag = 0;
TextFile_TYPE  gstTextFile;
char gcaStr[STRMAX+1];
char gcaNumStr[NUMSTRMAX+1];
unsigned long gulMS_Ticks = 0;
struct timeval sTime1;
//struct timespec sTimeSpec1, SClockResolution;

// **********************************************
int main(int argc, char **argv)
// **********************************************
{
unsigned long ulLoops=0;
static unsigned long ulTickComp = 0;  
static unsigned long ulRxTickComp = 0;  

InitUart();

printf("\r\nHello World\r\n");
printf("\r\nSend to Terminal COMx\r\n");
printf("\r\nKommandos im Terminal mit <CR> absenden\r\n");

uart_tx_string("\r\n");
uart_tx_string("JuniKaefer an Wallkuere\r\n");
uart_tx_string("Der Pirol pfeift heute Nacht\r\n");

Reset_TxtFileStruct( &gstTextFile );   //open EOF etc            
gbCtrlFlag.While_Run_Flag = 1;
sleep(1); // second

while( gbCtrlFlag.While_Run_Flag )   // HauptMainLoop
    {
    ulLoops++;
    gettimeofday(&sTime1, NULL);
    if( (sTime1.tv_usec - ulTickComp) > 1000UL)
        {
        ulTickComp = (unsigned long)sTime1.tv_usec; //suseconds_t=long int
        gulMS_Ticks++;
        if( !(gulMS_Ticks % 1000) )
            {
            gbCtrlFlag.TICK_1S_Flag = 1;
            };
        };
  /// ----------------------------------------------     
    if( gbCtrlFlag.TICK_1S_Flag )
        {
        gbCtrlFlag.TICK_1S_Flag = 0;
        // Versuche Textfile zu Öffnen
        if( (gstTextFile.u8FileFlags & TXT_FILE_OPEN) == 0)  // File NICHT offen !!
            {
            strcpy( gstTextFile.caFilePlaceName, STR_USB_TEXT_FILE_POS );
            printf("Try to Open textfile: %s\r\n", gstTextFile.caFilePlaceName);
            Reset_TxtFileStruct( &gstTextFile );               
            OPEN_Textfile( &gstTextFile, gstTextFile.caFilePlaceName);
            sleep(2); // second
            };
       
        if( gbCtrlFlag.ShowInfo_Flag  || gbCtrlFlag.LockInfo_Flag ) //Info Lock Iwr dmit Wert 0 gelöscht
            {
            gbCtrlFlag.ShowInfo_Flag = 0; //einmalig ausführen
//Debugs
            //sprintf(gcaStr, "\r\nPars:%d \tLength:%d\r\n", gstRX.u8Parser,gstRX.tRxLength);
            //printf( gcaStr );           
            sprintf(gcaStr, "T:%lu \tMCU:%lu \r\n", (unsigned long)(gulMS_Ticks / 1000UL), ulLoops);
            uart_tx_string( gcaStr );       
            printf("\r\nLoops:%lu  %s",ulLoops, gcaStr);
            };
       
        ulLoops=0;
        };
    if( (gulMS_Ticks - ulRxTickComp) > UART_RX_WIEDERHOL_MS )
        {
        ulRxTickComp =  gulMS_Ticks;
//uart_PutC('*');
        if( CheckUart_RX_Pol() == ASCII_CR )
            {
//printf("\r\n *Polling==13 Cmd:%s\t Val1:%d", gstRX.caCmd, gstRX.iVal1);
            Befehle(); 
            ResetCmdVars();  //wichtig im Kontext nach Befehle
//printf("\r\n Befehl fertig");
            };
//Text fertig, was tun ?
        if( gstTextFile.u8FileFlags & TXT_READY_READED )
            {
            gstTextFile.u8FileFlags &= ~TXT_READY_READED;
            gbCtrlFlag.While_Run_Flag = 0;
            };
       };
    }; // while

CLOSE_Textfile( &gstTextFile );  
CloseUart();
printf("\r\n*** Programn Ende ***");
return 0;
}
main.h

#ifndef _MAIN_HEADER_
    #define _MAIN_HEADER_

/*
 * Christof Ermer 03.09.2020
 */
 
#include "Uart_Rasp_Pi3.h"
#include  "FileBlkRead.h"
#include  "Befehle.h"
#include  "debug.h"

#define STR_USB_TEXT_FILE_POS  "/media/pi/USB16GERMER/texts/DasKapital.txt"

#define CR  13  // \r
#define LF  10  // \n
#define CRLF_STR {10,13,0}
#define STRMAX 253
#define NUMSTRMAX 50

#define UART_RX_WIEDERHOL_MS 10
//FLAGS
typedef struct
{
unsigned char While_Run_Flag    : 1;
unsigned char TICK_1S_Flag      : 1;
unsigned char Bell_CMD_Flag        : 1;
unsigned char ShowInfo_Flag     : 1;
unsigned char LockInfo_Flag     : 1;
}PROGFLAG_TYPE;


//Globals
//EXTERNS
extern char gcaStr[STRMAX+1];
extern char gcaNumStr[NUMSTRMAX+1];
extern PROGFLAG_TYPE gbCtrlFlag;
extern unsigned long  gulMS_Ticks;
extern TextFile_TYPE gstTextFile;

#endif


/*
 Christof Ermer 14.09.2020
 Uart_Rasp_PI3.c
*/

/*

CheckUart_RX_Pol(); Return 13 löst Befehle aus
    if( CheckUart_RX_Pol() == ASCII_CR )
        { //printf("\r\n *Polling==13 Cmd:%s\t Val1:%d", gstRX.caCmd, gstRX.lVal1);        
        Befehle(); 
        ResetCmdVars();  //wichtig im Kontext nach Befehle
        };
*/

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <bits/types.h>
#include <string.h>
#include <unistd.h>            //Used for UART
#include <fcntl.h>            //Used for UART
#include <termios.h>        //Used for UART

#include "Uart_Rasp_Pi3.h"
#include "main.h"

UART_RX_TYPE gstRX;
int uart0_filestream = -1;
// Prototype

// **********************************************
void ResetUartRxVars(void)
// **********************************************
{
*gstRX.au8RxStr = 0;
*(gstRX.au8RxStr + RX_BUF_SIZE) = 0;
*gstRX.caRxUartBuf = 0;
*(gstRX.caRxUartBuf+1) = 0; //Teerm
//gstRX.u8RxByte = 0;
gstRX.tRxLength = 0;
gstRX.u8Parser = 0;
};


// *************************
void ResetCmdVars(void)
// *************************
{
*gstRX.caCmd = 0;
*(gstRX.caCmd + COMMANDSIZEMAX) = 0;
gstRX.lVal1 = 0;
*gstRX.caValStr1 = 0;
*(gstRX.caValStr1 + VALUE_STRMAX) = 0;
};

// **********************************************
void InitUart(void)
// **********************************************
{
//-------------------------
    //----- SETUP USART 0 -----
    //-------------------------
    //At bootup, pins 8 and 10 are already set to UART0_TXD, UART0_RXD (ie the alt0 function) respectively
   
    //OPEN THE UART
    //The flags (defined in fcntl.h):
    //    Access modes (use 1 of these):
    //        O_RDONLY - Open for reading only.
    //        O_RDWR - Open for reading and writing.
    //        O_WRONLY - Open for writing only.
    //
    //    O_NDELAY / O_NONBLOCK (same function) - Enables nonblocking mode. When set read requests on the file can return immediately with a failure status
    //                                            if there is no input immediately available (instead of blocking). Likewise, write requests can also return
    //                                            immediately with a failure status if the output can't be written immediately.
    //
    //    O_NOCTTY - When set and path identifies a terminal device, open() shall not cause the terminal device to become the controlling terminal for the process.
    close(uart0_filestream);
    uart0_filestream = open( DEV_UART_USED, O_RDWR | O_NOCTTY | O_NDELAY);        //Open in non blocking read/write mode
    //printf("\r\nUartFileStream=%d", uart0_filestream );
  
if (uart0_filestream == -1)
    {
        //ERROR - CAN'T OPEN SERIAL PORT
        printf("\r\nError - Unable to open UART.  Ensure it is not in use by another application");
    }
   
    //CONFIGURE THE UART
    //The flags (defined in /usr/include/termios.h - see http://pubs.opengroup.org/onlinepubs/007908799/xsh/termios.h.html):
    //    Baud rate:- B1200, B2400, B4800, B9600, B19200, B38400, B57600, B115200, B230400, B460800, B500000, B576000, B921600, B1000000, B1152000, B1500000, B2000000, B2500000, B3000000, B3500000, B4000000
    //    CSIZE:- CS5, CS6, CS7, CS8
    //    CLOCAL - Ignore modem status lines
    //    CREAD - Enable receiver
    //    IGNPAR = Ignore characters with parity errors
    //    ICRNL - Map CR to NL on input (Use for ASCII comms where you want to auto correct end of line characters - don't use for bianry comms!)
    //    PARENB - Parity enable
    //    PARODD - Odd parity (else even)
    struct termios options;
    tcgetattr(uart0_filestream, &options);
    options.c_cflag = B9600 | CS8 | CLOCAL | CREAD;        //<Set baud rate
    options.c_iflag = IGNPAR;
    options.c_oflag = 0;
    options.c_lflag = 0;
    tcflush(uart0_filestream, TCIFLUSH);
    tcsetattr(uart0_filestream, TCSANOW, &options);
   
    ResetUartRxVars();
    ResetCmdVars();
};

// **********************************************
void CloseUart(void)
// **********************************************
{
// ----- CLOSE THE UART -----
close(uart0_filestream);
};

// **********************************************
int RxUartStream(void)
// **********************************************
{
//----- CHECK FOR ANY RX BYTES -----
if (uart0_filestream != -1)
    {
    // Read up to 255 characters from the port if they are there
    *gstRX.caRxUartBuf = 0;  //Nix
    //Lese "EIN" Zeichen
    gstRX.tRxLength = read(uart0_filestream, (void*)gstRX.caRxUartBuf, 1);        //Filestream, buffer to store in, number of bytes to read (max)
    gstRX.caRxUartBuf[1]=0;
    if (gstRX.tRxLength < 0)
        {
        //An error occured (will occur if there are no bytes)
        *gstRX.caRxUartBuf = 0;  //Nix
        return -1;
        }
    else if (gstRX.tRxLength == 0)
        {
        //No data waiting
        *gstRX.caRxUartBuf = 0;  //Nix
        return -1;
        }
    else
        {
//1 Byte received
//printf("\r\n%i bytes read : %s", gstRX.tRxLength, gstRX.caRxUartBuf);
        return (int)*gstRX.caRxUartBuf ;  //alles OK und nur 0.tes Byte zurückgeben.
        };
    };
//else
//und hier ging dann was schief.
*gstRX.caRxUartBuf = 0;  //Nix
return -1;
};


// **********************************************
int CheckUart_RX_Pol(void) // Polling in while(1)
// **********************************************
{
int iRxByte;
iRxByte = RxUartStream();  // NUR EIN BYTE
if( iRxByte != -1 )
    { 
    iRxByte &= 0x7F;  //<128
    if( iRxByte == CMDSIG_CR )  // 13
        {
        //printf("\r\n ** Befehl gefunden**:%s ln:%d", gstRX.au8RxStr, gstRX.tRxLength);
        TokenRXStr( (char*)gstRX.au8RxStr );
        //printf("\r\n ** Befehl %s\t Value=%d", gstRX.caCmd,gstRX.lVal1);       
/*
printf("\r\nRx:%d\t %c /tPars:%d /tStr%s\r\n",iRxByte,iRxByte, gstRX.u8Parser,gstRX.au8RxStr);
printf("\r\nCMD%s  Val:%d". gstRX.caCmd , gstRX.lVal1);
sprintf(gcaStr, "\r\nPars:%d \tLength:%d \tRxByte:%d rxStr%s\r\n", gstRX.u8Parser,gstRX.tRxLength, gstRX.u8RxByte, gstRX.au8RxStr);
printf( gcaStr );
*/     ResetUartRxVars();
        return CMDSIG_CR;       
        }
    else
        {
        //Suche unnütze Sonderzeichen
        if( (iRxByte < ASCII_NUMBERSTART) &&   \
            (iRxByte != ASCII_KOMMA) && \
            (iRxByte != ASCII_MINUS) ) {return -1; }; //weil "befehl,-123"
        if( (iRxByte > ASCII_BIG_Z_END) && (iRxByte < ASCII_SMALL_A_START) ) {return -1;};
//printf("\r\nRx:%d\t %c\r\n",iRxByte,iRxByte);       
        if( iRxByte > ASCII_SMALL_Z_END) {return -1;};
//printf("\r\nRx:%d\t %c /tPars:%d /tStr%s\r\n",iRxByte,iRxByte, gstRX.u8Parser,gstRX.au8RxStr);       
        if(gstRX.u8Parser > RX_BUF_SIZE)
            {
            ResetUartRxVars();
            return -1;
            };
        *( gstRX.au8RxStr + gstRX.u8Parser++) = (uint8_t)iRxByte;
        *( gstRX.au8RxStr + gstRX.u8Parser) = 0;
//printf("\r\nAkt RxStr:%s\r\n", gstRX.au8RxStr);
        return 1;
        };
    }
return -1;  // Bis hier war dan nix.
};

   
/* Diese Funktion zerlegt den Befehls-String in einzelne Module */
// *******************************************************************
void TokenRXStr(char *pcStrOrder)
// *******************************************************************
{ //INPUT ERWARTET "BEFEHL,WERT" BSP: "SFR,1000"
const char caDelimiter[]= ",";
char * pStrTok; // für strtok_r
if( (pStrTok = strtok( pcStrOrder, caDelimiter)) != NULL) // Trenne 1.Token in Command
    {   
    strcpy( gstRX.caCmd, pStrTok);
    }
else
    {
    *gstRX.caCmd = 0;
    };
gstRX.caCmd[ COMMANDSIZEMAX ] = 0; //Sicherheitsterminierung COMAMNDSIZEMAX=10
//für 1 fVal Variablen nach dem Kommando
gstRX.lVal1 = 0;
//gstRX.caCmd.i16CmdVal_2 = 0;
//HIER NULL POINTER
if( (pStrTok = strtok( NULL, caDelimiter)) != NULL) // Trenne 1.Token in Command
    {
    //gstRX.caCmd.fCmdVal_1 = atof(pStrTok);// Und dann TO Float   
    gstRX.lVal1 = atol(pStrTok);
    };

if( (pStrTok = strtok( NULL, caDelimiter)) != NULL) // Trenne 1.Token in Command
    {
    strcpy( gstRX.caValStr1, pStrTok );
    *(gstRX.caValStr1 +VALUE_STRMAX) = 0;
    }
else
    {
    *gstRX.caValStr1 = 0;
    *(gstRX.caValStr1 + VALUE_STRMAX) = 0;
    };
};


//************************************
//********** UART TX STRING **********
//************************************
// **********************************************
void uart_tx_string (char* tx_string)
// **********************************************
{
size_t u16StrLen = strlen(tx_string);
if (uart0_filestream != -1)
    {
//    write(uart0_filestream, (char*)tx_string.c_str(), tx_string.length());        //Filestream, bytes to write, number of bytes to write
    write(uart0_filestream, tx_string, u16StrLen);        //Filestream, bytes to write, number of bytes to write
    };
};

// **********************************************
void uart_PutC(unsigned char ucC)
// **********************************************
{
char caToTx[2];
*caToTx = ucC;
*(caToTx+1) = 0; 
if (uart0_filestream != -1)
    {
//    write(uart0_filestream, (char*)tx_string.c_str(), tx_string.length());        //Filestream, bytes to write, number of bytes to write
    write(uart0_filestream, caToTx, 1);        //Filestream, bytes to write, number of bytes to write
    };
};

Uart_Rasp_Pi3.h

#ifndef UART_RASP_HEADRER
    #define UART_RASP_HEADRER

/*
 * Christof Ermer 14.09.2020
 Uart_Rasp_Pi3.h
 https://de.wikipedia.org/wiki/Steuerzeichen
  * */

#define DEV_UART_USED       DEV_UART_MINIUART_P3
#define DEV_UART_MINIUART_P3    "/dev/ttyS0"
#define DEV_STANDARD    "/dev/serial0"

#define RX_BUF_SIZE     250 // Default
#define COMMANDSIZEMAX  31

#define ASCII_BEL   7  //BEL
#define ASCII_LF    10 //LF
#define ASCII_CR    13 //CR
#define ASCII_SPACE 32
#define ASCII_KOMMA 44
#define ASCII_MINUS 45
#define ASCII_NUMBERSTART   48
#define ASCII_BIG_A_START   65
#define ASCII_BIG_Z_END     92
#define ASCII_SMALL_A_START 97
#define ASCII_SMALL_Z_END   122
#define CMDSIG_BEL  ASCII_BEL //BEL  Anstelle von 13, was ja ein zu sendendens Zeichen sein kann.
#define CMDSIG_CR   ASCII_CR

#define VALUE_STRMAX    80
//Globals
typedef struct
    {
    char caRxUartBuf[2]; // 2 BYTE
    uint8_t au8RxStr[RX_BUF_SIZE + 1]; //Sample
    //uint8_t u8RxByte;    //single
    uint8_t u8Parser;
    int tRxLength;
    char caCmd[COMMANDSIZEMAX+1]; //Kommando
    long lVal1;
    char caValStr1[ VALUE_STRMAX +1 ];
    }UART_RX_TYPE;

extern UART_RX_TYPE gstRX;

//Fuctions   
extern void InitUart(void);
extern void ResetUartRxVars(void);
extern void ResetCmdVars(void);
extern void CloseUart(void);
extern int RxUartStream(void);
extern void TokenRXStr(char *pcStrOrder);   
extern int CheckUart_RX_Pol(void); // Polling in while(1)
extern void uart_tx_string (char* tx_string);
extern void uart_PutC(unsigned char ucC);

#endif
FileBlkRead.c


/*
Christof Ermer
FileBlkRead.c
Datum 14.09.2020

https://stackoverflow.com/questions/3463426/in-c-how-should-i-read-a-text-file-and-print-all-strings
http://openbook.rheinwerk-verlag.de/c_von_a_bis_z/016_c_ein_ausgabe_funktionen_014.htm#mjff798e62f1469fc3901b349f005d6547
*/


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//#include <stddef.h>  // size_t
#include <stdint.h>   //??
#include  "FileBlkRead.h"
#include  "main.h"

//***********************
void Reset_TxtFileStruct(TextFile_TYPE * pstTFile)
//***********************
{
// NICHT LÖSCHEN  char caFilePlaceName[ FILE_NAME_SIZE ];  // SOLL DATEINAME
*pstTFile->caRxBuf = 0;
*(pstTFile->caRxBuf + FTREAD_BUF_SIZE) = 0;
pstTFile->TxtFileHndl = NULL;
pstTFile->lSeekPos = 0;
pstTFile->lCurrentSeekPos = 0;
pstTFile->u8FileFlags = 0; // TXT_FILE_OPEN TXT_EOF_DETECT  TXT_READY_READED  etc.
pstTFile->tBlkSize = FTREAD_BUF_SIZE;
};


//***********************
int OPEN_Textfile(TextFile_TYPE * pstTFile, char* pcFilePosName)
//***********************
{
// FILE*
strcpy( pstTFile->caFilePlaceName, pcFilePosName );
pstTFile->TxtFileHndl = fopen( pcFilePosName, "r"); //"test.txt"  "r+b"
if(pstTFile->TxtFileHndl != NULL)
    {
    fseek(pstTFile->TxtFileHndl, 0L, SEEK_END); //Ende // Seek the last byte of the file
    // Offset from the first to the last byte, or in other words, filesize
    pstTFile->ulFileSize = ftell(pstTFile->TxtFileHndl);
    rewind(pstTFile->TxtFileHndl);// go back to the start of the file
    //fseek(pstTFile->TxtFileHndl, 0L, SEEk_SET ; //anfang
   
    pstTFile->u8FileFlags = TXT_FILE_OPEN;  //1
    pstTFile->lSeekPos = 0L;
    pstTFile->lCurrentSeekPos = 0L;
    return 1; //OK
    }
else
    {
    sprintf(gcaStr, "\r\n File %s Uart not Open \r\n", pcFilePosName);
    uart_tx_string( gcaStr );  //Switch To BELL CMD = 7 \a
    printf( gcaStr );
    //Sonst geht es einfach weiter, weil File schon offen  SEEK_CUR   
    };
return -1;
};

//fseek(), rewind() und fsetpos()
// SEEK_SET SEEK_CUR SEEK_END
//***********************
long int Seek_TextFile(TextFile_TYPE * pstTFile, long int lSeekPos)
//***********************
{
if ( pstTFile->TxtFileHndl != NULL)
    {   //int fseek (FILE *__stream, long int __off, int __whence);
    pstTFile->lCurrentSeekPos = fseek( pstTFile->TxtFileHndl, lSeekPos, SEEK_CUR);
    return pstTFile->lCurrentSeekPos;   
    };
return -1;
};


//***********************
void  CLOSE_Textfile(TextFile_TYPE * pstTFile )
//***********************
{
if(pstTFile->TxtFileHndl != NULL)
  {
   fclose(pstTFile->TxtFileHndl); 
   pstTFile->TxtFileHndl = NULL;
  };
};


//***********************
char * Read_TextBlock( TextFile_TYPE * pstTFile, size_t tBlkSize )
//***********************
{
size_t tReadedSize = 0;
*pstTFile->caRxBuf = 0;
pstTFile->tBlkSize = tBlkSize;

if(pstTFile->TxtFileHndl != NULL)
  {
  tReadedSize = fread(pstTFile->caRxBuf, sizeof(char), tBlkSize, pstTFile->TxtFileHndl);
  if( tReadedSize <= FTREAD_BUF_SIZE )
    {
    *( pstTFile->caRxBuf + tReadedSize) = 0;  //terminierung
    };
  *( pstTFile->caRxBuf + FTREAD_BUF_SIZE) = 0;
  };
 
if( tReadedSize < tBlkSize )
    {
    pstTFile->u8FileFlags |= TXT_EOF_DETECT | TXT_READY_READED;  // *** FLAG SETZEN ***;
    //printf( "\r\n ** Text readed < Block **: \tIST:%d\tSoll:%d", tReadedSize, tBlkSize);
    pstTFile->lCurrentSeekPos = fseek( pstTFile->TxtFileHndl, 0L, SEEK_SET);    //Stelle auf Anfang
    }
else
    {
    pstTFile->u8FileFlags &= ~TXT_EOF_DETECT;  // *** FLAG CLEAR ***;
    }
return pstTFile->caRxBuf;
};

//fseek( gstTextFile.TxtFileHndl, gstTextFile.lSeekPos, SEEK_CUR);

FileBlkRead.h

/*
Christof Ermer
FileBlkRead.h
Datum 14.09.2020
*/

#ifndef  _FILE_BLK_READ_H_
#define _FILE_BLK_READ_H_

#include <stdio.h>
#include <stdlib.h>
#define FTREAD_BUF_SIZE 250
#define TXT_FILE_OPEN   0x01
#define TXT_EOF_DETECT  0x02
#define TXT_READY_READED  0x04

#define FILE_NAME_SIZE    80
typedef struct
{
char caFilePlaceName[ FILE_NAME_SIZE ];  // SOLL DATEINAME
char caRxBuf[ FTREAD_BUF_SIZE + 1];
size_t tBlkSize;
FILE *TxtFileHndl;
long int lSeekPos;
long int lCurrentSeekPos;
unsigned long ulFileSize;
unsigned char u8FileFlags;  //TXT_FILE_OPEN
}TextFile_TYPE;

//Globals

//Fuctions
extern void Reset_TxtFileStruct(TextFile_TYPE * pstTFile);
extern int OPEN_Textfile(TextFile_TYPE * pstTFile, char* pcFilePosName);
extern long int Seek_TextFile(TextFile_TYPE * pstTFile, long int lSeekPos);
extern void  CLOSE_Textfile(TextFile_TYPE * pstTFile );
extern char * Read_TextBlock( TextFile_TYPE * pstTFile, size_t tBlkSize );

#endif

 Befehle.c
/*
 * Christof Ermer 14.09.2020
 Befehle.c
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>  //usleep
#include <stdint.h>   //??
#include <bits/types.h>
#include <string.h>
#include "Uart_Rasp_Pi3.h"
#include "FileBlkRead.h"
#include "Service.h"
#include "debug.h"
#include "main.h"

// https://de.wikipedia.org/wiki/Steuerzeichen
// #define CMDSIG  0x07 //BEL  Anstelle von 13, was ja ein zu sendendens Zeichen sein kann.
// uart_PutC(CMDSIG); // 7 = BELL
       
// **********************************************
void Befehle(void)
// **********************************************
{
    // gstRX.lVal1
if( !(strcasecmp( gstRX.caCmd, "RNT" ) ) ) //RD NEXT TEXT"
        {           
        if( !(gbCtrlFlag.Bell_CMD_Flag) )
            {
            uart_tx_string( "STB\r" );
            usleep( 500 );           
            };//Switch To BELL CMD = 7
        gstTextFile.tBlkSize = RX_BUF_SIZE;
        Read_TextBlock( &gstTextFile, gstTextFile.tBlkSize );
//printf("\r\nText:/t%s **",  gstTextFile.caRxBuf);
        uart_tx_string( gstTextFile.caRxBuf );
        uart_PutC(ASCII_BEL);
        return;
        };

if( !(strcasecmp( gstRX.caCmd, "RNS" ) ) ) //RD NEXT TEXT mit SIZE"
        {
        if( !(gbCtrlFlag.Bell_CMD_Flag) )
            {
            uart_tx_string( "STB\r" );
            usleep( 500 );           
            };//Switch To BELL CMD = 7
        if(gstRX.lVal1 == 0)
            {
            gstTextFile.tBlkSize = RX_BUF_SIZE;
            }
        else
            {
            gstTextFile.tBlkSize = gstRX.lVal1;
            };
        Read_TextBlock( &gstTextFile, gstTextFile.tBlkSize );
//printf("\r\nText:/t%s **", gstTextFile.caRxBuf);
        uart_tx_string( gstTextFile.caRxBuf );
        //uart_PutC(13);       
        uart_PutC(ASCII_BEL);       
        return;
        };


if( !(strcasecmp( gstRX.caCmd, "SBPOS" ) ) )
        {           
        gstTextFile.lSeekPos = gstRX.lVal1;
        fseek( gstTextFile.TxtFileHndl, gstTextFile.lSeekPos, SEEK_CUR);
        return;
        };

if( !(strcasecmp( gstRX.caCmd, "SFN" ) ) )
        {
        if( *gstRX.caValStr1 )           
            {
            strcpy( gstTextFile.caFilePlaceName, gstRX.caValStr1 );
            printf( gstTextFile.caFilePlaceName );
            return;
            };
        };


if( !(strcasecmp( gstRX.caCmd, "STB" ) ) )  //Switch To BELL CMD = 7 \a
        {
        gbCtrlFlag.Bell_CMD_Flag = 1;;       
//printf("\r\nBell CMD\r\n");
        uart_tx_string( "STB\r\a" );  //Switch To BELL CMD = 7
        return;
        };

if( !(strcasecmp( gstRX.caCmd, "STCR" ) ) )  //Switch To CR = 13
        {
        gbCtrlFlag.Bell_CMD_Flag = 0;;       
//printf("\r\nCR CMD\r\n");
        uart_tx_string( "STCR\a\r" );  //Switch To BELL CMD = 7 \a
        return;
        };
                   

if( !(strcasecmp( gstRX.caCmd, "SBS" ) ) ) //Set Block Size
        {
        if(gstRX.lVal1 > RX_BUF_SIZE) {gstRX.lVal1 = RX_BUF_SIZE;};
        gstTextFile.tBlkSize =  (size_t)gstRX.lVal1;
        printf("\r\nTNew ReadBlock Size:%d **", gstTextFile.tBlkSize);
        return;
        };

if( !(strcasecmp( gstRX.caCmd, "GBS" ) ) ) //Get Block Size
        {
        printf("\r\nCurrent_ReadBlockSize:%d", gstTextFile.tBlkSize);
        sprintf(gcaNumStr, "%d\r", gstTextFile.tBlkSize);
        uart_tx_string(gcaNumStr);
        uart_PutC(13);
        return;
        };       

if( !(strcasecmp( gstRX.caCmd, "PING" ) ) )
        {
        printf("\r\n ** PONG **");
        uart_tx_string( "PONG\r" );
        return;
        };
       
if( !(strcasecmp( gstRX.caCmd, "STOP" ) ) )
        {
        gbCtrlFlag.While_Run_Flag = 0;
        uart_tx_string( "STOP\r" );
        printf("\r\n ** STOP **");
        };

if( !(strcasecmp( gstRX.caCmd, "VV" ) ) )
        {
        printf("\r\nValue:\t%lu", gstRX.lVal1);
        sprintf(gcaStr,"%lu\r\n", gstRX.lVal1);
        uart_tx_string( gcaStr );
        //uart_PutC(13);       
        return;
        };
      
if( !(strcasecmp( gstRX.caCmd, "GFS" ) ) )
        {
        sprintf(gcaStr,"\r\nFileStat: Open:%d \tSeek:%lu \tCurSeek:%lu \tBlockSize:%u \tFlags:%x \tFileSize:%lu\r\n", \
            // (gstTextFile.u8FileFlags & TXT_FILE_OPEN),
            gstTextFile.u8FileFlags, \
            gstTextFile.lSeekPos,   \
            gstTextFile.lCurrentSeekPos, \
            gstTextFile.tBlkSize, \
            gstTextFile.u8FileFlags, \
            gstTextFile.ulFileSize \
            );          
        uart_tx_string( gcaStr );
        //uart_PutC(13);       
        return;
        };

if( !(strcasecmp( gstRX.caCmd, "TT" ) ) ) //TEST
        {
        sprintf(gcaStr,"%lu\r\n", gulMS_Ticks);
        uart_tx_string( gcaStr );          
        //sprintf(gcaStr, "\r\nPars:%d \tLength:%d\r\n", gstRX.u8Parser,gstRX.tRxLength);
        printf( gcaStr );
        return;
        };

if( !(strcasecmp( gstRX.caCmd, "II" ) ) ) //Info
        {
        gbCtrlFlag.ShowInfo_Flag = 1;
        return;
        };

if( !(strcasecmp( gstRX.caCmd, "LI" ) ) ) //LOCK Info, STaendiges ausführen
        {
        gbCtrlFlag.LockInfo_Flag = gstRX.lVal1;
        return;
        };
       
if( !(strcasecmp( gstRX.caCmd, "XX" ) ) )
        {
        gbCtrlFlag.While_Run_Flag = 0;
        printf("\r\n ** stop gefunden **");
        return;
        };

ResetCmdVars();       
};
Befehle.h

ifndef  _BEFEHLE_H_
#define _BEFEHLE_H_

#include <stdio.h>
#include <stdlib.h>
#include  "main.h"
extern void Befehle(void);
#endif


/*
debug.c
Christof Ermer
Verison 14.03.2020
*/
#include <stdint.h>
#include <stdlib.h>
#include "debug.h"

#ifdef BYTE_TO_BIN_USED
// *******************************************************************
char * ByteToBin(uint8_t u8Byte)
// *******************************************************************
{
static char caHex[9]; //groesse 8+1
char * pcParser = caHex;
int8_t i8NN=7;
do
    {
    if( u8Byte & (1 << i8NN) )
        {
        *pcParser = '1';
        }
    else
        {
        *pcParser = '0';
        };
    pcParser++;
    }while(i8NN--);
caHex[8]=0; //Terminierung
return caHex;
};
#endif


//WORD Anzeige in Binaerer Form
#ifdef WORD_TO_BIN_USED
// *******************************************************************
char * WordToBin(uint16_t u16Word)
// *******************************************************************
{
static char ucaBin[18]; // Array  zeigt Lücke 00000000 00000000
char * pcParser = ucaBin;
uint8_t u8NN=15;
do
    {
/*   
    if(u8NN == 7)
        {*pcParser =' '; pcParser++;}; // Füge Lücke ein im BYTE
*/
    if(u16Word & (1<<u8NN) )
        {
        *pcParser = '1';
        }
    else
        {
        *pcParser = '0';
        };
    pcParser++;
    }while(u8NN--);
ucaBin[17]=0;
return  ucaBin;
};
#endif


#ifdef FILL_TO_HEX_USED
static char caHex[5]; //groesse 8+1
// **************************
//Hilfsfuktion;
void FillHex(uint8_t u8Pos, uint8_t u8Mem)
// **************************
{
if(u8Mem > 9 )
    {
    switch(u8Mem)
        {
        case 10:
            {
            caHex[u8Pos]='A';
            break;
            };
        case 11:
            {
            caHex[u8Pos]='B';
            break;
            };
        case 12:
            {
            caHex[u8Pos]='C';
            break;
            };
        case 13:
            {
            caHex[u8Pos]='D';
            break;
            };
        case 14:
            {
            caHex[u8Pos]='E';
            break;
            };
        case 15:
            {
            caHex[u8Pos]='F';
            break;
            };
        };
    }
else
    {
    caHex[u8Pos]=u8Mem+48; //ASCII ZAHL 0
    };
}

// ******************************
char * ByteToHex(uint8_t u8Byte)
// ******************************
{
caHex[0]='0';
caHex[1]='x';
FillHex(2,(u8Byte & 0xF0) >> 4);
FillHex(3,u8Byte & 0x0F);
caHex[4]=0;
return caHex;
};
#endif

/*
debug.h
Christof Ermer
Verison 14.03.2020
*/

#ifndef DEBUG_TOOLS_HEADER
    #define DEBUG_TOOLS_HEADER
/*
Beispiel:
uart_puts( ByteToBin( gu8DS1337_Status )); uart_putc(13);       
Toggle_Bit(2);
*/

// ***  Schalte ein was du brauchst  ***
// #define TOGGLE_STATIC_BIT_USED
#define BYTE_TO_BIN_USED
#define WORD_TO_BIN_USED
#define BYTE_TO_HEX_USED
//#define FILL_TO_HEX_USED

#ifdef BYTE_TO_BIN_USED
extern char * ByteToBin(uint8_t u8Byte);
#endif

#ifdef WORD_TO_BIN_USED
extern char* WordToBin(uint16_t u16Word);
#endif


#ifdef BYTE_TO_HEX_USED
extern char * ByteToHex(uint8_t u8Byte);
#endif

#ifdef FILL_TO_HEX_USED
void FillHex(uint8_t u8Pos, uint8_t u8Mem)
#endif

#endif //DEBUG_TOOLS_HEADER