www.mikrocontroller.net

Forum: Compiler & IDEs Teilprogramm auslagern


Autor: Ingo Laabs (grobian)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Moin moin,

ich raffe dieses Auslagerungs-Gedöhns nicht wirklich.
Ich will im unten aufgeführten Programm dem EEprom kram auslagern (habe 
die Stellen mal mit ++++++ markiert) finde aber weder im Buch noch hier 
im web ne info wie ich da vorgehen soll.

@karl heinz buchegger
nicht böse sein, dass ich deinen Vorschlag mit define noch nicht 
umgesetzt habe, ist halt ein bissel warm und das Freibad hat gerufen.


Gruß aus Berlin
Ingo

// Mega 32
// CPU 12 MHz EEPROM 24c08 100 KHz
#include <stdlib.h>
#include <avr/io.h>
#include <avr/twi.h>

#define F_CPU 12000000UL

// General TWI Master staus codes
#define START 0x08

// TWI Master Transmitter staus codes
#define TWI_MTX_ADR_ACK    0x18  // SLA+W has been tramsmitted and ACK 
received
#define TWI_MTX_ADR_NACK  0x20  // SLA+W has been tramsmitted and NACK 
received
#define TWI_MTX_DATA_ACK  0x28  // Data byte has been tramsmitted and 
ACK received
#define TWI_MTX_DATA_NACK  0x30  // Data byte has been tramsmitted and 
NACK received

int EEpromDaten ;
int EEpromAdresse ;
int BasisAdresse1;
int BlockAdresse;
int Speicherzelle;
int BasisAdresse;



int  ERROR (void)
 {
 DDRA = 0xFF;
 PORTA = 0x01;
 while(1)
  {
     // Nüscht machen !
  }
return 0;
 }

++++++ Ab hier auslagern  ++++++

int EEPROM_SCHREIBEN (void)
{
  BasisAdresse  = 0xA0;
    BlockAdresse  = EEpromAdresse/256;
    BasisAdresse1 = BasisAdresse + BlockAdresse * 2;
    Speicherzelle = EEpromAdresse%256;    // modulo

TWSR = (0<<TWPS0) | (0<<TWPS1);     // Prescaler 1
TWBR = 0x34;          // berechnung ergab 52


TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTA);  // start senden
while  (!(TWCR & (1<<TWINT)));      // warten bis fertig
if ((TWSR & 0xF8) != START)
ERROR();


TWDR = BasisAdresse1  ;       // Controll BYTE fur 24c08  OxA1 = lesen 
!!
TWCR = (1<<TWINT) | (1<<TWEN);
while (!(TWCR & (1<<TWINT)));      // warten bis fertig
if ((TWSR & 0xF8) != TWI_MTX_ADR_ACK)    // hats geklappt ?
ERROR();


TWDR = Speicherzelle;    // Daten(ADRERSSE) an das EEPROM senden
TWCR = (1<<TWINT) | (1<<TWEN);
while (!(TWCR & (1<<TWINT)));      // warten bis fertig
if ((TWSR & 0xF8) != TWI_MTX_DATA_ACK)    // hats geklappt ?
ERROR();


TWDR = EEpromDaten;    // Daten(DATEN) an das EEPROM senden
TWCR = (1<<TWINT) | (1<<TWEN);
while (!(TWCR & (1<<TWINT)));      // warten bis fertig
if ((TWSR & 0xF8) != TWI_MTX_DATA_ACK)    // hats geklappt ?
ERROR();

TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTO); // und STOP senden
while(TWCR & (1<<TWSTO));    // warten bis fertig

return 0;
}


+++++++ bis hier auslagern ++++++++++

int main (void)
{

for (EEpromAdresse=0 ; EEpromAdresse <=1023 ; EEpromAdresse++)

  {
      EEpromDaten = 0;
    EEPROM_SCHREIBEN();
  }


while(1)
{
return 0;
}

}

Autor: Matthias Keller (mkeller)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Was meinst du mit auslagern? In eine eigenständige .c Datei? Alle 
Variablen die du auch in anderen Programmen brauchst machst du global 
und deklarierst sie als extern. Alle Variablen die nur dein EEPROM 
Teilprogramm braucht nimmst du mit und lässt sie lokal. Oder habe ich 
dich falsch verstanden, wo liegt das Problem?

