I2C-, USART-, EEPROM-Test für ein Feedback

[Marie L. (lendl)]

Hallo Kolleg:innen,

ich habe mit ein wenig Halbwissen, einigen Tutorials, Google-Suche und 
meiner Bascom-Programmier-Erfahrung schon mal ein paar Grundbausteine 
für mein nächstes (und erstes) C-Projekt zusammengebastelt.
Das Projekt soll Sensordaten via I2C einlesen, diese Daten manipulieren, 
über serielle Verbindungen zum PC und einem Nextion-Display ausgeben, 
Befehle und Werte über diese seriellen Verbindungen empfangen und auch 
einige Parameter im EEPROM abspeichern, usw...

Mit Bascom habe ähnliche Projekte schon realisiert, aber C ist eine neue 
Welt für mich. Zugegeben - da ist noch viel Unverständnis dabei, aber 
meine Neugier war einfach zu groß und mein C-Kurs ist noch lange nicht 
soweit und man lernt doch eh am besten bei der Arbeit am Projekt...

Langer Rede kurzer Sinn, das Wetter ist schlecht und vielleicht hat ja 
jemand Lust sich diesen ersten Code mal anzuschauen und mir ein Feedback 
zu geben, was gut ist und was ich anders/besser machen könnte.

Tausend Dank vorab!

/*
 * Test für I2C, USART, EEPROM
 */ 

#define F_CPU 2E6
#include <avr/io.h>
#include <util/delay.h>
#include <stdio.h>
#include <avr/eeprom.h>
#include <avr/interrupt.h>

/*wird bei Code::Blocks benötigt, bei Geany nicht
 * erzeugt dort einen [-Wimplicit-function-declaration] Fehler
void init_twi(void);
void init_serial_1(void);
void init_serial_2(void);
void sendChar_1(char c);
void sendChar_2(char c);
void sendString_1(char *text);
void sendString_2(char *text);
*/

/* Byte */
uint8_t eeFooByte EEMEM = 13;
/* Wort */
uint16_t eeFooWord EEMEM = 12345;
/* float */
float eeFooFloat EEMEM;


int main(void)
{
  // Initialisierungen
  init_serial_1();
  init_serial_2();
  init_twi();
  
  // Interrupt für Data-In
  PMIC.CTRL = PMIC_LOLVLEN_bm;
  sei();
  volatile char data_in;

  // Testdaten ins EEPROM schreiben
  eeprom_write_byte (&eeFooByte, 123);
  eeprom_write_float (&eeFooFloat, 1.23456);
  
    
    while (1) 
    {      
    _delay_ms(1000);
    
    // Variablendeklaration für die I2C Kommunikation
    uint8_t DataLow;
    uint8_t DataHigh;
    uint16_t DataResult;
    char str[32];
    
    /* I2C-Schreiben (Adresse 1111000) wird noch nicht benötigt,
     * Funktion muss noch beim DAC geprüft werden
    TWIE.MASTER.ADDR = 0x78 << 0x01;
    */
    
    //  I2C-Lesen (Adresse 1111000)    
    TWIE.MASTER.ADDR = (0x78 << 0x01) | 0x01; 
    
    // Alle Datenbytes bis auf das letzte empfangen
    while(!(TWIE.MASTER.STATUS & TWI_MASTER_RIF_bm));
    DataLow = TWIE.MASTER.DATA;
    TWIE.MASTER.CTRLC = TWI_MASTER_CMD_RECVTRANS_gc;
        
    // Empfangen des letzten Datenbytes
    while(!(TWIE.MASTER.STATUS & TWI_MASTER_RIF_bm));
    DataHigh = TWIE.MASTER.DATA;
    
    // Senden der Stop-Kondition
    TWIE.MASTER.CTRLC = TWI_MASTER_ACKACT_bm | TWI_MASTER_CMD_STOP_gc;    
    
    // Zusammenbauen der I2C Daten zum Messwert und Ausgabe am Terminal
    DataResult = DataLow * 256 + DataHigh;
    sprintf(str, "____Messwert: %d", DataResult);
    sendString_1(str);  

    // Ausgabe des Messwerts am Nextion Display
    sendString_2("t1.txt=\"");
    sprintf(str, "%d", DataResult);  
    sendString_2(str);
    sendString_2("\"");
    sendChar_2(0xFF);  
    sendChar_2(0xFF);
    sendChar_2(0xFF);
    // Keep Alive Meldung an Nextion Display senden
    sendString_2("home.vakal.val=1");
    sendChar_2(0xFF);  
    sendChar_2(0xFF);
    sendChar_2(0xFF);
    
    // EEPROM lesen und Daten ausgeben
    uint8_t myByte = eeprom_read_byte (&eeFooByte);
    sprintf(str, "Byte auslesen: %d", myByte);
    sendString_1(str);    
    uint16_t myWord = eeprom_read_word (&eeFooWord);
    sprintf(str, "Word auslesen: %d", myWord);
    sendString_1(str);
    float myFloat = eeprom_read_float(&eeFooFloat);
    sprintf(str, "Float auslesen: %f", myFloat); //funktioniert nicht. Kommt nur ein ?
    sendString_1(str);

    // EEPROM schreiben --> funktioniert
    //eeprom_write_word (&eeFooWord, DataResult);
        
    }
}

