INFO: Dieses Forum nutzt Cookies...
Cookies sind für den Betrieb des Forums unverzichtbar. Mit der Nutzung des Forums erklärst Du dich damit einverstanden, dass wir Cookies verwenden.

Es wird in jedem Fall ein Cookie gesetzt um diesen Hinweis nicht mehr zu erhalten. Desweiteren setzen wir Google Adsense und Google Analytics ein.

Antwort schreiben 
 
Themabewertung:
  • 0 Bewertungen - 0 im Durchschnitt
  • 1
  • 2
  • 3
  • 4
  • 5
Mehrere Werte in Eeprom schreiben und auslesen
16.11.2014, 17:40
Beitrag #1
Mehrere Werte in Eeprom schreiben und auslesen
Hallo,
ich bin`s mal wieder und könnte eure Hilfe brauchen.
Bin dabei eine Temperaturregelung zu machen. Es soll der Einschalt- und Ausschaltwert mit 5 Tasten eingestellt werden. Taste 1 startet einen Interrupt und mit den vier anderen wird hoch oder runter getippt. Das funktioniert im Prinzip schon.
Nun wollte ich diese beiden Werte im Eeprom ablegen, damit sie bei Stromausfall oder so wieder eingelesen werden. Mit einem Wert speichern und auslesen klappt es,
aber wie kann ich beide Werte speichern und auslesen?????
Hier mal mein Code.
Code:
#include <LiquidCrystal.h>
#include <EEPROM.h>
int temp = 0;
int LED=13;
int lampe=6;
int an=0;
int aus = 0;
int caladr=1;
int speichern=0;
LiquidCrystal lcd(7, 8, 9, 10, 11, 12);
volatile unsigned long alteZeit=0, entprellZeit=20, cal=0;

void setup() {
  Serial.begin(38400);
  lcd.begin(16,2);
  pinMode(LED, OUTPUT);    // LED Pin
  pinMode(2, INPUT);       // Pin 2 ist INT0
  digitalWrite(2, HIGH);   // interner Pull up Widerstand auf 5V
  attachInterrupt(0, interruptRoutine, LOW);
  // Pin 2 (INT 0) geht auf LOW (0V) dann interruptRoutine aufrufen
  pinMode(A1,INPUT);          // Taste AN hoch  
  digitalWrite(A1,HIGH);      // interner pullup Widerstand
  pinMode(A2,INPUT);          // Taste AN runter
  digitalWrite(A2,HIGH);
  pinMode(A3,INPUT);          // Taste AUS hoch  
  digitalWrite(A3,HIGH);      // interner pullup Widerstand
  pinMode(A4,INPUT);          // Taste AUS runter
  digitalWrite(A4,HIGH);
  pinMode(lampe,OUTPUT);
  an=eepromReadInt(caladr); // Startwert aus dem EEPROM lesen
  aus=eepromReadInt(caladr); // Startwert aus dem EEPROM lesen
}

void loop() {
  //Interupt AN
  if(cal==1) {
    if(readButton(1)) an+=1; // Einschaltwert hoch
    if(readButton(2)) an-=1; // Einschaltwert runter
    lcd.clear();
    lcd.print ( "Einschalten: " );
    lcd.print ( an );
   delay ( 700 );
    if(readButton(3)) aus+=1; // Ausschaltwert hoch
    if(readButton(4)) aus-=1; // Ausschaltwert runter
    lcd.clear();
    lcd.print ( "Ausschalten: " );
    lcd.print ( aus );
    delay ( 700 );
    LcdClearLine(1);
    speichern=1; // Wert verändert, bei verlassen der cal > speichern
  }
  if(speichern==1) {            // Wert soll gespeichert werden
    eepromWriteInt(caladr, an);
    //eepromWriteInt(caladr, an);
    speichern=0;                // Wert wurde gespeichert
  }
  int tempReading = analogRead(temp);
  float tempVolts = tempReading * 1.6 / 1024.0;
  float temp = (tempVolts - 0.5) * 100.0;
  if (temp <=an )
  digitalWrite(lampe,HIGH);
  Serial.println(an);
  //LcdClearLine(1);
  lcd.setCursor(0,0);
  lcd.print("Temp.:");
  lcd.print(temp);
  lcd.write(223);
  lcd.print("C");
  lcd.setCursor(0,1);
  lcd.print("Heizung:");
  lcd.print(an);
  lcd.print ( " / " );
  lcd.print(aus);
  delay(1000);
}
int readButton(int pin) {     // Taste einlesen
  if(analogRead(pin) < 500) { // Analog Eingang abfragen
    delay(entprellZeit);            
    if(analogRead(pin) < 500)
      return 1;               // war gedrückt
  }
  return 0;                   // war nicht gedrückt
}
void interruptRoutine() {
  if((millis() - alteZeit) > entprellZeit) {
    // innerhalb der entprellZeit nichts machen
    digitalWrite(LED, !digitalRead(LED)); // LED umschalten
    alteZeit = millis(); // letzte Schaltzeit merken
    cal = !cal; // Einstellmodus wechseln  
  }
}
int eepromReadInt(int adr) {  
// Integer aus dem EEPROM lesen
byte low, high;
  low=EEPROM.read(adr);
  high=EEPROM.read(adr+1);
  return low + ((high << 8)&0xFF00);
} //eepromReadInt
void eepromWriteInt(int adr, int wert) {
// Integer in das EEPROM schreiben
byte low, high;
  low=wert&0xFF;
  high=(wert >> 8)&0xFF;
  EEPROM.write(adr, low); // dauert 3,3ms
  EEPROM.write(adr+1, high);
  return;
}
// hilfsfunktion zum leeren einer zeile
void LcdClearLine(int r)
{
  lcd.setCursor(0,r);
  for (int i = 0; i < 16; i = i + 1)
  {
    lcd.print("            ");
  }
}

Danke
Bernd
Webseite des Benutzers besuchen Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
16.11.2014, 18:27 (Dieser Beitrag wurde zuletzt bearbeitet: 16.11.2014 18:47 von nettworker.)
Beitrag #2
RE: Mehrere Werte in Eeprom schreiben und auslesen
Was hindert dich daran die Werte einfach zu lesen und zu schreiben, wie es in den Beispielen unter EEPROM gemacht wird?
Code:
// Wert wegscheiben:
// EEPROM.write(addr, val);
EEPROM.write(0, 1); // 1 bis 255
EEPROM.write(1, 1); // 1 bis 255

// Wert lesen:
// value = EEPROM.read(address);
an = EEPROM.read(0);
aus = EEPROM.read(1);

(16.11.2014 17:40)Kurt schrieb:  Hallo,
ich bin`s mal wieder und könnte eure Hilfe brauchen.
Bin dabei eine Temperaturregelung zu machen. Es soll der Einschalt- und Ausschaltwert mit 5 Tasten eingestellt werden. Taste 1 startet einen Interrupt und mit den vier anderen wird hoch oder runter getippt. Das funktioniert im Prinzip schon.
Nun wollte ich diese beiden Werte im Eeprom ablegen, damit sie bei Stromausfall oder so wieder eingelesen werden. Mit einem Wert speichern und auslesen klappt es,
aber wie kann ich beide Werte speichern und auslesen?????
Hier mal mein Code.
Code:
#include <LiquidCrystal.h>
#include <EEPROM.h>
int temp = 0;
int LED=13;
int lampe=6;
int an=0;
int aus = 0;
int caladr=1;
int speichern=0;
LiquidCrystal lcd(7, 8, 9, 10, 11, 12);
volatile unsigned long alteZeit=0, entprellZeit=20, cal=0;

