UART und SD Karte

[Holger W. (mb_holger)]

Wer kann mir helfen. Ein Atmega 32, ein LCD 2x16 und ein SD Karten 
Modul.

Ich habe  den Beispiel Quellcode aus dem Buch "AVR Hardware und
Programmierung in C"  sd-karte.c  für ein  Projekt verwendet.
Ich zeichne die Temperatur mit Zeit und Datum auf je Stunde. Mit einen 
Taster kann ich die Aufzeichnung stoppen und die Karte im Programm 
wechseln.
Die Aufzeichnung funktioniert sehr gut alles OK.

Weiter habe ich ein umfangreiches Programm mit Ausgabe und Untermenüs 
auf einen 2x16 LCD für Temperatur-Max -Min Datum-  Zeit- 
Batteriespannungsanzeige....und Auswertungen ....mit einen Programmteil 
zur Einstellung der des Datums und der Uhr erstellt. Alles funktioniert 
sehr gut.

Mein Problem ich schaffe es nicht die beiden Programme zusammenzuführen.
Die SD Karten Aufzeichnung funktioniert störungsfrei aber das LCD geht 
nicht es zeigt sinnlose Zeichen an nach der Initialisierung der SD Karte 
und ist nicht mehr ansprechbar.

Hier der C Code. Ich habe ein einfaches Beispiel erzeugt zur 
Demonstration.
Die erste Zeile Datensatz 1 wird fehlerfrei angezeigt. Nach der 
Programmstelle  timer0_init(); Geht das LCD noch richtig und gibt 
fehlerfrei die zweite Zeile aus.

Nach dem nächsten Programmschritt  uinit();// uart config  ist Schluss 
danach geht es nicht mehr. Aber wie gesagt die Aufzeichnung auf die SD 
Karte funktioniert fehlerfrei.

Mein erster Verdacht war die Variable str[20] im C Code SD Karte und die 
gleiche Variable str[5] im C Code des LCD, aber nach der Änderung str[5] 
in strl[5] für das LCD ist der Fehler nicht behoben.

Ich denke es ist ein Zeiger Konflikt? Im C Code und den Bibliotheken der 
SD Karte sind viele static Variablen und in der  #include 
<util/LCD_display_free_int_pins.h> für das LCD keine static?

Vielen Dank , Ich bin noch Anfänger zwei dicke Bücher habe ich schon 
gelesen aber hier komme ich nicht weiter.

hier der C code Beispiel und die #include 
<util/LCD_display_free_int_pins.h>
und #include "uart.h" und uart.c

/**
 *  Greift auf eine SD Karte per SPI zu
 *
 *   Doku, siehe http://www.mikrocontroller.net/articles/AVR_FAT32
 *  Neuste Version: http://www.mikrocontroller.net/svnbrowser/avr-fat32/
 *  
 *
 */

#define F_CPU 8000000UL
#include <avr/io.h>
#include <util/delay.h>    // definiert _delay_ms() 


#include <avr/interrupt.h>
#include <stdio.h>
#include <mmc_config.h>  // Hier werden alle noetigen Konfigurationen vorgenommen, umbedingt anschauen !
#include <file.h>
#include <fat.h>
#include <mmc.h>    // Hardware abhaengig
#include <uart.h>    // Hardware abhaengig, es kann auch eine eigene eingebunden werden !

#include <avr/BitUtilities.h>

#include <util/LCD_display_free_int_pins.h>

char strl [5];
int xx = 0;    // Zähler Datensatz


//""""  SD Karte   """"""""""""""""""""""""""""""""""""""""""""""""""""

// prototypen von funktionen in dieser datei
static void timer0_init(void);
int main(void);

// timer0 einstellungen, werte mit http://www.avrcalc.com/download.html berechnet!
// aus diesen 3 werten ergibt sich die tick zeit, hier 10ms. 
// 4 = prescaler 256, 3 = prescaler 64, 5 = prescaler 1024, 2 = prescaler 8. wenn prescaler 0 = prescaler dann stoppt der timer
#if(F_CPU == 4000000)      // error 0.16%
  #define TOP_OCR 0x9B
  #define START_TCNT 0x64
  #define PRESCALER 0x04
#endif