void init_twi()
{
  TWIE.MASTER.BAUD = 0x05;
  TWIE.MASTER.CTRLA = TWI_MASTER_ENABLE_bm;
  TWIE.MASTER.STATUS |= TWI_MASTER_BUSSTATE_IDLE_gc;
}

void init_serial_1()
{
  // Baudrate 19200
  USARTE0.BAUDCTRLA = 0xB0 & 0xFF;
  USARTE0.BAUDCTRLB = ((0xB0 & 0xF00) >> 0x08);
  USARTE0.BAUDCTRLB |= ((-5 & 0x0F) << 0x04);
  /* Baudrate 9600
  USARTE0.BAUDCTRLA = 0x181 & 0xFF;
  USARTE0.BAUDCTRLB = ((0x181 & 0xF00) >> 0x08);
  USARTE0.BAUDCTRLB |= ((-5 & 0x0F) << 0x04);
  */
  USARTE0.CTRLA = USART_RXCINTLVL_LO_gc;
  USARTE0.STATUS |= USART_RXCIF_bm;
  USARTE0.CTRLB = USART_TXEN_bm | USART_RXEN_bm;
  USARTE0.CTRLC = USART_CHSIZE_8BIT_gc;
  USARTE0.CTRLC &= ~(USART_PMODE0_bm | USART_PMODE1_bm | USART_SBMODE_bm);
  PORTE.DIR = 0x08;
}

void sendChar_1(char c)
{
    while( !(USARTE0_STATUS & USART_DREIF_bm) );
    USARTE0_DATA = c;     
}
 
void sendString_1(char *text)
{
    while(*text)
    {
        sendChar_1(*text++);
    }
    //noch CR und LF anhängen
  while (!(USARTE0.STATUS & USART_DREIF_bm));
  USARTE0.DATA = 0x0D;
  while (!(USARTE0.STATUS & USART_DREIF_bm));
  USARTE0.DATA = 0x0A;
}
 
void init_serial_2()
{
  // Baudrate 9600
  USARTC0.BAUDCTRLA = 0x181 & 0xFF;
  USARTC0.BAUDCTRLB = ((0x181 & 0xF00) >> 0x08);
  USARTC0.BAUDCTRLB |= ((-5 & 0x0F) << 0x04);
  USARTC0.CTRLA = USART_RXCINTLVL_LO_gc;
  USARTC0.STATUS |= USART_RXCIF_bm;
  USARTC0.CTRLB = USART_TXEN_bm | USART_RXEN_bm;
  USARTC0.CTRLC = USART_CHSIZE_8BIT_gc;
  USARTC0.CTRLC &= ~(USART_PMODE0_bm | USART_PMODE1_bm | USART_SBMODE_bm);
  PORTC.DIR = 0x08;
}