void setup() {
  Serial.begin(38400);
  lcd.begin(16,2);
  pinMode(LED, OUTPUT);    // LED Pin
  pinMode(2, INPUT);       // Pin 2 ist INT0
  digitalWrite(2, HIGH);   // interner Pull up Widerstand auf 5V
  attachInterrupt(0, interruptRoutine, LOW);
  // Pin 2 (INT 0) geht auf LOW (0V) dann interruptRoutine aufrufen
  pinMode(A1,INPUT);          // Taste AN hoch  
  digitalWrite(A1,HIGH);      // interner pullup Widerstand
  pinMode(A2,INPUT);          // Taste AN runter
  digitalWrite(A2,HIGH);
  pinMode(A3,INPUT);          // Taste AUS hoch  
  digitalWrite(A3,HIGH);      // interner pullup Widerstand
  pinMode(A4,INPUT);          // Taste AUS runter
  digitalWrite(A4,HIGH);
  pinMode(lampe,OUTPUT);
  an=eepromReadInt(caladr); // Startwert aus dem EEPROM lesen
  aus=eepromReadInt(caladr); // Startwert aus dem EEPROM lesen
}

void loop() {
  //Interupt AN
  if(cal==1) {
    if(readButton(1)) an+=1; // Einschaltwert hoch
    if(readButton(2)) an-=1; // Einschaltwert runter
    lcd.clear();
    lcd.print ( "Einschalten: " );
    lcd.print ( an );
   delay ( 700 );
    if(readButton(3)) aus+=1; // Ausschaltwert hoch
    if(readButton(4)) aus-=1; // Ausschaltwert runter
    lcd.clear();
    lcd.print ( "Ausschalten: " );
    lcd.print ( aus );
    delay ( 700 );
    LcdClearLine(1);
    speichern=1; // Wert verändert, bei verlassen der cal > speichern
  }
  if(speichern==1) {            // Wert soll gespeichert werden
    eepromWriteInt(caladr, an);
    //eepromWriteInt(caladr, an);
    speichern=0;                // Wert wurde gespeichert
  }
  int tempReading = analogRead(temp);
  float tempVolts = tempReading * 1.6 / 1024.0;
  float temp = (tempVolts - 0.5) * 100.0;
  if (temp <=an )
  digitalWrite(lampe,HIGH);
  Serial.println(an);
  //LcdClearLine(1);
  lcd.setCursor(0,0);
  lcd.print("Temp.:");
  lcd.print(temp);
  lcd.write(223);
  lcd.print("C");
  lcd.setCursor(0,1);
  lcd.print("Heizung:");
  lcd.print(an);
  lcd.print ( " / " );
  lcd.print(aus);
  delay(1000);
}
int readButton(int pin) {     // Taste einlesen
  if(analogRead(pin) < 500) { // Analog Eingang abfragen
    delay(entprellZeit);            
    if(analogRead(pin) < 500)
      return 1;               // war gedrückt
  }
  return 0;                   // war nicht gedrückt
}
void interruptRoutine() {
  if((millis() - alteZeit) > entprellZeit) {
    // innerhalb der entprellZeit nichts machen
    digitalWrite(LED, !digitalRead(LED)); // LED umschalten
    alteZeit = millis(); // letzte Schaltzeit merken
    cal = !cal; // Einstellmodus wechseln  
  }
}
int eepromReadInt(int adr) {  
// Integer aus dem EEPROM lesen
byte low, high;
  low=EEPROM.read(adr);
  high=EEPROM.read(adr+1);
  return low + ((high << 8)&0xFF00);
} //eepromReadInt
void eepromWriteInt(int adr, int wert) {
// Integer in das EEPROM schreiben
byte low, high;
  low=wert&0xFF;
  high=(wert >> 8)&0xFF;
  EEPROM.write(adr, low); // dauert 3,3ms
  EEPROM.write(adr+1, high);
  return;
}
// hilfsfunktion zum leeren einer zeile
void LcdClearLine(int r)
{
  lcd.setCursor(0,r);
  for (int i = 0; i < 16; i = i + 1)
  {
    lcd.print("            ");
  }
}