#if(F_CPU == 8000000)      // error 0,16%
  #define TOP_OCR 0x4D
  #define START_TCNT 0xB2
  #define PRESCALER 0x05
#endif

#if(F_CPU == 10000000)      // error 0.351%
  #define TOP_OCR 0x61
  #define START_TCNT 0x9E
  #define PRESCALER 0x05
#endif

#if(F_CPU == 12000000)      // error 0.16%
  #define TOP_OCR 0x74
  #define START_TCNT 0x8B
  #define PRESCALER 0x05
#endif

#if(F_CPU == 16000000)      // error 0,16%
  #define TOP_OCR 0x9B
  #define START_TCNT 0x64
  #define PRESCALER 0x05
#endif

#if(F_CPU == 20000000)      // error 0.16%
  #define TOP_OCR 0x4D
  #define START_TCNT 0xB2
  #define PRESCALER 0x04
#endif

// timer0 variable
volatile uint8_t   TimingDelay;  // fuer mmc.c

ISR (TIMER0_COMP_vect)
{
  TimingDelay = (TimingDelay==0) ? 0 : TimingDelay-1;
}

static void timer0_init()
{
  // timer0 config  
  // initialisierung, auf jeden fall vor mmc_init(), 
  // denn da wird der timer benoetigt!

  TimingDelay = 0;    // initialisierung der zaehl variable  

  TCCR0 = 1<<WGM01;     // timer0 im ctc mode
  TIMSK = 1<<OCIE0;    // compare interrupt an

  TCNT0 = START_TCNT;    // ab wo hochgezaehlt wird,
  OCR0 = TOP_OCR;      // maximum bis wo gezaehlt wird bevor compare match  

  TCCR0 = PRESCALER;    // wenn prescaler gesetzt wird, lauft timer los
  sei();          // interrupts anschalten, wegen compare match
}


// ***** Haupt Programm  ************************************************************************************************************


int main(void)

{
  
  lcd_init(); lcd_send(COMMAND, LCD_CLEAR);                //LCD
  lcd_set_cursor (1, 1);lcd_write ("Datensatz");              //LCD
  sprintf(strl,"%02d",xx); lcd_set_cursor (1, 12); lcd_write (strl);    //LCD
  
  
//"""""  SD Karte Aktivierung """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""

uint8_t file_name [] = "Temp.txt";
char str [20];

timer0_init();    // Timer initialisieren bevor FAT Library genutzt wird


  lcd_set_cursor (2, 1);lcd_write ("Datensatz");              //LCD letze funktionierende Stelle
  sprintf(strl,"%02d",xx); lcd_set_cursor (2, 12); lcd_write (strl);    //LCD letze funktionierende Stelle


uinit();      // uart config

uputs((uint8_t*)"Start");

// sd/mmc config
if( FALSE == mmc_init() )
{
  uputs((uint8_t*)" -> Fehler Init. Ende\n");
  return -1;
}

// fat config
if( FALSE == fat_loadFatData() )
{
  uputs((uint8_t*)" -> Fehler loadFatData. Ende\n");
  return -1;
}

uputs((uint8_t*)" OK\n");



  // ********************** Datei schreiben auf SD **********************
      
      for (unsigned char i = 0; i <= 9; i++)
      {
       xx++;  
      
      if( MMC_FILE_OPENED == ffopen(file_name,'r') )    // Oeffne existierende Datei zum anhaengen von Daten. Wenn geklappt
      {ffseek(file.length);}  // Gehe ans Ende der Datei und LED2 an
      
      else
      {ffopen(file_name,'c');}              
      
      sprintf (str, "Datensatz %2d\r\n",xx);  // DOS Zeilenumbruch
      ffwrites ((uint8_t*)str);
      ffclose();
      }
  
  lcd_set_cursor (2, 1);lcd_write ("Datensatz");              //LCD
  sprintf(strl,"%02d",xx); lcd_set_cursor (2, 12); lcd_write (strl);    //LCD
          
return(0);
  }

und die #include <util/LCD_display_free_int_pins.h>

// LCD Output for  HD44780 compatible displays
// Pinning adapted to set interrupt pins free
// Target: ATMEGA8

#include "BitUtilities.h"

