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
Daten Byte,Word,Int ans EE-Prom Senden
10.12.2014, 23:05
Beitrag #1
Daten Byte,Word,Int ans EE-Prom Senden
Hallo.
Ich Beschaeftige mich seit ca. 1/2Jahr mit dem Arduino.
Der Vorteil ist, das man den Arduino unabhaengig vom PC betreiben kann.
Um Abgleichwerte oder Configurationswerte bei Reset oder Spannungswiederkehr nicht neu eingeben zu muessen,
kam ich auf die Idee, diese Werte auf dem EE-Prom zu hinterlegen. Bei Netzausfall oder Reset werden diese Werte
aus dem EE-Prom wieder eingeladen und benutzt.
Im Moment habe ich 3 Programme die mit meinem Geräten arbeiten.
Arduino Mega-2560, Lapptop mit Win-7, Werteeingabe ueber den Serial-Monitor der IDE.
Programm 1: Eingabe von Byte-Werten. Werte 0-255.
Programm 2. Eingabe von Word-Werten. Werte 0-65535
Programm 3: Eingabe von Long-Werten. Werte von + 2.147.483.647 bis - 2.147.483.648
In den Programmen koennen 4 Werte eingegeben werden. Als Zuordnung fuer die Werte 1-4 werden die Buchstaben
A B C D benutzt. Die Eingaben koennen durch Komma getrennt werden.
Die Anzahl der Eingaben können vergrößert oder verkleinert werden. Das Programm muss dann angepaßt werden.
Bei Eingabe von 'e' werden die Werte ins EE-Prom geschrieben.
Bei Eingabe von 'g' werden Grundwerte, die im Programm festgelegt werden koennen, ins EE-Prom geschrieben.
Bei Eingabe von 'v' werden die Eingabewerte in die Variablen aber nicht ins EE-Prom geschrieben.
Wird z.B e,v,z eingegeben werden die Eingabewerte ins EE-Prom und in die Variablen geschrieben.
'z' muss als letzter Befehl eingegeben werden sonst werden die Eingabewerte nicht bearbeitet.
Nachfolgend ein Eingabestring fuer das Programm 3. Integerwerte +/-
A20000005,B-2000254163,C-123000,D1000000,vz Werte nach Variablen
A20000005,B-2000254163,C-123000,D1000000,evz Werte nach Variablen und EE-Prom
C123456,vz Es wird nur Variable 3 geaendert, Die Variablen 1,2,4 bleiben unveraendert.
gz Es werden die Grundwerte wieder ins EE-Prom geschrieben.
Ich habe nur Befehle verwendet, die in der Hilfe, Referenz angegeben wurden. Man kann wahrscheinlich vieles
einfacher programmieren, es soll aber für Neueinsteiger nachvollziehbar sein.
Viel Glueck dabei.
Ps. bin dabei auch Gleitpunktzahlen zu benutzen und die ins EE-Prom zu schreiben und wieder auszulesen.
Kann mir einer einen Tip geben ??
Code:
#include <EEPROM.h>
// -----------------------------------------------------------
byte Werte[5]; // Monitor Eingabewerte
byte Index = 0; // Index Eingabewert
byte M2 = 0;     // Bit-Merker fuer e,g,s
byte i = 0;     // Schleifenzaehler fuer For-Next
String Nullen = " ";
byte Var_1 = 0;  // Variable Eingabe 1 als Byte
byte Var_2 = 0;  // Variable Eingabe 2 als Byte
byte Var_3 = 0;  // Variable Eingabe 3 als Byte
byte Var_4 = 0;  // Variable Eingabe 4 als Byte
byte M0 = 0;
// ###########################################################
void setup() {
  Serial.begin(115200);        // Schnittstelle bit/Sekunde
  EE_Prom_Werte_Lesen_Byte();  // Configurationswerte Laden
}  
// ###########################################################
void loop() {
  if (Serial.available()) {
    NeueWerte_Byte();
  }
   Serial.print(" EE-PROM 1=   "); Serial.print (EEPROM.read(1));  
   Serial.print(" EE-PROM 2=   "); Serial.print (EEPROM.read(2));  
   Serial.print(" EE-PROM 3=   "); Serial.print (EEPROM.read(3));  
   Serial.print(" EE-PROM 4=   "); Serial.println (EEPROM.read(4));
   Serial.print(" Var 1=   "); Serial.print  (Var_1);
   Serial.print(" Var 2=   "); Serial.print  (Var_2);
   Serial.print(" Var 3=   "); Serial.print  (Var_3);
   Serial.print(" Var 4=   "); Serial.println(Var_4);
   delay(1000);
}
// ###########################################################
void EE_Prom_Werte_Lesen_Byte() {
  Var_1 = EEPROM.read(1);
  Var_2 = EEPROM.read(2);
  Var_3 = EEPROM.read(3);
  Var_4 = EEPROM.read(4);
  Serial.println(" Alte Werte eingeladen ");
}  
// ###########################################################
void EE_Prom_Werte_Schreiben_Byte() {
  EEPROM.write(1, Werte[1]);
  EEPROM.write(2, Werte[2]);
  EEPROM.write(3, Werte[3]);
  EEPROM.write(4, Werte[4]);
  Serial.println(" Werte nach EE-Prom Geschrieben ");
}
//############################################################
void EE_Prom_Grundwerte_Schreiben_Byte() { // ,g, Grundwerte
  EEPROM.write(1, 10); // Grundwerte individuell
  EEPROM.write(2, 20);
  EEPROM.write(3, 30);
  EEPROM.write(4, 40);
  Serial.println(" Grundwerte gespeichert");
}    
//############################################################
void NeueWerte_Byte() {     // Eingabe von Byte " 8 Bit "
  delayMicroseconds(100);   // Zeit evtl. anpassen
  while (Serial.available() > 0)
  {
    char ch = Serial.read();
    delayMicroseconds(200);   // Zeit evtl. anpassen
    if (ch == 'A') Index = 1; // Wert 1
    if (ch == 'B') Index = 2; // Wert 2
    if (ch == 'C') Index = 3; // Wert 3
    if (ch == 'D') Index = 4; // Wert 4
    if (ch >= '0' && ch <= '9') {
      Werte[Index] = (Werte[Index] * 10) + (ch - '0'); // Zahlen 0-9
    }
    if (ch == 'e') bitSet(M2, 0); // Wenn 'e' nach EE-Prom schreiben
    if (ch == ',' || ch == ' ') byte x = 0; // Dummy
    if (ch == 'g') bitSet(M2, 1); // Wenn 'g' Grundwerte speichern
    if (ch == 'v') bitSet(M2, 2); // Wenn 'v' Werte nach Variablen
    if (ch == 'z')  { // z letztes Zeichen im Eingabestring
      if (bitRead(M2, 0) == 1) EE_Prom_Werte_Schreiben_Byte();
      if (bitRead(M2, 1) == 1) EE_Prom_Grundwerte_Schreiben_Byte();
      if (bitRead(M2, 2) == 1) {  // Werte nach Config Variablen
        if (Werte[1] != 0) Var_1 = Werte[1]; // Werte ungleich 0
        if (Werte[2] != 0) Var_2 = Werte[2]; // neue Werte
        if (Werte[3] != 0) Var_3 = Werte[3];
        if (Werte[4] != 0) Var_4 = Werte[4];
        Serial.println(" Neue Werte ");
      }  
    }
  }
  for(i=0; i <= 9; i++) Werte[i] = 0;
  Index = 0;
  M2 = 0;
  Serial.println(" Werte uebernommen");
}
// ###########################################################
Code:
#include <EEPROM.h>
// --------------------------------------------------------------------------------
word Werte[10]; // Monitor Eingabewerte
byte Index = 0; // Index Eingabewert
byte M2 = 0;    // Bit-Merker fuer e,g,s
byte i = 0;     // Schleifenzaehler fuer For-Next
String Nullen = " ";
word Var_1 = 0;  // Variable Eingabe 1 als Word
word Var_2 = 0;  // Variable Eingabe 2 als Word
word Var_3 = 0;  // Variable Eingabe 3 als Word
word Var_4 = 0;  // Variable Eingabe 4 als Word
// ################################################################################​
void setup() {
  Serial.begin(115200);                   // Schnittstelle bit/Sekunde
  EE_Prom_Werte_Lesen_Word();  // Configurationswerte Laden
}  
// ################################################################################​
void loop() {
  if (Serial.available()) {
    NeueWerte_Word();
  }
   Serial.print("  Var 1=  "); Serial.print  (Var_1);
   Serial.print("  Var 2=  "); Serial.print  (Var_2);
   Serial.print("  Var 3=  "); Serial.print  (Var_3);
   Serial.print("  Var 4=  "); Serial.println(Var_4);
   delay(1000);
}
// ################################################################################​
void EE_Prom_Werte_Lesen_Word() {
  Var_1 = 0; // ............................................................
  Var_1 = EEPROM.read(1);
  Var_1 = Var_1 << 8;
  Var_1 =Var_1 | EEPROM.read(2);
  Var_2 = 0; // ............................................................
  Var_2 = EEPROM.read(3);
  Var_2 = Var_2 << 8;
  Var_2 =Var_2 | EEPROM.read(4);
  Var_3 = 0; // ............................................................
  Var_3 = EEPROM.read(5);
  Var_3 = Var_3 << 8;
  Var_3 =Var_3 | EEPROM.read(6);
  Var_4 = 0; // ............................................................
  Var_4 = EEPROM.read(7);
  Var_4 = Var_4 << 8;
  Var_4 =Var_4 | EEPROM.read(8);
   Serial.println(" Alte Werte eingeladen ");
}  
// ################################################################################​
void EE_Prom_Werte_Schreiben_Word() {
  EEPROM.write(1, highByte(Werte[1]));
  EEPROM.write(2, lowByte (Werte[1]));
  EEPROM.write(3, highByte(Werte[2]));
  EEPROM.write(4, lowByte (Werte[2]));
  EEPROM.write(5, highByte(Werte[3]));
  EEPROM.write(6, lowByte (Werte[3]));
  EEPROM.write(7, highByte(Werte[4]));
  EEPROM.write(8, lowByte (Werte[4]));
  Serial.println(" Werte nach EE-Prom Geschrieben ");
}
//################################################################################​#
void EE_Prom_Grundwerte_Schreiben_Word() {              // bei ,g, Grundwerte setzen
  EEPROM.write(1, highByte(21840));// Werte anpassen
  EEPROM.write(2, lowByte (21840));
  EEPROM.write(3, highByte(21841));
  EEPROM.write(4, lowByte (21841));
  EEPROM.write(5, highByte(21842));
  EEPROM.write(6, lowByte (21842));
  EEPROM.write(7, highByte(21843));
  EEPROM.write(8, lowByte (21843));
  Serial.println(" Grundwerte gespeichert");
}    
//################################################################################​#
void NeueWerte_Word() {                // Eingabe von Byte " 8 Bit "
  delayMicroseconds(100);   // Zeit evtl. anpassen
  while (Serial.available() > 0)
  {
    char ch = Serial.read();
    delayMicroseconds(200);   // Zeit evtl. anpassen    
    if (ch == 'A') Index = 1; // Wert 1
    if (ch == 'B') Index = 2; // Wert 2
    if (ch == 'C') Index = 3; // Wert 3
    if (ch == 'D') Index = 4; // Wert 4
    if (ch >= '0' && ch <= '9') {
       Werte[Index] = (Werte[Index] * 10) + (ch - '0');  // Zahlen 0-9
    }
    if (ch == 'e') bitSet(M2, 0); // Wenn 'e' 1= nach EE-Prom schreiben
    if (ch == ',' || ch == ' ') byte x = 0; // Dummy
    if (ch == 'g') bitSet(M2, 1); // Wenn 'g' 2= Grundwerte speichern
    if (ch == 'v') bitSet(M2, 2); // Wenn 'v' 4= Werte nach Config Variablen
    if (ch == 'z')  { // z letztes Zeichen im Eingabestring
      if (bitRead(M2, 0) == 1) EE_Prom_Werte_Schreiben_Word();
      if (bitRead(M2, 1) == 1) EE_Prom_Grundwerte_Schreiben_Word();
      if (bitRead(M2, 2) == 1) {  // Werte nach Config Variablen
        if (Werte[1] != 0) Var_1 = Werte[1]; // Werte > 0 neue Werte uebernehmen
        if (Werte[2] != 0) Var_2 = Werte[2];
        if (Werte[3] != 0) Var_3 = Werte[3];
        if (Werte[4] != 0) Var_4 = Werte[4];
        Serial.print(" Neue Werte "); Serial.print(" Index "); Serial.println(Index);
      }  
    }               // Serial.flush() ?????
  }
  for(i=0; i <= 9; i++) Werte[i] = 0;
  Index = 0;
  M2 = 0;
  Serial.println(" Werte uebernommen");
}
// ################################################################################​
#include <EEPROM.h>
// --------------------------------------------------------------------------------
long Werte[10]; // Monitor Eingabewerte
byte Index = 0; // Index Eingabewert
byte Vorz[10]; // Vorzeichen des Eingabewert
byte M2 = 0; // Bit-Merker fuer e,g,s
byte i = 0; // Schleifenzaehler fuer For-Next
String Nullen = " ";
long Var_1 = 0; // Variable Eingabe 1 als Long
long Var_2 = 0; // Variable Eingabe 2 als Long
long Var_3 = 0; // Variable Eingabe 3 als Long
long Var_4 = 0; // Variable Eingabe 4 als Long
// ################################################################################​
void setup() {
Serial.begin(115200); // Schnittstelle bit/Sekunde
EE_Prom_Werte_Lesen_Long(); // Configurationswerte Laden
}
// ################################################################################​
void loop() {
if (Serial.available()) {
NeueWerte_Long();
}
Serial.print(" Var 1= "); Serial.print (Var_1);
Serial.print(" Var 2= "); Serial.print (Var_2);
Serial.print(" Var 3= "); Serial.print (Var_3);
Serial.print(" Var 4= "); Serial.println(Var_4);
delay(1000);
}
// ################################################################################​
void EE_Prom_Werte_Lesen_Long() {
Var_1 = 0; // ............................................................
Var_1 = EEPROM.read(1); // HH-Byte
Var_1 = Var_1 << 8;
Var_1 =Var_1 | EEPROM.read(2); // H-Byte
Var_1 = Var_1 << 8;
Var_1 =Var_1 | EEPROM.read(3); // L-Byte
Var_1 = Var_1 << 8;
Var_1 =Var_1 | EEPROM.read(4); // LL-Byte
Var_2 = 0; // ............................................................
Var_2 = EEPROM.read(5); // HH-Byte
Var_2 = Var_2 << 8;
Var_2 =Var_2 | EEPROM.read(6); // H-Byte
Var_2 = Var_2 << 8;
Var_2 =Var_2 | EEPROM.read(7); // L-Byte
Var_2 = Var_2 << 8;
Var_2 =Var_2 | EEPROM.read(8); // LL-Byte
Var_3 = 0; // ............................................................
Var_3 = EEPROM.read(9); // HH-Byte
Var_3 = Var_3 << 8;
Var_3 =Var_3 | EEPROM.read(10); // H-Byte
Var_3 = Var_3 << 8;
Var_3 =Var_3 | EEPROM.read(11); // L-Byte
Var_3 = Var_3 << 8;
Var_3 =Var_3 | EEPROM.read(12); // LL-Byte
Var_4 = 0; // ............................................................
Var_4 = EEPROM.read(13); // HH-Byte
Var_4 = Var_4 << 8;
Var_4 =Var_4 | EEPROM.read(14); // H-Byte
Var_4 = Var_4 << 8;
Var_4 =Var_4 | EEPROM.read(15); // L-Byte
Var_4 = Var_4 << 8;
Var_4 =Var_4 | EEPROM.read(16); // LL-Byte
Serial.println(" Alte Werte eingeladen ");
}
// ################################################################################​
void EE_Prom_Werte_Schreiben_Long() {
if (Vorz[1] == 1) { // Werte Negativ
Werte[0] = ~ Werte[1]; Werte[0] = Werte[0] + 1; }
else Werte[0] = Werte[1]; // Werte Positiv
EEPROM.write(1, ((Werte[0] >> 24) & 255)); // HH-Byte
EEPROM.write(2, ((Werte[0] >> 16) & 255)); // H-Byte
EEPROM.write(3, ((Werte[0] >> 8) & 255)); // L-Byte
EEPROM.write(4, ( Werte[0] & 255)); // LL-Byte

if (Vorz[2] == 1) { // Werte Negativ
Werte[0] = ~ Werte[2]; Werte[0] = Werte[0] + 1; }
else Werte[0] = Werte[2]; // Werte Positiv
EEPROM.write(5, ((Werte[0] >> 24) & 255));
EEPROM.write(6, ((Werte[0] >> 16) & 255));
EEPROM.write(7, ((Werte[0] >> 8) & 255));
EEPROM.write(8, ( Werte[0] & 255));

if (Vorz[3] == 1) { // Werte Negativ
Werte[0] = ~ Werte[3]; Werte[0] = Werte[0] + 1; }
else Werte[0] = Werte[3]; // Werte Positiv
EEPROM.write(9, ((Werte[0] >> 24) & 255));
EEPROM.write(10, ((Werte[0] >> 16) & 255));
EEPROM.write(11, ((Werte[0] >> 8) & 255));
EEPROM.write(12, ( Werte[0] & 255));

if (Vorz[4] == 1) { // Werte Negativ
Werte[0] = ~ Werte[4]; Werte[0] = Werte[0] + 1; }
else Werte[0] = Werte[4]; // Werte Positiv
EEPROM.write(13, ((Werte[0] >> 24) & 255));
EEPROM.write(14, ((Werte[0] >> 16) & 255));
EEPROM.write(15, ((Werte[0] >> 8) & 255));
EEPROM.write(16, ( Werte[0] & 255));

Serial.println(" Werte nach EE-Prom Geschrieben ");
}
//################################################################################​#
void EE_Prom_Grundwerte_Schreiben_Long() { // bei ,g, Grundwerte setzen
EEPROM.write(1, ((1000000 >> 24) & 255)); // HH-Byte Werte anpassen
EEPROM.write(2, ((1000000 >> 16) & 255)); // H-Byte
EEPROM.write(3, ((1000000 >> 8) & 255)); // L-Byte
EEPROM.write(4, ( 1000000 & 255)); // LL-Byte
EEPROM.write(5, ((-1000000 >> 24) & 255));
EEPROM.write(6, ((-1000000 >> 16) & 255));
EEPROM.write(7, ((-1000000 >> 8) & 255));
EEPROM.write(8, ( -1000000 & 255));
EEPROM.write(9, ((1431655765 >> 24) & 255));// 1431655765 = Eigene Werte setzen
EEPROM.write(10, ((1431655765 >> 16) & 255));
EEPROM.write(11, ((1431655765 >> 8) & 255));
EEPROM.write(12, ( 1431655765 & 255));
EEPROM.write(13, ((-1431655766 >> 24) & 255));
EEPROM.write(14, ((-1431655766 >> 16) & 255));
EEPROM.write(15, ((-1431655766 >> 8) & 255));
EEPROM.write(16, ( -1431655766 & 255));
Serial.println(" Grundwerte gespeichert");
}
//################################################################################​#
void NeueWerte_Long() { // Eingabe von Byte " 8 Bit "
delayMicroseconds(100); // Zeit evtl. anpassen
while (Serial.available() > 0)
{
char ch = Serial.read();
delayMicroseconds(200); // Zeit evtl. anpassen
if (ch == 'A') Index = 1; // Wert 1
if (ch == 'B') Index = 2; // Wert 2
if (ch == 'C') Index = 3; // Wert 3
if (ch == 'D') Index = 4; // Wert 4
if (ch >= '0' && ch <= '9') {
Werte[Index] = (Werte[Index] * 10) + (ch - '0'); // Zahlen 0-9
}
if (ch == '-') Vorz[Index] = 1; // Wenn 1 Wert ist negativ
if (ch == 'e') bitSet(M2, 0); // Wenn 'e' 1= nach EE-Prom schreiben
if (ch == ',' || ch == ' ') byte x = 0; // Dummy
if (ch == 'g') bitSet(M2, 1); // Wenn 'g' 2= Grundwerte speichern
if (ch == 'v') bitSet(M2, 2); // Wenn 'v' 4= Werte nach Config Variablen
if (ch == 'z') { // z letztes Zeichen im Eingabestring Empfang verarbeiten
if (bitRead(M2, 0) == 1) EE_Prom_Werte_Schreiben_Long(); // Eingabe 'e'
if (bitRead(M2, 1) == 1) EE_Prom_Grundwerte_Schreiben_Long(); // Eingabe 'g'
if (bitRead(M2, 2) == 1) { // Werte nach Config Variablen Eingabe 's'
if (Werte[1] != 0 && Vorz[1] == 0) Var_1 = Werte[1]; // Werte +
if (Werte[1] != 0 && Vorz[1] == 1) { // Werte -
Var_1 = ~ Werte[1]; Var_1 = Var_1 + 1; // ~ Tilde = Pos. nach Neg.
}
if (Werte[2] != 0 && Vorz[2] == 0) Var_2 = Werte[2]; // Werte +
if (Werte[2] != 0 && Vorz[2] == 1) { // Werte -
Var_2 = ~ Werte[2]; Var_2 = Var_2 + 1;
}
if (Werte[3] != 0 && Vorz[3] == 0) Var_3 = Werte[3]; // Werte +
if (Werte[3] != 0 && Vorz[3] == 1) { // Werte -
Var_3 = ~ Werte[3]; Var_3 = Var_3 + 1;
}
if (Werte[4] != 0 && Vorz[4] == 0) Var_4 = Werte[4]; // Werte +
if (Werte[4] != 0 && Vorz[4] == 1) { // Werte -
Var_4 = ~ Werte[4]; Var_4 = Var_4 + 1;
}
Serial.print(" Neue Werte "); Serial.print(" Index "); Serial.println(Index);
}
}
}
for(i=0; i <= 9; i++) {
Werte[i] = 0; // Gesendete Werte vom Monitor auf 0 setzen
Vorz[i] = 0; // Test der 4 Werte auf +/-
}
Index = 0;
M2 = 0;
Serial.println(" Werte uebernommen");
}
// ################################################################################​
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
11.12.2014, 10:11
Beitrag #2
RE: Daten Byte,Word,Int ans EE-Prom Senden
Hi,
ich hab's nicht ausprobiert, aber das mit dem float würde ich so machen:
Code:
void eeprom_write_float(int addr, float value) {
   byte* ptr = (byte*)(&value);
   int size = sizeof(value);
  
   for(int i = 0; i < size; i++) {
      EEPROM.write(addr+i, ptr[i]);
   }
}