Danke
Bernd
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
16.11.2014, 22:43
Beitrag #3
RE: Mehrere Werte in Eeprom schreiben und auslesen
Hallo nettworker,

wenn das so einfach für mich wäre, würde ich nicht fragen.
Das hier:
// Wert wegscheiben:
// EEPROM.write(addr, val);
EEPROM.write(0, 1); // 1 bis 255
EEPROM.write(1, 1); // 1 bis 255

// Wert lesen:
// value = EEPROM.read(address);
an = EEPROM.read(0);
aus = EEPROM.read(1);
leuchtet mir zwar ein, aber wie ich meinen Code dafür umstellen muss - keine Ahnung.
So ein Profi bin ich eben noch nicht.
Webseite des Benutzers besuchen Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
16.11.2014, 22:58 (Dieser Beitrag wurde zuletzt bearbeitet: 16.11.2014 23:04 von nettworker.)
Beitrag #4
RE: Mehrere Werte in Eeprom schreiben und auslesen
Was willst du denn abspeichern, eine 0 für aus und eine 1 für an?

Dann ist das so einfach.
Code:
EEPROM.write(0, 1)
speichert im ersten Byte des EEPROM (0) den Wert 1. Zählweise, bzw. Index der Bytes im EEPROM wie fast überall bei 0 beginnend.
Und
Code:
an = EEPROM.read(0)
liest vom ersten Byte im EEPROM den Wert in die Variable an ein.