// LCD control cmmands 
#define LCD_CLEAR    0x01  /*Clear display:     0b 0000 0001  */
#define LCD_HOME    0x02  /*Cursor home:       0b 0000 0010  */
#define LCD_ON      0x0C  /*Cursor invisible:     0b 0000 1100  */
#define LCD_OFF      0x08  /*Display off:       0b 0000 1000  */
#define POS_01      0x80  /*Line 1 - Column 0    0b 1000 0000   */
#define POS_02      0xC0  /*Line 2 - Column 0    0b 1100 0000   */
// definitions of port pins
#define  LCDPORT      PORTD
#define  LCDDDR      DDRD
#define LCD_PIN_RS    0
#define LCD_PIN_E    3
#define LCD_PIN_D4    4
#define LCD_PIN_D5    5
#define LCD_PIN_D6    6
#define LCD_PIN_D7    7

#define  COMMAND      0
#define DATA      1

void toggle_enable_pin(void)
{
  sbi(LCDPORT, LCD_PIN_E); cbi(LCDPORT, LCD_PIN_E);  
}

void lcd_send(unsigned char type, unsigned char c)
{
  unsigned char sic_c;  // backup for c
  
  // send high nibble
  sic_c = c;                  // save original c
  sic_c &= ~0x0f;                // set bit 0-3 == 0
  if (type==DATA) sic_c |= (1<<LCD_PIN_RS);  // data: RS = 1
  LCDPORT = sic_c; toggle_enable_pin();    // send high nibble
  
  // send low nibble
  sic_c = c;                  // save original c
  sic_c = sic_c<<4;              // exchange nibbles
  sic_c &= ~0x0f;                // set bit 0-3 == 0
  if (type==DATA) sic_c |= (1<<LCD_PIN_RS);  // data: RS = 1
  LCDPORT = sic_c; toggle_enable_pin();    // send low nibble
  _delay_ms(5);                // Wait for LCD controller
}

// set cursor to line x and column y
void lcd_set_cursor(uint8_t line, uint8_t col)
{ uint8_t i;
  switch (line) 
  { case 1: i=0x80+0x00+col; break;    // 1. line
    case 2: i=0x80+0x40+col; break;    // 2. line
    default: return;                   // invalid line
  }
  lcd_send(COMMAND, i);
}

// write string to LCD
void lcd_write(char *data)
{    while(*data) {lcd_send(DATA, *data); data++;}
}

// Initializing LCD controller - see data sheet for details
void lcd_init()
{
  /* Set Port to Output */
  LCDPORT = 0x00;  LCDDDR  = 0xFF;
  _delay_ms(50); // Wait for LCD

  /* 4-bit Modus config */
  sbi(LCDPORT, LCD_PIN_D5); cbi(LCDPORT, LCD_PIN_D4);

  /* 4-Bit Modus start */ 
  sbi(PORTD, LCD_PIN_E); cbi(PORTD, LCD_PIN_E); _delay_ms(5); 

  /* 2 Lines, 4-Bit Mode */
  lcd_send(COMMAND, 0x28);
  lcd_send(COMMAND, LCD_OFF);  lcd_send(COMMAND, LCD_CLEAR);
  lcd_send(COMMAND, 0x06);  lcd_send(COMMAND, LCD_ON);
}

hier die #include "uart.h"

*
 *   Doku, siehe http://www.mikrocontroller.net/articles/AVR_FAT32
 *  Neuste Version: http://www.mikrocontroller.net/svnbrowser/avr-fat32/
 *  Autor: Daniel R.
 */


#ifndef _UART_H

  #define _UART_H  
  #define BAUD 9600l
  #define UBRR_VAL ((F_CPU+BAUD*8)/(BAUD*16)-1)   // clever runden


  #if defined (__AVR_ATmega168__)
  #define UDR       UDR0  
  #define UCSRA      UCSR0A  
  #define UDRE      UDRE0  
  #define UCSRB    UCSR0B  
  #define RXC       RXC0
  #define UCSRC    UCSR0C
  #define UCSZ0    UCSZ00
  #define RXEN    RXEN0
  #define TXEN    TXEN0
  #define UBRRH    UBRR0H
  #define UBRRL    UBRR0L
  #endif

  //#######################################################################################################################
  // funktionen

  extern void uinit(void);        //Initialisiert uart
  extern void uputc(uint8_t c);
  extern void uputs (uint8_t *s);
  extern void ugets( int8_t*,uint8_t);
  extern uint8_t ugetc(void);

