Zur Übersicht - INFO - Neueste 50 Beiträge - Neuer Beitrag - Suchen - Zum C-Control-I-Forum - Zum C-Control-II-Forum

Re: floats im I2C-EE speichern Kategorie: Sonstige Hardware (von Marcel - 26.03.2008 8:59)
Als Antwort auf Re: floats im I2C-EE speichern von Hannes - 26.03.2008 8:44
Ich nutze:
C-Control Pro Mega128, CC-Pro 128 Application Board
Hi,

das ist eine gute Idee.
So habe ich mir das auch gedacht, allerdings bisher ohne Erfolg.
Ich will den Float auch in einen Vorkomma- und Nachkommabereich teilen und dann abspeichern.
Geht das so wie du es gezeigt hast auch mit - Zahlen?

Gruß Marcel



> Hi,
>
> Nachkommastellen verschluckt?? Ich weis ja nicht wie Du die float`s im EEPROM speicherst aber
> prinzipiell kann man das I2C-EEPROM nur byteweise ansprechen.
> Das C-Control Pro verwendet float-Zahlen, als 4Byte, nach IEEE 754. Ob man mit dem System die
> float manuell in die 4Byte umrechnen kann weis ich nicht, die Frage kann evtl. PeterS beantworten.
>
> Ich hab mal ein kleines Programm geschrieben um positive Messwerte als Float im I2C-EE zu speichern.
> Dabei zerlege ich die float in die Vorkomma- und Nachkommastellen und speichere diese mit
> 3Byte im I2C-EE ab. Geht also nur bis 32767,xx mit einer kleinen Ungenauigkeit in der letzten Komma-
> stelle, für mich ein brauchbares Ergebnis.
>
> Gruss
>
>
>
>
>
>
>
> /*
>     Eine Float-Zahl im I2C-EEPROM speichern + lesen
>     Achtung: Rundungsfehler entstehen bereits ab der 2. Stelle hinterm Komma!!!
>              z.B. 3.33000 -> 3.32
>
>
> */
>
>
> #define LF 0x0A
> #define CR 0x0D
> #define SPACE 0x20
>
> void main(void)
> {
>     float Zahlf;
>     word EE_Adr;
>     byte EE_Byte;
>
>     EE_Adr=0;
>
>     I2C_Init(I2C_100kHz);                               // I2C Bit Rate: 100 kHz
>
>     for (Zahlf = 0.0; Zahlf <= 20.0; Zahlf= Zahlf + 1.11)
>     {
>         WriteFloat_24C64(EE_Adr, Zahlf);
>         EE_Adr = EE_Adr + 3;
>         Msg_WriteFloat(Zahlf);
>         Msg_WriteChar(SPACE);
>     }
>
>     Msg_WriteChar(0x3D);                                // " = "
>
>     for (EE_Adr=0; EE_Adr <= 54; EE_Adr = EE_Adr + 3)   // aus dem I2C-EE lesen
>     {
>         Zahlf= ReadFloat_24C64(EE_Adr);
>         Msg_WriteFloat(Zahlf);
>         Msg_WriteChar(SPACE);
>     }
>
>
> }
>
> // ----------------------- eine Float-Zahl als 3 Byte ins I2C-EEPROM schreiben ------------------
> //
> void WriteFloat_24C64(word EE_Adresse, float zahlf)
> {
>     float VKSf, NKSf;
>     word VKSw;
>     byte NKSb;
>     word high_byte, low_byte, teiler;
>
>     teiler=256;
>
>     VKSw = zahlf;                           // Vorkommastellen als word
>     VKSf = VKSw;                            // Vorkommastellen als float
>     NKSf = zahlf - VKSf;                    // Nachkommastellen als float
>     NKSb = NKSf *100.0;                     // Nachkommastellen als byte  (2-stellig)
>
>     high_byte = VKSw / teiler;              // VKS (word) in ein high-byte
>     low_byte  = VKSw % teiler;              // und low-byte zerlegen
>
>     Write_24C64(EE_Adresse,   high_byte);   // die VKS im EE speichern
>     Write_24C64(EE_Adresse+1, low_byte);
>     Write_24C64(EE_Adresse+2, NKSb);        // die NKS im EE speichern
> }
>
>
> // ---------------------- eine Float-Zahl (3 Byte) aus dem I2C-EEPROM lesen --------------------
> //
> float ReadFloat_24C64(word EE_Adresse)
> {
>     float zahlf;
>     word VKSw;
>     byte NKSb;
>
>     VKSw= Read_24C64(EE_Adresse)*256 + Read_24C64(EE_Adresse+1);    // die Vorkommastelle (2Byte) lesen
>     NKSb= Read_24C64(EE_Adresse+2);                              // die Nachkommastelle (1Byte) lesen
>
>     zahlf= VKSw + NKSb/100.0;
>
>     return zahlf;
>
> }
>
>
> //------------------------------------------------------------------------------
> // Daten in das 24C64 (8k x 8) EEPROM schreiben
> //
> void Write_24C64(word Adresse, byte Daten)
> {
>     I2C_Start();
>     I2C_Write(0xA0);                        // DEVICE ADDRESS : A0
>     I2C_Write(Adresse>>8);                  // HIGH WORD ADDRESS
>     I2C_Write(Adresse);                     // LOW WORD ADDRESS
>     I2C_Write(Daten);                       // write Data
>     I2C_Stop();
>     AbsDelay(5);                            // delay for EEPROM Write Cycle
> }
>
> //------------------------------------------------------------------------------
> // Daten aus dem 24C64 (8k x 8) EEPROM lesen
> //
> byte Read_24C64(word Adresse)
> {
>     byte I2C_DATA;
>
>     I2C_Start();
>     I2C_Write(0xA0);                        // DEVICE ADDRESS : A0
>     I2C_Write(Adresse>>8);                  // HIGH WORD ADDRESS
>     I2C_Write(Adresse);                     // LOW WORD ADDRESS
>     I2C_Start();                            // RESTART
>     I2C_Write(0xA1);                        // DEVICE ADDRESS : A1
>     I2C_DATA=(I2C_Read_NACK());
>     I2C_Stop();
>     return I2C_DATA;                        // return I2C Data Register
> }
>
>
>
>
> /*
> Interpreter gestartet - 2kb RAM                                                
> 0.00000 1.11000 2.22000 3.33000 4.44000 5.55000 6.66000 7.77000 8.88000 9.99000
> 11.10000 12.21000 13.32000 14.43000 15.54000 16.64999 17.75999 18.86999 19.97999
>
>  =0.00000 1.11000 2.22000 3.32000 4.43000 5.54000 6.65000 7.76000 8.87000 9.9800
> 0 11.09000 12.20000 13.31000 14.42000 15.53000 16.64000 17.75000 18.86000 19.970
> 00                                                                              
> Zeit: 460ms                                                                    
> Interpreter gestoppt    
> */


    Antwort schreiben


Antworten:

Re: floats im I2C-EE speichern (von Hannes - 26.03.2008 9:20)
    Re: floats im I2C-EE speichern (von Marcel - 26.03.2008 18:02)
        Re: floats im I2C-EE speichern (von Hannes - 27.03.2008 10:24)
            Re: floats im I2C-EE speichern (von Marcel - 27.03.2008 11:46)
                Re: floats im I2C-EE speichern (von Hannes - 27.03.2008 13:36)