Datei -> Beispiele -> EEPROM -> eeprom_read
Datei -> Beispiele -> EEPROM -> eeprom_write
Datei -> Beispiele -> EEPROM -> eeprom_clear


(16.11.2014 22:43)Kurt schrieb:  Hallo nettworker,

wenn das so einfach für mich wäre, würde ich nicht fragen.
Das hier:
// Wert wegscheiben:
// EEPROM.write(addr, val);
EEPROM.write(0, 1); // 1 bis 255
EEPROM.write(1, 1); // 1 bis 255

// Wert lesen:
// value = EEPROM.read(address);
an = EEPROM.read(0);
aus = EEPROM.read(1);
leuchtet mir zwar ein, aber wie ich meinen Code dafür umstellen muss - keine Ahnung.
So ein Profi bin ich eben noch nicht.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
17.11.2014, 00:24
Beitrag #5
RE: Mehrere Werte in Eeprom schreiben und auslesen
(16.11.2014 17:40)Kurt schrieb:  Hallo,
ich bin`s mal wieder und könnte eure Hilfe brauchen.
Bin dabei eine Temperaturregelung zu machen. Es soll der Einschalt- und Ausschaltwert mit 5 Tasten eingestellt werden. Taste 1 startet einen Interrupt und mit den vier anderen wird hoch oder runter getippt. Das funktioniert im Prinzip schon.
Nun wollte ich diese beiden Werte im Eeprom ablegen, damit sie bei Stromausfall oder so wieder eingelesen werden. Mit einem Wert speichern und auslesen klappt es,
aber wie kann ich beide Werte speichern und auslesen?????
Hier mal mein Code.
Code:
#include <LiquidCrystal.h>
#include <EEPROM.h>
int temp = 0;
int LED=13;
int lampe=6;
int an=0;
int aus = 0;
int caladr=1;
int speichern=0;
LiquidCrystal lcd(7, 8, 9, 10, 11, 12);
volatile unsigned long alteZeit=0, entprellZeit=20, cal=0;

void setup() {
  Serial.begin(38400);
  lcd.begin(16,2);
  pinMode(LED, OUTPUT);    // LED Pin
  pinMode(2, INPUT);       // Pin 2 ist INT0
  digitalWrite(2, HIGH);   // interner Pull up Widerstand auf 5V
  attachInterrupt(0, interruptRoutine, LOW);
  // Pin 2 (INT 0) geht auf LOW (0V) dann interruptRoutine aufrufen
  pinMode(A1,INPUT);          // Taste AN hoch  
  digitalWrite(A1,HIGH);      // interner pullup Widerstand
  pinMode(A2,INPUT);          // Taste AN runter
  digitalWrite(A2,HIGH);
  pinMode(A3,INPUT);          // Taste AUS hoch  
  digitalWrite(A3,HIGH);      // interner pullup Widerstand
  pinMode(A4,INPUT);          // Taste AUS runter
  digitalWrite(A4,HIGH);
  pinMode(lampe,OUTPUT);
  an=eepromReadInt(caladr); // Startwert aus dem EEPROM lesen
  aus=eepromReadInt(caladr); // Startwert aus dem EEPROM lesen
}

void loop() {
  //Interupt AN
  if(cal==1) {
    if(readButton(1)) an+=1; // Einschaltwert hoch
    if(readButton(2)) an-=1; // Einschaltwert runter
    lcd.clear();
    lcd.print ( "Einschalten: " );
    lcd.print ( an );
   delay ( 700 );
    if(readButton(3)) aus+=1; // Ausschaltwert hoch
    if(readButton(4)) aus-=1; // Ausschaltwert runter
    lcd.clear();
    lcd.print ( "Ausschalten: " );
    lcd.print ( aus );
    delay ( 700 );
    LcdClearLine(1);
    speichern=1; // Wert verändert, bei verlassen der cal > speichern
  }
  if(speichern==1) {            // Wert soll gespeichert werden
    eepromWriteInt(caladr, an);
    //eepromWriteInt(caladr, an);
    speichern=0;                // Wert wurde gespeichert
  }
  int tempReading = analogRead(temp);
  float tempVolts = tempReading * 1.6 / 1024.0;
  float temp = (tempVolts - 0.5) * 100.0;
  if (temp <=an )
  digitalWrite(lampe,HIGH);
  Serial.println(an);
  //LcdClearLine(1);
  lcd.setCursor(0,0);
  lcd.print("Temp.:");
  lcd.print(temp);
  lcd.write(223);
  lcd.print("C");
  lcd.setCursor(0,1);
  lcd.print("Heizung:");
  lcd.print(an);
  lcd.print ( " / " );
  lcd.print(aus);
  delay(1000);
}
int readButton(int pin) {     // Taste einlesen
  if(analogRead(pin) < 500) { // Analog Eingang abfragen
    delay(entprellZeit);            
    if(analogRead(pin) < 500)
      return 1;               // war gedrückt
  }
  return 0;                   // war nicht gedrückt
}
void interruptRoutine() {
  if((millis() - alteZeit) > entprellZeit) {
    // innerhalb der entprellZeit nichts machen
    digitalWrite(LED, !digitalRead(LED)); // LED umschalten
    alteZeit = millis(); // letzte Schaltzeit merken
    cal = !cal; // Einstellmodus wechseln  
  }
}
int eepromReadInt(int adr) {  
// Integer aus dem EEPROM lesen
byte low, high;
  low=EEPROM.read(adr);
  high=EEPROM.read(adr+1);
  return low + ((high << 8)&0xFF00);
} //eepromReadInt
void eepromWriteInt(int adr, int wert) {
// Integer in das EEPROM schreiben
byte low, high;
  low=wert&0xFF;
  high=(wert >> 8)&0xFF;
  EEPROM.write(adr, low); // dauert 3,3ms
  EEPROM.write(adr+1, high);
  return;
}
// hilfsfunktion zum leeren einer zeile
void LcdClearLine(int r)
{
  lcd.setCursor(0,r);
  for (int i = 0; i < 16; i = i + 1)
  {
    lcd.print("            ");
  }
}

Danke
Bernd

Hallo Kurt,
was mir in deiner Leseroutine auffällt ist die Maske mit dem "& 0xFF00" die eigentlich nicht nötig ist. und das high und low zusammensetzen könnte man auch mal mit dem Oder "|" versuchen was ich sinnvoller halte.
Im setup holst du Zweimal den gleichen Wert ab:
an=eepromReadInt(caladr); // Startwert aus dem EEPROM lesen
aus=eepromReadInt(caladr); // Startwert aus dem EEPROM lesen
ist das richtig so ? ich hätte da zwischendrin eine Wertänderung von caladr erwartet. Und ein kleiner Hinweis zur EEPROM Adresse, die fängt mit 0 an.
Hoffe mal das da deine Fehler versenkt sind.
lg
bk

1+1 = 10 Angel ...und ich bin hier nicht der Suchmaschinen-Ersatz Dodgy...nur mal so als genereller Tipp..
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
17.11.2014, 07:58
Beitrag #6
RE: Mehrere Werte in Eeprom schreiben und auslesen
Danke für eure Antworten.
Abspeichern will ich die Ein-und Ausschaltwerte die ich mit den Tastern 2-4 einstelle.
Das sind Werte zwischen 0 und 25. Den Code habe ich im Netz gefunden. Ursprunglich ist der für 3 Taste gedacht(Taste 1 für Interrupt und Tasten 2-3 zum
hoch und runtertippen eines Wertes. Ich habe versucht den umzustellen für 2 Werte.
Ob das hier richtig ist:
an=eepromReadInt(caladr); // Startwert aus dem EEPROM lesen
aus=eepromReadInt(caladr); // Startwert aus dem EEPROM lesen
weiß ich ja selbst nicht. Die 2. Zeile hab ich eingefügt.

Bernd
Webseite des Benutzers besuchen Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
17.11.2014, 09:03
Beitrag #7
RE: Mehrere Werte in Eeprom schreiben und auslesen
Hallo Kurt,

du kannst auch mehrere Werte auch in eine Struktur packen (ist so eine Art Array mit verschiedenen (oder auch gleichen) Datentypen pro Datensatz) und bei aktuellen Versionen der IDE nach folgendem Beispiel vorgehen:
Code:
#include <avr/eeprom.h>
// Die Struktur mit den Daten
struct settings_t
{
  long alarm;
  int mode;
} settings;
// die Struktur aus dem EEPROM lesen
  eeprom_read_block((void*)&settings, (void*)0, sizeof(settings));
// Die Struktur in den EEPROM schreiben
   eeprom_write_block((const void*)&settings, (void*)0, sizeof(settings));
Grüße Ricardo
PS: Die Bemerkungen von nettworker bzw. Bitklopfer solltest du natürlich trotzdem beachten

Nüchtern betrachtet...ist besoffen besser Big Grin
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
17.11.2014, 10:25
Beitrag #8
RE: Mehrere Werte in Eeprom schreiben und auslesen
Hallo Ricardo,
schön dich hier mal wieder zu lesen...hattest Urlaub im Webfreien Raum ?
Dieses Blockweise lesen und schreiben vom EEPROM ist aber nur in der AVR Lib enthalten und nicht in der EEPROM Lib von der Arduino IDE - richtig so ?

@Kurt, also wenn du nur Werte zwischen 0 und 25 im EEPROM ablegen willst dann kannst aus den Variablen an und aus auch gleich eine vom Typ byte machen da der ganze Prozessor Byte orientiert ist brauchst dann keine Klimmzüge mit dem zusammenbasteln eines Integers zu machen, das liest sich dann so:

Code:
// Integer aus dem EEPROM lesen
int eepromReadByte(int adr) {  
byte low;
  low=EEPROM.read(adr);
  return low;
} //eepromReadByte

// Integer in das EEPROM schreiben
void eepromWriteByte(int adr, byte wert) {
  EEPROM.write(adr, wert); // dauert 3,3ms
}

..damit wird die Sache viel übersichtlicher.

Aber beim Wert an und aus solltest du nach der Tasterabfrage dann eine Wertebegrenzung einfügen das der Wert deine min und max Werte nicht über oder unterschreitet.

Bei dem Aufruf von readButton kannst du als pin auch eine Bytevariable einsetzen die da völlig ausreicht und das System ist etwas schneller dadurch. An der Stelle ist mir auch aufgefallen das du mit analogRead arbeitest...analogRead greift üblicherweise auf die Analogeingänge A0 - A5 zu und nicht auf auf die DigitalPorts 0 - X . Also wenn du wirklich deine Tasten auf den Analogeingängen hast dann solltes du im Aufruf auch AX angeben. Allerdings habe ich es noch nicht versucht bei einem Analogeingang der auch so verwendet wird den Pull Up Widerstand zu benutzen. Wäre in dem Fall aber eine schöne Sache.

Noch was zum häufigen schreiben aufs EEPROM, eine Speicherzelle dort hält maximal 10.000 Schreibzyklen aus laut Datenblatt. Deshalb wäre es sinnvoll sich eine Strategie auszudenken das das EEPROM nicht nach jedem Tastendruck beschrieben wird sondern vielleicht erst nach 2 Sekunden nach dem letzten Tastendruck und vor dem schreiben erst mal die Speicherstelle auslesen und überprüfen ob sich was geändert hat....und ERST dann schreiben.

lg
bk

1+1 = 10 Angel ...und ich bin hier nicht der Suchmaschinen-Ersatz Dodgy...nur mal so als genereller Tipp..
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
Antwort schreiben 


Möglicherweise verwandte Themen...
Thema: Verfasser Antworten: Ansichten: Letzter Beitrag
  Mit dem Arduino JSON Webseiten auslesen seb201 3 97 05.12.2016 22:25
Letzter Beitrag: Tommy56
  Data Logger Daten auf SD Card schreiben Crichton 12 312 22.11.2016 18:32
Letzter Beitrag: Crichton
  Messchieber auslesen mit nem UNO roadcaptain 8 317 15.11.2016 14:30
Letzter Beitrag: Tommy56
  U-blox Neo 6M GPS auslesen Matthias_Arduino 15 878 09.11.2016 16:40
Letzter Beitrag: AvrRobot
  mehrere Taster entprellen Kitt 15 528 24.10.2016 21:17
Letzter Beitrag: georg01
  mit Attiny85 Feuchtigkeitssensor auslesen toto1975 17 579 19.08.2016 22:40
Letzter Beitrag: hotsystems
  Taster für mehrere Funktionen matthias3579 5 353 16.08.2016 16:00
Letzter Beitrag: StephanBuerger
  Serial Monitor ASCII 1 schreiben BennIY 11 581 01.08.2016 16:42
Letzter Beitrag: Mathias
  Gewichteten Durchschnitt berechnen, 20 Werte in fortlaufender Variable speichern TimeMen 10 476 03.07.2016 09:00
Letzter Beitrag: Binatone
  Ausgabe druckt immer 2 Werte anstatt nur einen. Finde den Fehler nicht TimeMen 24 744 02.07.2016 14:18
Letzter Beitrag: hotsystems

Gehe zu:


Benutzer, die gerade dieses Thema anschauen: 1 Gast/Gäste