oder allgemein:
Code:
template<typename T>
void eeprom_write_all(int addr, T value) {
   byte* ptr = (byte*)(&value);
   int size = sizeof(value);
  
   for(int i = 0; i < size; i++) {
      EEPROM.write(addr+i, ptr[i]);
   }
}

Wie gesagt, hab's nicht ausprobiert. Das mit dem Template funktioniert für Arrays und Objekte wahrscheinlich nicht. Es sollte aber für alle primitive Datentypen gehen.
Nochwas: Ich würde beim Schreiben ins EEPROM vorher immer prüfen, ob der Wert nicht sowieso schon drinsteht. EEPROMs vertragen nur eine bestimmte Anzahl an Schreibzyklen.
Also in etwa so (das habe ich ausprobiert):
Code:
void lazyEEPROMwrite(int address, byte value) {
  if(value != EEPROM.read(address))
       EEPROM.write(address, value);
};

Gruß,
Thorsten

Falls ich mit einer Antwort helfen konnte, wuerde ich mich freuen, ein paar Fotos oder auch ein kleines Filmchen des zugehoerigen Projekts zu sehen.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
11.12.2014, 12:46
Beitrag #3
RE: Daten Byte,Word,Int ans EE-Prom Senden
Hallo Thorsten.
Danke für den Tip.
Mit dem Test ob die gleichen Daten schon im EE-Prom sind ist besser! als Test
ob Daten <> 0.
Das mit dem Float muss ich mal Testen. (Die nächsten Tage)
Ich habe ein MCP3424 AD/Wandler am laufen. Die Config.Werte der 4 Kanaele habe
ich mit den Programm am laufen.
Nur fuer den Abgleich brauche ich zb. "0.00034 * Messwert" um den Wert mit einem
genauen Multimeterabzugleichen.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
11.12.2014, 13:03
Beitrag #4
RE: Daten Byte,Word,Int ans EE-Prom Senden
(11.12.2014 12:46)HTO schrieb:  Mit dem Test ob die gleichen Daten schon im EE-Prom sind ist besser! als Test
ob Daten <> 0.
...vor Allem weil ein "leeres" EEPROM glaube ich normalerweise 0xFF in jedem Byte stehen hat.