Autor: Ingo Laabs (grobian)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Matthias Keller schrieb:
> Was meinst du mit auslagern? In eine eigenständige .c Datei?
 joooo, so meinte ich das.
So dass ich diesen Programmabschnitt in weiteren Programmen verwenden 
kann einschließlich der deklarierten Variablen.

Autor: Ingo Laabs (grobian)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
um es anders auszudrücken, ich finde immer Programme die dann in 
kleinere Abschnitte gegliedert sind.
zb:
main.c
eeprom.c
dcf.c
soundso.c

in Verbindung mit

main.h
eeprom.h
dcf.h
soundso.h

und den kram schnalle ich irgendwie nicht

von daher will ich mein o.a Programm auch in diese Teile zerlegen. In 
diesem Falle EEprom.c halt um diesen Programmabschnitt wieter zu 
verwenden.

Hoffe, ich habe das jetzt so einigermaßen verständlich rüber 
gebracht.....uffff

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ingo Laabs schrieb:

> und den kram schnalle ich irgendwie nicht

Wo liegt das Problem.

Du fängst damit an, deine Funktionen in eine eigene *.c zu verschieben

eeprom.c
int EEPROM_SCHREIBEN (void)
{
  BasisAdresse  = 0xA0;
  BlockAdresse  = EEpromAdresse/256;
  BasisAdresse1 = BasisAdresse + BlockAdresse * 2;
  Speicherzelle = EEpromAdresse%256;    // modulo

  TWSR = (0<<TWPS0) | (0<<TWPS1);     // Prescaler 1
  TWBR = 0x34;          // berechnung ergab 52


  TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTA);  // start senden
  while  (!(TWCR & (1<<TWINT)));      // warten bis fertig
  if ((TWSR & 0xF8) != START)
    ERROR();


  TWDR = BasisAdresse1  ;       // Controll BYTE fur 24c08  OxA1 = lesen !!
  TWCR = (1<<TWINT) | (1<<TWEN);
  while (!(TWCR & (1<<TWINT)));      // warten bis fertig
  if ((TWSR & 0xF8) != TWI_MTX_ADR_ACK)    // hats geklappt ?
    ERROR();


  TWDR = Speicherzelle;    // Daten(ADRERSSE) an das EEPROM senden
  TWCR = (1<<TWINT) | (1<<TWEN);
  while (!(TWCR & (1<<TWINT)));      // warten bis fertig
  if ((TWSR & 0xF8) != TWI_MTX_DATA_ACK)    // hats geklappt ?
    ERROR();


  TWDR = EEpromDaten;    // Daten(DATEN) an das EEPROM senden
  TWCR = (1<<TWINT) | (1<<TWEN);
  while (!(TWCR & (1<<TWINT)));      // warten bis fertig
  if ((TWSR & 0xF8) != TWI_MTX_DATA_ACK)    // hats geklappt ?
    ERROR();

  TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTO); // und STOP senden
  while(TWCR & (1<<TWSTO));    // warten bis fertig

  return 0;
}

Soweit so gut.
Jetzt brauchst du erst mal ein Header File dafür.
In das Header File kommt alles rein, was ein Verwender der Funktionen 
wissen muss. Was könnte das sein? Nun zunächst mal muss er wissen welche 
Funktionen es gibt, welche Argumente sie nehmen und welche Returnwerte 
sie liefern.

Also fängst du an

eeprom.h
int EEPROM_SCHREIBEN (void);

Du du ein guter C-Programmierer bist, legst du auch gleich noch einen 
Include-Guard in das Header File

eeprom.h
#ifndef EEPROM_H_INCLUDED
#define EEPROM_H_INCLUDED

int EEPROM_SCHREIBEN (void);

#endif

Soweit so gut.
Zurück zum EEPROM.C