void sendChar_2(char c)
{
    while( !(USARTC0_STATUS & USART_DREIF_bm) );
    USARTC0_DATA = c;     
}
 
void sendString_2(char *text)
{
    while(*text)
    {
        sendChar_2(*text++);
    }
    //noch CR und LF anhängen
    /*
  while (!(USARTC0.STATUS & USART_DREIF_bm));
  USARTC0.DATA = 0x0D;
  while (!(USARTC0.STATUS & USART_DREIF_bm));
  USARTC0.DATA = 0x0A;
  */
}

ISR(USARTE0_RXC_vect) // Interrupt vom Terminal
{
    char data_in = USARTE0_DATA;
  sendChar_1(data_in);  
}
ISR(USARTC0_RXC_vect) // Interrupt vom Nextion Display
{
    char data_in = USARTC0_DATA;
    sendChar_1(data_in);
}

[da und dort (Gast)]

Marie L. schrieb:
> und mir ein Feedback
> zu geben, was gut ist und was ich anders/besser machen könnte.

Zu allererst lernst du bitte die Hinweise zum Posten zu lesen,
zu verinnerlichen und zu beachten.

Im Speziellen jetzt hier:
----------------------------------------------
Wichtige Regeln - erst lesen, dann posten!
............
Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang
----------------------------------------------

Will heissen dass eine Source die länger als etwa ein Bildschirm
ist in einen Anhang als *.c Datei gepostet gehört.

Nachdem du schon seit 28.04.2010 hier angemeldet bist, also mehr
als 10 Jahre, solltest du das eigentlich wissen. Ist sozusagen
Bestandteil der Netiquette.

[Stefan F. (Gast)]

Deine Strings "fressen" eine Menge RAM. Du kannst sie stattdessen im 
FLash Speicher lassen und von dort aus verwenden. Siehe

https://www.nongnu.org/avr-libc/user-manual/pgmspace.html
https://www.nongnu.org/avr-libc/user-manual/pgmspace_8h.html

[Thomas W. (Gast)]

Moin, -

besorge Dir ein kleines C-Buch zu den Grundlagen.

> #define F_CPU 2E6

ich weiss nicht, ob der Float so eine gute Idee ist und der Compiler das 
richtig bekommt.