Falls ich mit einer Antwort helfen konnte, wuerde ich mich freuen, ein paar Fotos oder auch ein kleines Filmchen des zugehoerigen Projekts zu sehen.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
15.12.2014, 00:02
Beitrag #5
RE: Daten Byte,Word,Int ans EE-Prom Senden
Hallo habe programm für float am laufen.
Was koente man verbessern?
Schreiben nach EE-Prom muss noch Abfrage rein ob Wert schon vorhanden.
Bin froh, das es so funktioniert.
Jedenfalls bei Reset sind die Standartwerte aus dem EE-Prom wieder vorhanden.
Code:
#include <EEPROM.h>
// -------------------------------------------------------------------
byte In; // Monitor Eingabewerte
byte Index = 0; // Index Eingabewert
word FLA = 0;   // Merken welcher Wert Eingegeben A-D
byte Vorz[5];  // Vorzeichen des Eingabewert
byte M2 = 0;    // Bit-Merker fuer e,g,s
byte i = 0;     // Schleifenzaehler fuer For-Next
float VK[5];
float NK[5];
float DivNK[5];
float Erg;
byte ZahlNK[5];
byte VK_NK[5];// Umschalten Vor-Nachkommastelle
float Var_1 = 0; // Variable Eingabe 1 als Long
float Var_2 = 0; // Variable Eingabe 2 als Long
float Var_3 = 0; // Variable Eingabe 3 als Long
float Var_4 = 0; // Variable Eingabe 4 als Long
//##################################################################
void setup() {                
  Serial.begin(115200);
  Variablen_Loeschen();  
  EE_Prom_Werte_Lesen_float_1(); // Configurationswerte Laden
  EE_Prom_Werte_Lesen_float_2();
  EE_Prom_Werte_Lesen_float_3();
  EE_Prom_Werte_Lesen_float_4();
}
//##################################################################
void loop() {
  if (Serial.available()) {
    NeueWerte_Double();
  }
Serial.print("  A=  "); Serial.println(Var_1, 6);
Serial.print("  B=  "); Serial.println(Var_2, 6);
Serial.print("  C=  "); Serial.println(Var_3, 6);
Serial.print("  D=  "); Serial.println(Var_4, 6);
  delay(1000);
}
//#################################################################
void NeueWerte_Double() {
  Variablen_Loeschen();
  delayMicroseconds(100);
  while (Serial.available() >0 )
  {
    In = Serial.read();
    delayMicroseconds(200);
    if (In == 65) {Index = 1; bitSet(FLA, 0);} // Eingabe "A" Wert 1
    if (In == 66) {Index = 2; bitSet(FLA, 1);} // Eingabe "B" Wert 2
    if (In == 67) {Index = 3; bitSet(FLA, 2);} // Eingabe "C" Wert 4
    if (In == 68) {Index = 4; bitSet(FLA, 3);} // Eingabe "D" Wert 8
    if (In == 44 || In == 127) byte x = 0; //"," oder " " = Dummy
    if (In == 45) Vorz[Index] = 1; // "-" Wenn 1 Wert ist negativ
    if (In == 46) VK_NK[Index] = 1; // "." Umschalten nach Nachkommawert
    if (In == 101) bitSet(M2, 0); // "e" Wenn 1= nach EE-Prom schreiben
    if (In == 103) bitSet(M2, 1); // Wenn "g" 2= Grundwerte speichern
    if (In == 118) bitSet(M2, 2); // Wenn "v" 4= Werte nach Config Variablen

    if(In >47 && In <58)
    { // Zahl 0-9
      if(VK_NK[Index] == 0){ // Umschalter Vorkomma - Nachkommawert bei "."
        VK[Index] = (VK[Index] * 10) + (In - 48); // Vorkommawert
      }
      else
      { // Nachkommawert
        NK[Index] = (NK[Index] * 10) + (In - 48); // Nachkommawert
        DivNK[Index] = DivNK[Index] * 10;// Nachkommazahl Diffidieren
        ZahlNK[Index]++; // Zaehlen Nachkommastellen
      }
    }
    if (In == 122)
    { // z letztes Zeichen im Eingabestring
      if (bitRead(M2, 0) == 1) {             // Eingabe 'e'
        EE_Prom_Werte_Schreiben_float_1();  
        EE_Prom_Werte_Schreiben_float_2();  
        EE_Prom_Werte_Schreiben_float_3();  
        EE_Prom_Werte_Schreiben_float_4();  
      }        
      if (bitRead(M2, 1) == 1) {             // Eingabe 'g'
        EE_Prom_Grundwerte_Schreiben_float_1();
        EE_Prom_Grundwerte_Schreiben_float_2();
        EE_Prom_Grundwerte_Schreiben_float_3();
        EE_Prom_Grundwerte_Schreiben_float_4();
      }  
      if (bitRead(M2, 2) == 1) {  // Werte nach Config Variablen       Eingabe 'z'
        if (bitRead(FLA, 0) == 1) {  // Wert wurde geaendert
          Erg = VK[1] + (NK[1] / DivNK[1]); // Double zusammensetzen
          if (Erg != 0 && Vorz[1] == 0) Var_1 = Erg;      // Werte +
          if (Erg != 0 && Vorz[1] == 1) {
            Erg = Erg - (Erg * 2); Var_1 = Erg;           // Werte -
          }
        }
        if (bitRead(FLA, 1) == 1) {  // Wert wurde geaendert
          Erg = VK[2] + (NK[2] / DivNK[2]); // Double zusammensetzen
          if (Erg != 0 && Vorz[2] == 0) Var_2 = Erg;      // Werte +
          if (Erg != 0 && Vorz[2] == 1) {
            Erg = Erg - (Erg * 2); Var_2 = Erg;           // Werte -
          }  
        }  
        if (bitRead(FLA, 2) == 1) {  // Wert wurde geaendert
          Erg = VK[3] + (NK[3] / DivNK[3]); // Double zusammensetzen
          if (Erg != 0 && Vorz[3] == 0) Var_3 = Erg;      // Werte +
          if (Erg != 0 && Vorz[3] == 1) {
            Erg = Erg - (Erg * 2); Var_3 = Erg;           // Werte -
          }
        }  
        if (bitRead(FLA, 3) == 1) {  // Wert wurde geaendert
          Erg = VK[4] + (NK[4] / DivNK[4]); // Double zusammensetzen
          if (Erg != 0 && Vorz[4] == 0) Var_4 = Erg;      // Werte +
          if (Erg != 0 && Vorz[4] == 1) {
            Erg = Erg - (Erg * 2); Var_4 = Erg;           // Werte -
          }
        }  
      }
    }
  }
}
//###################################################################
void Variablen_Loeschen() {
  for(i=0; i <= 5; i++) {
    VK[i] = 0;
    NK[i] = 0;
    DivNK[i] = 1;
    ZahlNK[i] = 0;
    Vorz[i] = 0;
    VK_NK[i] = 0;
  }  
  Erg = 0;
  FLA = 0;
}
//###################################################################
void EE_Prom_Werte_Schreiben_float_1() {
  char *ptr = (char*) & Var_1;
  EEPROM.write(1, *ptr++);
  EEPROM.write(2, *ptr++);
  EEPROM.write(3, *ptr++);
  EEPROM.write(4, *ptr++);
}  
void EE_Prom_Werte_Schreiben_float_2() {
  char *ptr = (char*) & Var_2;
  EEPROM.write(5, *ptr++);
  EEPROM.write(6, *ptr++);
  EEPROM.write(7, *ptr++);
  EEPROM.write(8, *ptr++);
}  
void EE_Prom_Werte_Schreiben_float_3() {
  char *ptr = (char*) & Var_3;
  EEPROM.write(9, *ptr++);
  EEPROM.write(10, *ptr++);
  EEPROM.write(11, *ptr++);
  EEPROM.write(12, *ptr++);
}  
void EE_Prom_Werte_Schreiben_float_4() {
  char *ptr = (char*) & Var_4;
  EEPROM.write(13, *ptr++);
  EEPROM.write(14, *ptr++);
  EEPROM.write(15, *ptr++);
  EEPROM.write(16, *ptr++);
}
//###################################################################
void EE_Prom_Werte_Lesen_float_1() {
  char *ptr = (char *) & Var_1;
  *ptr++ = EEPROM.read (1);
  *ptr++ = EEPROM.read (2);
  *ptr++ = EEPROM.read (3);
  *ptr++ = EEPROM.read (4);
}  
void EE_Prom_Werte_Lesen_float_2() {
  char *ptr = (char *) & Var_2;
  *ptr++ = EEPROM.read (5);
  *ptr++ = EEPROM.read (6);
  *ptr++ = EEPROM.read (7);
  *ptr++ = EEPROM.read (8);
}  
void EE_Prom_Werte_Lesen_float_3() {
  char *ptr = (char *) & Var_3;
  *ptr++ = EEPROM.read (9);
  *ptr++ = EEPROM.read (10);
  *ptr++ = EEPROM.read (11);
  *ptr++ = EEPROM.read (12);
}  
void EE_Prom_Werte_Lesen_float_4() {
  char *ptr = (char *) & Var_4;
  *ptr++ = EEPROM.read (13);
  *ptr++ = EEPROM.read (14);
  *ptr++ = EEPROM.read (15);
  *ptr++ = EEPROM.read (16);
}
//###################################################################
void EE_Prom_Grundwerte_Schreiben_float_1() {
  Var_1 = 0.01545;
  char *ptr = (char*) & Var_1;
  EEPROM.write(1, *ptr++);
  EEPROM.write(2, *ptr++);
  EEPROM.write(3, *ptr++);
  EEPROM.write(4, *ptr++);
}  
void EE_Prom_Grundwerte_Schreiben_float_2() {
  Var_2 = 0.10;
  char *ptr = (char*) & Var_2;
  EEPROM.write(5, *ptr++);
  EEPROM.write(6, *ptr++);
  EEPROM.write(7, *ptr++);
  EEPROM.write(8, *ptr++);
}  
void EE_Prom_Grundwerte_Schreiben_float_3() {
  Var_3 = 1.00047;
  char *ptr = (char*) & Var_3;
  EEPROM.write(9, *ptr++);
  EEPROM.write(10, *ptr++);
  EEPROM.write(11, *ptr++);
  EEPROM.write(12, *ptr++);
}  
void EE_Prom_Grundwerte_Schreiben_float_4() {
  Var_4 = 10.048;
  char *ptr = (char*) & Var_4;
  EEPROM.write(13, *ptr++);
  EEPROM.write(14, *ptr++);
  EEPROM.write(15, *ptr++);
  EEPROM.write(16, *ptr++);
}
//###################################################################
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
Antwort schreiben 