Wenn dieses File compiliert wird, für sich alleine, welche includes 
benötigt es.
Dazu müsst du wissen, was denn alles in der Funktion verwendet wird. 
Kurz über den Code drüber geschaut ergibt: io.h wird auf jeden Fall 
drinnen sein. twi.h ebenfalls. Und das eigene Include File eeprom.h zu 
inkludieren ist auch immer eine gute Idee. Auf die Art kann der Compiler 
prüfen, ob der Prototyp im Header File auch mit der Funktionsdefinition 
übereinstimmt.
Auch werden alle #define die für das EEPROM_SCHREIBEN notwendig sind aus 
der Hauptdatei nach eeprom.c verschoben.
Ziel ist es, dass eeprom.c für sich alleine compiliert werden kann. Dazu 
muss aber alles was da drinnen verwendet wird, auch irgendwo herkommen.

Also:
#include <avr/io.h>
#include <avr/twi.h>
#include "eeprom.h"

// General TWI Master staus codes
#define START 0x08

// TWI Master Transmitter staus codes
#define TWI_MTX_ADR_ACK    0x18  // SLA+W has been tramsmitted and ACK received
#define TWI_MTX_ADR_NACK  0x20  // SLA+W has been tramsmitted and NACK received
#define TWI_MTX_DATA_ACK  0x28  // Data byte has been tramsmitted and ACK received
#define TWI_MTX_DATA_NACK  0x30  // Data byte has been tramsmitted and NACK received

int EEPROM_SCHREIBEN (void)
{
  BasisAdresse  = 0xA0;
  BlockAdresse  = EEpromAdresse/256;
  BasisAdresse1 = BasisAdresse + BlockAdresse * 2;
  Speicherzelle = EEpromAdresse%256;    // modulo

  TWSR = (0<<TWPS0) | (0<<TWPS1);     // Prescaler 1
  TWBR = 0x34;          // berechnung ergab 52


  TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTA);  // start senden
  while  (!(TWCR & (1<<TWINT)));      // warten bis fertig
  if ((TWSR & 0xF8) != START)
    ERROR();


  TWDR = BasisAdresse1  ;       // Controll BYTE fur 24c08  OxA1 = lesen !!
  TWCR = (1<<TWINT) | (1<<TWEN);
  while (!(TWCR & (1<<TWINT)));      // warten bis fertig
  if ((TWSR & 0xF8) != TWI_MTX_ADR_ACK)    // hats geklappt ?
    ERROR();


  TWDR = Speicherzelle;    // Daten(ADRERSSE) an das EEPROM senden
  TWCR = (1<<TWINT) | (1<<TWEN);
  while (!(TWCR & (1<<TWINT)));      // warten bis fertig
  if ((TWSR & 0xF8) != TWI_MTX_DATA_ACK)    // hats geklappt ?
    ERROR();


  TWDR = EEpromDaten;    // Daten(DATEN) an das EEPROM senden
  TWCR = (1<<TWINT) | (1<<TWEN);
  while (!(TWCR & (1<<TWINT)));      // warten bis fertig
  if ((TWSR & 0xF8) != TWI_MTX_DATA_ACK)    // hats geklappt ?
    ERROR();

  TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTO); // und STOP senden
  while(TWCR & (1<<TWSTO));    // warten bis fertig

  return 0;
}

Wenn du eeprom.c jetzt compilierst kommst du drauf:
Da sind ein Haufen Variablen undefiniert.
Jetzt rächt es sich, dass du sinnloserweise einen Haufen Variablen 
global gemacht hast, anstatt das gleich vernünftig anzugehen.

int EEpromDaten ;
int EEpromAdresse ;
int BasisAdresse1;
int BlockAdresse;
int Speicherzelle;
int BasisAdresse;

Was ist damit?
Einige der Variablen ( BasisAdresse1, BlockAdresse, Speicherzelle und 
Basisadresse) werden nur innerhalb der Funktion benötigt. Also macht man 
die auch funktionslokal. Andere deiner Variablen EEpromDaten und 
EEpromAdresse sind hingegen dafür zuständig, dass die Funktion mit 
Werten versorgt wird. Die werden zu Funktionsargumenten.
#include <avr/io.h>
#include <avr/twi.h>
#include "eeprom.h"

// General TWI Master staus codes
#define START 0x08