#endif


/*
Terminal VT100 zeichen

uputc(0x1B);    //steuer zeichen ESC (hex 0x1B, dez 27) Achtung, wird erst gesendet wenn danach ein string gesendet wird !! siehe uputs uputc

uputs("[1K");    //links vom cursor zeile löschen
uputs("[K");    //rechts vom cursor zeile löschen
uputs("[2J");    //vom cursor abwärts schirm löschen
uputs("[J");    //vom cursor aufwärts schirm löschen

uputs("[01;01H");  //position cursor zeile 1, spalte 1

    * die Zeilennummer 1-24
    * die Spalternummer 1-80 oder 1-132     


<ESC>[paramm     '-(das ist ein kleines "m" am Schluß)-'

Mögliche "param" sind:

    * 0 = Normal
    * 1 = Heller (bold)
    * 4 = Unterstrichen
    * 5 = Blinkend
    * 7 = Reverse (dunkel auf hell bzw. umgekehrt) 

Dabei können mehrere Attribute angegeben werden, dann aber mit Semikolon getrennt:

<ESC>[param1;param2;param3m 
*/

und die uart.c

/*
 *   Doku, siehe http://www.mikrocontroller.net/articles/AVR_FAT32
 *  Neuste Version: http://www.mikrocontroller.net/svnbrowser/avr-fat32/
 *  Autor: Daniel R.
 */

#define F_CPU 8000000UL
#include "mmc_config.h"
#include "uart.h"



//***********************Funktionen**********************************
void uputc(uint8_t c){    //zeichen senden

  loop_until_bit_is_set(UCSRA,UDRE);  // warten bis puffer frei ist
  UDR = c;                // zeichen schreiben
}  

//*******************************************************************
void uputs (uint8_t *s){    //string senden
  
  while(*s) uputc(*s++);        //sendet zeichenkette, bis ende.. '\0'    
  
}

#if (!1)

// *******************************************************************
uint8_t ugetc(void){      //zeichen holen

  while (!(UCSRA & (1<<RXC))) {;}  // warten bis Zeichen verfuegbar
        
  return UDR;                      // Zeichen aus UDR an Aufrufer zurueckgeben
}


// *******************************************************************
void ugets(int8_t* Buffer, uint8_t MaxLen){  // zeichenkette holen
  uint8_t NextChar;
  uint8_t StringLen = 0;
 
  NextChar = ugetc();             // Warte auf und empfange das nächste Zeichen  
                                
  while( NextChar != '\n' && StringLen < MaxLen - 1 ) {    //string ende oder puffer voll
    *Buffer++ = NextChar;
    StringLen++;
    NextChar = ugetc();
  }
   
  *Buffer = '\0';          //string abschluss
}
#endif


//*******************************************************************
void uinit (void){          //init usart Tx, 8n1 ,UDRE interupt enable

  UCSRC |= (3<<UCSZ0);        // URSEL = 1 dann wird UCSRC benutzt sonst UBRRH ; UCSZ0=data register- 8bit; USBS stop bit 1   
  //Baudrate (high und low byte)
  UBRRH = (uint8_t)(UBRR_VAL>>8);
  UBRRL = (uint8_t)UBRR_VAL;
  UCSRB |= (1<<TXEN)|(1<<RXEN);    // UART TX,RX einschalten,  data register empty interrupt enable,
}

[Holger W. (mb_holger)]

Hallo ich selbst noch mal,

Ich habe weiter getestet und einfach uinit() ausgeschaltet  mit
//uinit()  // uart config. und jetzt läuft alles bis zum Programmende 
richtig ab. Die Anzeige macht alles richtig und die Aufzeichnung auf die 
SD Karte funktioniert. Am Programmende sind die Daten auf der SD Karte 
und in der 2. Zeile des LCD steht richtig Datensatz 10, so wie es sein 
soll.