Möglicherweise verwandte Themen...
Thema: Verfasser Antworten: Ansichten: Letzter Beitrag
  Daten Visualisieren MeisterQ 12 557 01.12.2016 19:36
Letzter Beitrag: MeisterQ
  Data Logger Daten auf SD Card schreiben Crichton 12 293 22.11.2016 18:32
Letzter Beitrag: Crichton
  I2C Daten übertragen Gandalf 3 211 04.11.2016 13:20
Letzter Beitrag: hotsystems
  Daten über USB verarbeiten Felix91 10 320 12.10.2016 13:00
Letzter Beitrag: Tommy56
  Byte Shiften und Bit abfragen.... comfan 4 203 02.09.2016 20:30
Letzter Beitrag: comfan
  Can-Bus Shield ok, aber keine Daten Clubsport 38 1.533 01.09.2016 14:17
Letzter Beitrag: Clubsport
  NRF24L01+ "Ping" senden, empfangen, bestätigen MeisterQ 8 378 23.08.2016 13:19
Letzter Beitrag: MeisterQ
  Daten an mysql diode1990 24 1.302 31.07.2016 10:29
Letzter Beitrag: Gandalf
  NRF24L01,Empfangene Daten auswerten Marc2014 9 518 30.07.2016 19:34
Letzter Beitrag: rkuehle
  Problem mit ESP8266 und EMail senden torsten_156 1 596 13.06.2016 21:14
Letzter Beitrag: torsten_156

Gehe zu:


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