// TWI Master Transmitter staus codes
#define TWI_MTX_ADR_ACK    0x18  // SLA+W has been tramsmitted and ACK received
#define TWI_MTX_ADR_NACK  0x20  // SLA+W has been tramsmitted and NACK received
#define TWI_MTX_DATA_ACK  0x28  // Data byte has been tramsmitted and ACK received
#define TWI_MTX_DATA_NACK  0x30  // Data byte has been tramsmitted and NACK received

int EEPROM_SCHREIBEN ( int EEpromAdresse, int EEpromDaten )
{
  int BasisAdresse1;
  int BlockAdresse;
  int Speicherzelle;
  int BasisAdresse;

  BasisAdresse  = 0xA0;
  BlockAdresse  = EEpromAdresse/256;
  BasisAdresse1 = BasisAdresse + BlockAdresse * 2;
  Speicherzelle = EEpromAdresse%256;    // modulo

  TWSR = (0<<TWPS0) | (0<<TWPS1);     // Prescaler 1
  TWBR = 0x34;          // berechnung ergab 52


  TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTA);  // start senden
  while  (!(TWCR & (1<<TWINT)));      // warten bis fertig
  if ((TWSR & 0xF8) != START)
    ERROR();


  TWDR = BasisAdresse1  ;       // Controll BYTE fur 24c08  OxA1 = lesen !!
  TWCR = (1<<TWINT) | (1<<TWEN);
  while (!(TWCR & (1<<TWINT)));      // warten bis fertig
  if ((TWSR & 0xF8) != TWI_MTX_ADR_ACK)    // hats geklappt ?
    ERROR();


  TWDR = Speicherzelle;    // Daten(ADRERSSE) an das EEPROM senden
  TWCR = (1<<TWINT) | (1<<TWEN);
  while (!(TWCR & (1<<TWINT)));      // warten bis fertig
  if ((TWSR & 0xF8) != TWI_MTX_DATA_ACK)    // hats geklappt ?
    ERROR();


  TWDR = EEpromDaten;    // Daten(DATEN) an das EEPROM senden
  TWCR = (1<<TWINT) | (1<<TWEN);
  while (!(TWCR & (1<<TWINT)));      // warten bis fertig
  if ((TWSR & 0xF8) != TWI_MTX_DATA_ACK)    // hats geklappt ?
    ERROR();

  TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTO); // und STOP senden
  while(TWCR & (1<<TWSTO));    // warten bis fertig

  return 0;
}

Da sich die Funktionssignatur geändert hat, muss diese natürlich auch im 
Header File angepasst werden

eeprom.h
#ifndef EEPROM_H_INCLUDED
#define EEPROM_H_INCLUDED

int EEPROM_SCHREIBEN ( int EEpromAdresse, int EEpromDaten );

#endif


Erneutes compilieren von eeprom.c ergibt, dass eine Funktion ERROR 
aufgerufen wird. Das geht natürlich gar nicht. Wenn EEPROM_SCHREIBEN 
einen Fehler feststellt, dann soll sie das melden aber auf keinen Fall 
selbst eine Aktion unternehmen. Was im Fehlerfall geschehen soll obliegt 
der Verantwortung des Aufrufers der Funktion.

Du hast noch den Funktionsreturnwert. Und den benutzet du um einen 
Fehlercode zurückzugeben. Fürs erste reicht es völlig aus, wenn im 
Fehlerfall 0 (also logisch FALSE laut C-Konvention) bzw. 1 (also TRUE 
laut C-Konvention) zurückgegeben wird. FALSE steht dabei für Fehler, 
TRUE für Aktion ausgeführt. Damit kann dann der Aufrufer von 
EEPROM_SCHREIBEN auf einen Fehler so reagieren, wie es ihm richtig 
erscheint.
#include <avr/io.h>
#include <avr/twi.h>
#include "eeprom.h"

// General TWI Master staus codes
#define START 0x08

// TWI Master Transmitter staus codes
#define TWI_MTX_ADR_ACK    0x18  // SLA+W has been tramsmitted and ACK received
#define TWI_MTX_ADR_NACK  0x20  // SLA+W has been tramsmitted and NACK received
#define TWI_MTX_DATA_ACK  0x28  // Data byte has been tramsmitted and ACK received
#define TWI_MTX_DATA_NACK  0x30  // Data byte has been tramsmitted and NACK received