Die Funktion uinit() // uart config hat die LCD Anzeige gestört. Wer 
kann mir das Beantworten warum und wozu ist die Funktion uinit() // uart 
config notwendig? Gibt die Funktion uinit() // uart config Signale an 
den Ports D aus
wo das LCD angeschlossen ist?



Holger Weiß

[Holger W. (mb_holger)]

Hier die Funktion void uinit (void)

Was Stört hier das LCD? und warum funktioniert die SD Karten 
Aufzeichnung auch ohne die Funktion? Bitte um  Hilfe ..Danke.


Hier die Funktion void uinit (void)

void uinit (void){          //init usart Tx, 8n1 ,UDRE interupt enable

  UCSRC |= (3<<UCSZ0);        // URSEL = 1 dann wird UCSRC benutzt sonst UBRRH ; UCSZ0=data register- 8bit; USBS stop bit 1   
  //Baudrate (high und low byte)
  UBRRH = (uint8_t)(UBRR_VAL>>8);
  UBRRL = (uint8_t)UBRR_VAL;
  UCSRB |= (1<<TXEN)|(1<<RXEN);    // UART TX,RX einschalten,  data register empty interrupt enable,
}

[Dieter F. (Gast)]

Na ja, es ist schon unpraktisch Port D als LCD-Port zu verwenden, wenn 
dort der U(S)ART beheimatet ist und man den auch nutzen will. Das stört 
sich natürlich gegenseitig.

Die Fleury-Lib erlaubt es, z.B. die Datenleitungen des LCD auf PC.. 
zugeben und die Steuerleitungen auf freie PB.. oder PD.. oder ... zu 
geben.

Für einen Anfänger legst Du aber ordentlich auf :-)

[Holger W. (mb_holger)]

Danke für den Tipp.
Habe ich Übersehen das PD0 und PD1 bim Atmega 32 RXD und TXD vom UART.
Der RS Anschluss vom LCD lag auf dem PD0. Das War der Fehler.
Ich habe in der #include <util/LCD_display_free_int_pins.h> aus
#define LCD_PIN_RS 0 einfach
#define LCD_PIN_RS 3 gemacht und schon liegt der RS Anschluss vom LCD 
auf PD3. Und ich kann die Funktion uinit() // uart config
anschalten.

Ich habe die #include <util/LCD_display_free_int_pins.h> aus der CD vom 
Buch AVR Mikrocontroller in C programmieren vom Franzis Verlag. Eine 
böse Falle dass die in der Vorlage den PIN RS das LCD auf den PIN PD0 
des Atmega legen.

Ich bin ganz schön ins schwitzen gekommen und hat mich viel Zeit 
gekostet
diesen kleinen Fehler zu finden. Ohne den Tipp von Dieter Frohnapfel 
wäre ich nicht darauf gekommen.

Jetzt sollte es mir gelingen mein erstes großes Projekt fertigzustellen.

Trotzdem noch eine Frage ist Funktion uinit() // uart config also  UART
notwendig für das schreiben auf die SD Karte. Es hat ja auch ohne UART 
funktioniert und vom SD Karten Modul ist kein Pin an UART angeschlossen.


nochmals Danke
Holger

[Holger W. (mb_holger)]

Hallo noch mal.
Ich mache einen neuen Thread auf, ich habe nur noch eine Frage alles 
andere ist gelöst.


Dieter F. schrieb:
> Na ja, es ist schon unpraktisch Port D als LCD-Port zu verwenden, wenn
> dort der U(S)ART beheimatet ist und man den auch nutzen will. Das stört
> sich natürlich gegenseitig.
>
> Die Fleury-Lib erlaubt es, z.B. die Datenleitungen des LCD auf PC..
> zugeben und die Steuerleitungen auf freie PB.. oder PD.. oder ... zu
> geben.
>
> Für einen Anfänger legst Du aber ordentlich auf :-)


Danke für den Tipp.
Habe ich Übersehen das PD0 und PD1 bim Atmega 32 RXD und TXD vom UART.
Der RS Anschluss vom LCD lag auf dem PD0. Das War der Fehler.
Ich habe in der #include <util/LCD_display_free_int_pins.h> aus
 #define LCD_PIN_RS 0 einfach
 #define LCD_PIN_RS 3 gemacht und schon liegt der RS Anschluss vom LCD