> /*wird bei Code::Blocks benötigt, bei Geany nicht
>  * erzeugt dort einen [-Wimplicit-function-declaration] Fehler
> void init_twi(void);

Das sind keine Fehlermeldungen sondern Warnungen des Compilers. Es 
kompiliert irgendwas (nicht unbedingt was Du Dir gedacht hast). Du hast 
implizite Funktionen deklariert (--> C-Buch). Beim Compileraufruf sind 
die Warnungen einstellbar, aber:

"Thou shalt run lint frequently and study its pronouncements with care, 
for verily its perception and judgement oft exceed thine."


>   eeprom_write_byte (&eeFooByte, 123);

eeprom_write_byte koennte auch scheitern. Sicherlich hat das einen 
Return-Wert. Auswerten!

>     float myFloat = eeprom_read_float(&eeFooFloat);
>     sprintf(str, "Float auslesen: %f", myFloat); //funktioniert nicht.
> Kommt nur ein ?

Du hast nur eine eingeschraenkte fprintf-Library. Bei Mikrocontroller 
versuche immer, float-Ausgabe zu vermeiden.

Gruesse

Th.

[Stefan F. (Gast)]

Thomas W. schrieb:
> besorge Dir ein kleines C-Buch zu den Grundlagen.
>> #define F_CPU 2E6
> ich weiss nicht, ob der Float so eine gute Idee ist und der Compiler das
> richtig bekommt.

Das ist schon in Ordnung

Thomas W. schrieb:
> Du hast nur eine eingeschraenkte fprintf-Library. Bei Mikrocontroller
> versuche immer, float-Ausgabe zu vermeiden.

Float Unterstützung bekommen man mit den folgenden Optionen:

# Enable floating-point support in printf
# LDFLAGS += -Wl,-u,vfprintf -lprintf_flt

# Enable floating-point support in scanf
# LDFLAGS += -Wl,-u,vscanf -lscanf_flt

(so steht das in meinem Makefile)

[Thomas W. (Gast)]

Moin, -

Stefan ⛄ F. schrieb:
> Thomas W. schrieb:

> Float Unterstützung bekommen man mit den folgenden Optionen:
>

> # Enable floating-point support in printf
> # LDFLAGS += -Wl,-u,vfprintf -lprintf_flt
> 
> # Enable floating-point support in scanf
> # LDFLAGS += -Wl,-u,vscanf -lscanf_flt
>

> (so steht das in meinem Makefile)

Ja, hast Du Dir den Footprint fuer das bischen Float angeguckt? OK, bei 
einem 32bitter mit richtig Speicher, aber bei einem acht-bitter muesste 
ich schon in bitterer Not sein um die Library zu nutzen (or don't care).

Einfache Nachkomma-Formatierung (z.B. 123.45) geht auch viel einfacher.
(z.B.
https://github.com/eepj/SHT2x_for_STM32_HAL/blob/master/sht2x_for_stm32_hal.c
)

Gruesse

Th.

Edith zeigt auf github.com/eepj/sht2x_for_stm32_hal

[Stefan F. (Gast)]

Thomas W. schrieb:
> Ja, hast Du Dir den Footprint fuer das bischen Float angeguckt?

ich nutze es nur, wenn ich einen guten Grund dazu habe.

[Marie L. (lendl)]

Erst mal vielen Dank für die vielen Rückmeldungen!

da und dort schrieb:
> Wichtige Regeln - erst lesen, dann posten!
> ............
> Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Mea Culpa - hätte ich mir auch denken können...
Ich gelobe Besserung!

Stefan ⛄ F. schrieb:
> Deine Strings "fressen" eine Menge RAM. Du kannst sie stattdessen
> im
> FLash Speicher lassen und von dort aus verwenden.

Hab ich mir angeschaut, aber leider nicht verstanden. Ich denke, dass 
ich bei vielen Themen einfach noch nicht soweit bin. Das ist ein guter 
Übergang zum nächsten Thema:

Thomas W. schrieb:
> besorge Dir ein kleines C-Buch zu den Grundlagen.

Ich mache gerade einen Udemy-Kurs, bin aber noch relativ am Anfang. Ist 
sehr trocken und am Projekt "rumspielen" macht einfach mehr Spass. Ich 
weiss, dass das die falsche Vorgehensweise ist, aber manchmal kann man 
halt nicht aus seiner Haut :-)

Thomas W. schrieb:
>>   eeprom_write_byte (&eeFooByte, 123);
>
> eeprom_write_byte koennte auch scheitern. Sicherlich hat das einen
> Return-Wert. Auswerten!

Das ist natürlich die Folge der Übereifers. Ich habe nicht versanden wie 
ich das auswerten kann. Vielleicht magst Du mir das ja noch erklären.

Stefan ⛄ F. schrieb:
> Float Unterstützung bekommen man mit den folgenden Optionen:# Enable
> floating-point support in printf
> # LDFLAGS += -Wl,-u,vfprintf -lprintf_flt
> # Enable floating-point support in scanf
> # LDFLAGS += -Wl,-u,vscanf -lscanf_flt
> (so steht das in meinem Makefile)

Super, vielen Dank!!! Du hast mir sehr geholfen. Jetzt funktionieren die 
Floats!

Zur Erklärung, ich werde ca. 15 bis 30 Floats brauchen, weil ich da 
Kalibrierwerte abspeichern muss.

Ich danke Euch allen für die Unterstützung!

[Falk B. (falk)]

Marie L. schrieb:
> Zur Erklärung, ich werde ca. 15 bis 30 Floats brauchen, weil ich da
> Kalibrierwerte abspeichern muss.

Vielleicht, vielleicht auch nicht. Man sollte auch mal eine Minute an 
das Thema Festkommaarithmetik verschwenden. Die reicht in vielen 
Fällen.

[Stefan F. (Gast)]

Marie L. schrieb:
>> Deine Strings "fressen" eine Menge RAM. Du kannst sie stattdessen
>> im FLash Speicher lassen und von dort aus verwenden.

> Hab ich mir angeschaut, aber leider nicht verstanden. Ich denke, dass
> ich bei vielen Themen einfach noch nicht soweit bin.

Kurz gesagt, änderst du

> puts("Es war einmal ein langer String...");

in

> puts_p(PSTR("Es war einmal ein langer String..."));

Dann wird der String beim Programmstart nicht ins RAM kopiert, sondern 
direkt aus dem Flash verwendet. Der Zugriff darauf ist ein bisschen 
langsamer.

Oder:

> char geschichte[] PROGMEM = "Es war einmal ein langer String...";
> puts_p(geschichte);

Die ganzen xxx_p() Funktionen sind dafür vorbereitet, direkt aus dem 
Flash zu lesen.

[Thomas W. (Gast)]

Moin, -

please disregard my comment: in <avr/eeprom.h> ist wie folgt definiert:

void eeprom_write_byte   (   
        uint8_t *      __p,
        uint8_t        __value 
    )

d.h. eine Fehlermeldung gibt es nicht. Wenn es einen Fehler gibt (d.h. 
out of bound, Eeprom nicht bereit) bekommst Du das nicht mit (-> per 
Hand programmieren: Schreiben, Lesen, vergleichen)

Gruesse

Th.

[Thomas W. (Gast)]

Moin, -

noch eine kleine Bemerkung: Flash kann man ca. 10000x beschreiben, 
eeprom ca. 100000x. Hoert sich sehr viel an, wenn Du aber auf die Idee 
kommst, jede Minute Messdaten in den Eeprom zu schreiben, hast Du die 
theoretische Lebenserwartung nach 70 Tagen erreicht.

Gruesse

Th.

[Marie L. (lendl)]

Falk B. schrieb:
> Vielleicht, vielleicht auch nicht. Man sollte auch mal eine Minute an
> das Thema Festkommaarithmetik verschwenden. Die reicht in vielen
> Fällen.

Ja, das ist in der Tat sehr interessant, das werde ich mir mal genauer 
anschauen. Danke!

Stefan ⛄ F. schrieb:
> Dann wird der String beim Programmstart nicht ins RAM kopiert, sondern
> direkt aus dem Flash verwendet. Der Zugriff darauf ist ein bisschen
> langsamer.

Geschwindigkeit spielt bei den Messungen keine große Rolle, ich werde es 
mal testen, ob ich damit zurecht komme. Danke!

Thomas W. schrieb:
> d.h. eine Fehlermeldung gibt es nicht. Wenn es einen Fehler gibt (d.h.
> out of bound, Eeprom nicht bereit) bekommst Du das nicht mit (-> per
> Hand programmieren: Schreiben, Lesen, vergleichen)

Die Kalibrierwerte müssen nach der Kalibrierung wieder ausgegeben werden 
(zur Kontrolle und Dokumentation). Also wird es sowieso eine Funktion 
geben (müssen), die alle Kalibrierwerte ausliest. Mal schauen ob ich das 
gleich kombinieren kann... Danke!

Thomas W. schrieb:
> noch eine kleine Bemerkung: Flash kann man ca. 10000x beschreiben,
> eeprom ca. 100000x. Hoert sich sehr viel an, wenn Du aber auf die Idee
> kommst, jede Minute Messdaten in den Eeprom zu schreiben, hast Du die
> theoretische Lebenserwartung nach 70 Tagen erreicht.

Ich kann dich beruhigen, es werden nur Kalibrierwerte und keine 
Messwerte ins Eeprom geschrieben. Also maximal 30 Werte und das ca. 
einmal im Jahr. Ansonsten kommen eventuell noch "Zustände" ins Eeprom, 
z.B. der Messbereich, damit man beim Einschalten wieder die gleichen 
Einstellungen hat.

Euch allen nochmal vielen Dank für die freundliche Unterstützung!
Ich werde bestimmt noch die ein oder andere doofe Frage stellen. Der 
Umstieg von Bascom auf C ist nämlich nicht ohne.
Bis bald...