int EEPROM_SCHREIBEN ( int EEpromAdresse, int EEpromDaten )
{
  int BasisAdresse1;
  int BlockAdresse;
  int Speicherzelle;
  int BasisAdresse;

  BasisAdresse  = 0xA0;
  BlockAdresse  = EEpromAdresse/256;
  BasisAdresse1 = BasisAdresse + BlockAdresse * 2;
  Speicherzelle = EEpromAdresse%256;    // modulo

  TWSR = (0<<TWPS0) | (0<<TWPS1);     // Prescaler 1
  TWBR = 0x34;          // berechnung ergab 52


  TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTA);  // start senden
  while  (!(TWCR & (1<<TWINT)));      // warten bis fertig
  if ((TWSR & 0xF8) != START)
    return 0;


  TWDR = BasisAdresse1  ;       // Controll BYTE fur 24c08  OxA1 = lesen !!
  TWCR = (1<<TWINT) | (1<<TWEN);
  while (!(TWCR & (1<<TWINT)));      // warten bis fertig
  if ((TWSR & 0xF8) != TWI_MTX_ADR_ACK)    // hats geklappt ?
    return 0;


  TWDR = Speicherzelle;    // Daten(ADRERSSE) an das EEPROM senden
  TWCR = (1<<TWINT) | (1<<TWEN);
  while (!(TWCR & (1<<TWINT)));      // warten bis fertig
  if ((TWSR & 0xF8) != TWI_MTX_DATA_ACK)    // hats geklappt ?
    return 0;


  TWDR = EEpromDaten;    // Daten(DATEN) an das EEPROM senden
  TWCR = (1<<TWINT) | (1<<TWEN);
  while (!(TWCR & (1<<TWINT)));      // warten bis fertig
  if ((TWSR & 0xF8) != TWI_MTX_DATA_ACK)    // hats geklappt ?
    return 0;

  TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTO); // und STOP senden
  while(TWCR & (1<<TWSTO));    // warten bis fertig

  return 1;
}

Gut. Wenn ich jetzt nichts mehr übersehen habe, müsste eeprom.c 
eigentlich compilieren.

Wie verwendet man nun das Ganze?
zb so
// Mega 32
// CPU 12 MHz EEPROM 24c08 100 KHz
#include <stdlib.h>
#include <avr/io.h>
#include "eeprom.h"   // damit wird hier Bescheid gegeben, was das
                      // "EEPROM Modul" so alles kann.

#define F_CPU 12000000UL


int  ERROR (void)
{
  DDRA = 0xFF;
  PORTA = 0x01;
  while(1)
  {
     // Nüscht machen !
  }
  return 0;
}

int main (void)
{
  int Addr;

  for (Addr=0; Addr <= 1023; Addr++)
  {
    if( !EEPROM_SCHREIBEN( Addr, 0 ) )
      ERROR();
  }

  while(1)
  {
  }

  return 0;
}

In dein Projekt fügst du noch eeprom.c und eeprom.h mit ein.
Beim nächsten Build-Prozess werden eeprom.c compiliert, deien Haupt *.c 
wird compiliert und die Ergebnisse beider Übersetzungsvorgänge (eeprom.o 
und dein *.o) werden vom Linker zum Gesamtprogram zusammengefügt.

****************************************************
Im Grunde ist der Vorgang sehr simpel.
Du musst dich einfach nur von dem Prinzip leiten lassen:
Wenn eeprom.c für sich alleine compiliert wird, was braucht es alles 
dafür?
Und so baust du dann das *.c File dafür auf. Dazu noch ein Header File, 
welches vom Gedankengang getragen wird: Wenn jemand mein *.c verwenden 
will, was muss er alles wissen?
In deinem Fall ist die Sache einfach. Jemand der deine EEPROM 
Funktionalität benutzen will, muss nur wissen, dass es eine Funktion 
EEPROM_SCHREIBEN gibt. Mehr nicht. Er muss nicht wissen, dass du intern 
eine Variable BlockAdresse hast. Er muss nicht wissen, dass du eine 
Variable Speicherzelle hast, etc. All das ist in der Funktion 
EEPROM_SCHREIBEN verborgen und geht ausserhalb der Funktion niemanden 
etwas an.