auf PD3. Und ich kann die Funktion uinit() // uart config
anschalten.

Ich habe die #include <util/LCD_display_free_int_pins.h> aus der CD vom
Buch AVR Mikrocontroller in C programmieren vom Franzis Verlag. Eine
böse Falle dass die in der Vorlage den PIN RS das LCD auf den PIN PD0
des Atmega legen.

Ich bin ganz schön ins schwitzen gekommen und hat mich viel Zeit
gekostet diesen kleinen Fehler zu finden. Ohne den Tipp von Dieter 
Frohnapfel
wäre ich nicht darauf gekommen.

Jetzt sollte es mir gelingen mein erstes großes Projekt fertigzustellen.



Trotzdem noch eine Frage ist  Funktion uinit() // uart config (also 
UART)
notwendig für das Schreiben auf die SD Karte. Es hat ja auch ohne UART
funktioniert und vom SD Karten Modul ist kein Pin an UART angeschlossen.

nochmals Danke
 Holger

[grundschüler (Gast)]

Holger W. schrieb:
> notwendig für das Schreiben auf die SD Karte.

offensichtlich nicht

Den uart verwendet man als Protokollfunktion zur Fehlersuche. Das geht 
aber auch mit dem LCD. Du brauchst den uart also nicht unbedingt. der 
von Dir verwendete M32 ist im Prinzip veraltet. Aktuell wäre z.B. der 
pingleiche M1284 für rund 6€. Irgendwann steigst du eh um.

[Dieter F. (Gast)]

Holger W. schrieb:
> Trotzdem noch eine Frage ist Funktion uinit() // uart config also  UART
> notwendig für das schreiben auf die SD Karte.

Hallo Holger,

nein. Ich kenne die von Dir eingesetzten SD-Routinen zwar nicht, gehe 
aber davon aus dass die Kommunikation mit der Karte per SPI abläuft. Der 
U(S)ART wird wohl nur zur Zustandsportokollierung / für Fehlermeldungen 
mit "uputs(..." eingesetzt. Diese solltest Du dann wenigstens auf dem 
LCD ausgeben.

Wenn Du den U(S)ART nicht nutzen willst kannst Du die ursprüngliche 
Pin-Belegung auch beibehalten ... .

Gruß
Dieter

[Holger W. (mb_holger)]

grundschüler schrieb:
> Holger W. schrieb:
>> notwendig für das Schreiben auf die SD Karte.
>
> offensichtlich nicht
>
> Den uart verwendet man als Protokollfunktion zur Fehlersuche. Das geht
> aber auch mit dem LCD. Du brauchst den uart also nicht unbedingt. der
> von Dir verwendete M32 ist im Prinzip veraltet. Aktuell wäre z.B. der
> pingleiche M1284 für rund 6€. Irgendwann steigst du eh um.

Was ist der Unterschied ? Ich habe im Internet nichts gefunden.

Grüße Holger

[Stefan F. (Gast)]

> Ich habe im Internet nichts gefunden.

Kopfschüttel - das kann gar nicht sein.

Für beide Kontroller kannst du mit jeder beliebigen Suchmaschine die 
Datenblätter finden. Außer mit Hotel-Suchmaschinen.


Zum Beispiel liefert Bing für "atmega32 atmega1284 vergleich" sogar als 
allererstes diesen Link:

http://mikrocontroller.net/articles/AVR_Typen  (lustig, was?)

Und wenn du dort mit Strg-F nach "1284" suchst, landest du in einer 
Vergleichstabelle.

Den weg zum Klo findest du aber alleine? :-)

[Holger W. (mb_holger)]

grundschüler schrieb:
> Den uart verwendet man als Protokollfunktion zur Fehlersuche. Das geht
> aber auch mit dem LCD. Du brauchst den uart also nicht unbedingt. der
> von Dir verwendete M32 ist im Prinzip veraltet. Aktuell wäre z.B. der
> pingleiche M1284 für rund 6€. Irgendwann steigst du eh um.

Alles klar ich habe die Bezeichnungen M 32 bzw MI1284 auf das LCD 
bezogen.
und deshalb nichts gefunden.

Restlos verblödet bin ich nicht. Ist mein erstes Projekt.

Holger