PS: Bist du dir sicher, dass ein Datentyp von int für EEpromDaten 
sinnvoll ist?

Autor: Steffen A. (stigmer)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Karl heinz Buchegger schrieb:
> [...]

Sehr nice, Hut ab für solch eine Mühe! :)

Autor: Ingo Laabs (grobian)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo Karl Heinz
>>PS: Bist du dir sicher, dass ein Datentyp von int für EEpromDaten
sinnvoll ist?

unsigned int EEpromDaten...denke ich

ansonsten..hab vielen lieben dank für deine ausführliche Beschreibung.
Das ist genau das, was ich gesucht habe. Bin jetzt leider noch auf 
Arbeit aber werde es mir , wenn unser Steppke nicht wieder mit 
Badeanstalt um die Ecke kommt mir zu gemüte führen.
Kennst du evt. noch eine weiterführende Literatur die genau solch Dinge 
behandelt ?
Habehier zwar schon einige Bücher aber so ein speziellen Kram finde ich 
da immer nicht.

G Ingo

Autor: Ingo Laabs (grobian)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
ist irgendwie merkwürdig, was vor 2 Tagen noch ohne delay funftionierte, 
funktioniert jetzt nur noch mit delay im Hauptprogramm..wieso.
Ich warte doch die Stop-Bedingung vom EEprom ab bevor ich neu beschreibe


int EEPROM_SCHREIBEN (void)
{
  BasisAdresse = 0xA0;
    BlockAdresse = EEpromAdresse/256;
    BasisAdresse1 = BasisAdresse + BlockAdresse * 2;
    Speicherzelle = EEpromAdresse%256;

TWSR = (0<<TWPS0) | (0<<TWPS1);       // Prescaler 1
TWBR = 0x34;                // berechnung ergab 52


TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTA);  // start senden
while  (!(TWCR & (1<<TWINT)));        // warten bis fertig
if ((TWSR & 0xF8) != START)
ERROR();


TWDR = BasisAdresse1  ;            // Controll BYTE fur 24c08  OxA1 = 
lesen !!
TWCR = (1<<TWINT) | (1<<TWEN);
while (!(TWCR & (1<<TWINT)));        // warten bis fertig
if ((TWSR & 0xF8) != TWI_MTX_ADR_ACK)    // hats geklappt ?
ERROR();


TWDR = Speicherzelle;            // Daten(ADRERSSE) an das EEPROM senden
TWCR = (1<<TWINT) | (1<<TWEN);
while (!(TWCR & (1<<TWINT)));        // warten bis fertig
if ((TWSR & 0xF8) != TWI_MTX_DATA_ACK)    // hats geklappt ?
ERROR();


TWDR = EEPROM_DATEN;            // Daten(DATEN) an das EEPROM senden
TWCR = (1<<TWINT) | (1<<TWEN);
while (!(TWCR & (1<<TWINT)));        // warten bis fertig
if ((TWSR & 0xF8) != TWI_MTX_DATA_ACK)    // hats geklappt ?
ERROR();

TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTO); // und STOP senden
while(TWCR & (1<<TWSTO));          // warten bis fertig

return 0;
}
int main (void)
{

for (EEpromAdresse=0 ; EEpromAdresse <=1023 ; EEpromAdresse++)

  {
      EEPROM_DATEN = 0;
      EEPROM_SCHREIBEN();
      _delay_ms(10);
  }

while(1)
  {
    return 0;
  }
}

Autor: Lowtzow .... (lowtzow)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
@ Karl heinz Buchegger
auch von mir danke für das Tutorial ;-)

mfg

Autor: Steffen (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
:-)

Tolle Anleitung. Vielleicht hätte noch der Hinweis kommen können, dass 
komplette Großschreibung von Wörtern oftmals nicht für "normale" 
Funktionen verwendet wird (hier EEPROM_SCHREIBEN()) sondern dies für 
Makros (z.B. define-Ersetzungen) reserviert ist.

Steffen

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.