Mit Parallelem Port LM75 auslesen



  • Hi!

    Ich möchte gerne mittels dem ParallelPort meinen LM75 einlesen. Grundsätzlich sei gesagt, dass meine Schaltung mit einem fertig compilierten Programm getestet wurde und funktioniert. Auch wurde das Ansteuern der DataPorts mit LEDS getestet und funktioniert ebenfalls.

    Einzig das Einlesen der Temperatur funktioniert nicht.

    Ich poste hier einfach einmal meinen Qullcode und zum vergleich jenen, von dem ich die hints habe. Evtl. weiß ja jemand wo die Anfängerfehler liegen...

    Eine kurze Erklärung zu den Abläufen in meinem Code:

    • Es wird der Treiber inpout32.dll geladen, den man ja für die Ansteuerung von Ports unter XP braucht.
    • Es läuft die (beschriebene) Prozedur zum Einlesen der Temperatur vom LM75 ab.

    Zum Vergleich hier der Link zum Originalquelltext in C#: http://www.franksteinberg.de/SOURCE/LM75-MIN.BAS (coole Seite übrigens, was Hinweise zu solchen Themen anbelangt!

    Ich danke Vielmals für jeden Hinweis!

    lg,
    LeFish

    #include <stdio.h>
    #include <conio.h>
    #include <windows.h>
    #include <time.h>
    #include <iostream>
    using namespace std;
    
    /* Definitions in the build of inpout32.dll are:            */
    /*   short _stdcall Inp32(short PortAddress);               */
    /*   void _stdcall Out32(short PortAddress, short data);    */
    
    /* prototype (function typedef) for DLL function Inp32: */
    
         typedef short _stdcall (*inpfuncPtr)(short portaddr);
         typedef void _stdcall (*oupfuncPtr)(short portaddr, short datum);
    
    int main(void)
    {
         HINSTANCE hLib;
         inpfuncPtr inp32;
         oupfuncPtr oup32;
    
         short x;
    
         /* Load the library */
         hLib = LoadLibrary("inpout32.dll");
    
         if (hLib == NULL) {
              printf("LoadLibrary Failed.\n");
              return -1;
         }
    
         /* get the address of the function */
    
         inp32 = (inpfuncPtr) GetProcAddress(hLib, "Inp32");
    
         if (inp32 == NULL) {
              printf("GetProcAddress for Inp32 Failed.\n");
              return -1;
         }
    
         oup32 = (oupfuncPtr) GetProcAddress(hLib, "Out32");
    
         if (oup32 == NULL) {
              printf("GetProcAddress for Oup32 Failed.\n");
              return -1;
         };
    
                   /*--------------------------------*/
                   /*                                */
                   /*Spannungsversorgung des LM75 ein*/
                   /*                                */
                   /*--------------------------------*/
    
         Sleep(75);
    
            (oup32)(0x378,128);         /*Versorgungsspannung einschalten*/
    
                   /*--------------------------------*/
                   /*                                */
                   /*Grundstellung im LM75 herstellen*/
                   /*                                */
                   /*--------------------------------*/
    
            (oup32)(0x37A,2);                /*SCL auf high stellen*/
            (oup32)(0x37A,0);                /*SDA auf high stellen*/
    
         Sleep(75);
    
                   /*--------------------------------*/
                   /*                                */
                   /*      Start an LM75 senden      */
                   /*                                */
                   /*--------------------------------*/
    
            (oup32)(0x37A,2);                /*SDA auf low stellen*/
            (oup32)(0x37A,3);                /*SCL auf low stellen*/
    
                   /*--------------------------------*/
                   /*                                */
                   /*    Adressbyte an LM75 senden   */
                   /*                                */
                   /*--------------------------------*/
    
            /*Bit7/Bit6/Bit5/Bit4: feste Adresse des LM75 = 1001*/
    
            (oup32)(0x37A,1);                 /*Bit7 = 1*/
            (oup32)(0x37A,0);                 /*SCL auf high stellen*/
            (oup32)(0x37A,1);                 /*SCL auf low stellen*/
    
            (oup32)(0x37A,3);                 /*Bit6 = 0*/
            (oup32)(0x37A,2);                 /*SCL auf high stellen*/
            (oup32)(0x37A,3);                 /*SCL auf low stellen*/
    
            (oup32)(0x37A,3);                 /*Bit5 = 0*/
            (oup32)(0x37A,2);                 /*SCL auf high stellen*/
            (oup32)(0x37A,3);                 /*SCL auf low stellen*/
    
            (oup32)(0x37A,1);                 /*Bit4 = 1*/
            (oup32)(0x37A,0);                 /*SCL auf high stellen*/
            (oup32)(0x37A,1);                 /*SCL auf low stellen*/
    
            /*Bit3/Bit2/Bit1: variable Adresse des LM75, wie 
              Pin5/Pin6/Pin7 = A2/A1/A0 verbunden; hier = 000*/
    
            (oup32)(0x37A,3);                 /*Bit3 = 0*/
            (oup32)(0x37A,2);                 /*SCL auf high stellen*/
            (oup32)(0x37A,3);                 /*SCL auf low stellen*/
    
            (oup32)(0x37A,3);                 /*Bit2 = 0*/
            (oup32)(0x37A,2);                 /*SCL auf high stellen*/
            (oup32)(0x37A,3);                 /*SCL auf low stellen*/
    
            (oup32)(0x37A,3);                 /*Bit1 = 0*/
            (oup32)(0x37A,2);                 /*SCL auf high stellen*/
            (oup32)(0x37A,3);                 /*SCL auf low stellen*/
    
            /*Bit0 je nach dem ob Master (PC) anschließend schreiben (0) soll 
                                                           oder lesen (1) soll*/
    
            (oup32)(0x37A,1);                 /*Bit0 = 1*/
            (oup32)(0x37A,0);                 /*SCL auf high stellen*/
            (oup32)(0x37A,1);                 /*SCL auf low stellen*/
    
                   /*--------------------------------*/
                   /*                                */
                   /*    LM75 sendet "Acknowledge"   */
                   /*                                */
                   /*--------------------------------*/
    
            (oup32)(0x37A,3);                 /*SDA auf low stellen*/
            (oup32)(0x37A,2);                 /*SCL auf high stellen*/
            (oup32)(0x37A,3);                 /*SCL auf low stellen*/  
    
                   /*--------------------------------*/
                   /*                                */
                   /*       Datenbyte 1 lesen        */
                   /*                                */
                   /*--------------------------------*/   
    
       int ByteWert=0; 
    
            (oup32)(0x37A,1);                 /*SDA auf high stellen*/ 
    
            (oup32)(0x37A,0);                 /*SCL auf high stellen*/                                 
       if   
            (((inp32)(0x379) && 64)==64) { 
           ByteWert+128;                        /*Achtes Bit auslesen*/
       }
            (oup32)(0x37A,1);                 /*SCL auf low stellen*/ 
    
            (oup32)(0x37A,0);                 /*SCL auf high stellen*/                                 
       if   
            (((inp32)(0x379) && 64)==64) {
           ByteWert+64;                        /*Siebentes Bit auslesen*/
       }
            (oup32)(0x37A,1);                 /*SCL auf low stellen*/ 
    
            (oup32)(0x37A,0);                 /*SCL auf high stellen*/                                 
       if   
            (((inp32)(0x379) && 64)==64) {
           ByteWert+32;                        /*Sechstes Bit auslesen*/
       }
            (oup32)(0x37A,1);                 /*SCL auf low stellen*/ 
    
            (oup32)(0x37A,0);                 /*SCL auf high stellen*/                                 
       if   
            (((inp32)(0x379) && 64)==64) {
           ByteWert+16;                        /*Fünftes Bit auslesen*/
       }
            (oup32)(0x37A,1);                 /*SCL auf low stellen*/ 
    
            (oup32)(0x37A,0);                 /*SCL auf high stellen*/                                 
       if   
            (((inp32)(0x379) && 64)==64) {
           ByteWert+8;                        /*Viertes Bit auslesen*/
       }
            (oup32)(0x37A,1);                 /*SCL auf low stellen*/ 
    
            (oup32)(0x37A,0);                 /*SCL auf high stellen*/                                 
       if   
            (((inp32)(0x379) && 64)==64) {
           ByteWert+4;                        /*Drittes Bit auslesen*/
       }
            (oup32)(0x37A,1);                 /*SCL auf low stellen*/ 
    
            (oup32)(0x37A,0);                 /*SCL auf high stellen*/                                 
       if   
            (((inp32)(0x379) && 64)==64) {
           ByteWert+2;                        /*Zweites Bit auslesen*/
       }
            (oup32)(0x37A,1);                 /*SCL auf low stellen*/ 
    
            (oup32)(0x37A,0);                 /*SCL auf high stellen*/                                 
       if   
            (((inp32)(0x379) && 64)==64) {
           ByteWert+1;                        /*Erstes Bit auslesen*/
       }
            (oup32)(0x37A,1);                 /*SCL auf low stellen*/ 
    
                   /*--------------------------------*/
                   /*                                */
                   /* Ackknowledge vom Master senden */
                   /*                                */
                   /*--------------------------------*/  
    
            (oup32)(0x37A,3);                 /*SDA auf low stellen*/ 
            (oup32)(0x37A,2);                 /*SCL auf high stellen*/   
            (oup32)(0x37A,3);                 /*SCL auf low stellen*/ 
            (oup32)(0x37A,1);                 /*SDA auf high stellen*/ 
    
                 /*-----------------------------------*/
                 /*                                   */
                 /*Höchstwertiges Bit vom 2.Byte lesen*/
                 /*                                   */
                 /*-----------------------------------*/
    
       int kommafuenf=1;
    
            (oup32)(0x37A,0);                 /*SCL auf high stellen*/                                 
       if   
            (((inp32)(0x379) && 64)==64) {
           kommafuenf=1;                        /*Erstes Bit auslesen*/
           }
       else {
            kommafuenf=0;
       }
    
            (oup32)(0x37A,3);                 /*SCL auf low stellen*/ 
    
                   /*--------------------------------*/
                   /*                                */
                   /*   Spannung vom LM75 abklemmen  */
                   /*                                */
                   /*--------------------------------*/ 
    
            (oup32)(0x378,00000000);         /*Versorgungsspannung ausschalten*/
    
                   /*--------------------------------*/
                   /*                                */
                   /*       Vorzeichen bestimmen     */
                   /*                                */
                   /*--------------------------------*/ 
    
       int Temperatur=0;
    
       if   
            ((ByteWert && 128)==128) {
           Temperatur = ByteWert - 256;                 /*Temperatur unter 0 Grad*/
       }
       else {
           Temperatur = ByteWert;                       /*Temperatur über 0 Grad*/
       }
    
                   /*--------------------------------*/
                   /*                                */
                   /*       Temperatur ausgeben      */
                   /*                                */
                   /*--------------------------------*/ 
    
       if(kommafuenf==1) {
           Temperatur+0.5;
       }
    
       cout<< "Die Temperatur betraegt: " <<Temperatur<<" Grad Celsius"<< endl;     
    
            system("Pause");
    };
    


  • guck dir mal das an: http://www.nxp.com/acrobat_download/literature/9398/39340011.pdf
    und überprüf' ob du alles richtig machst.
    wenn der code logisch ok ist, dann stimmen wahrscheinlich die timings nicht...
    🙂



  • also ich muss mal ganz ehrlich sagen, dass ich ein noob bin und gerade mal so halb verstanden habe, wie mein LM75 arbeitet.

    auch mit c++ hatte ich noch nicht so viel am hut. das letzte mal, dass ich ein bisschen was zum spaß programmiert habe war im dos mit den stapelverarbeitungscmnds.

    das was ich in den quellcode oben reingeschrieben hab (außer den anfang, der kommt von einer testdatei) hab ich mal so zusammengenudelt aus dem was ich im internet über den lm75 finden konnte.

    die temperaturausgabe mit der komma-fünf (ja/nein) abfrage hab ich dann selbst so hingetrickst, dass sie funktionieren sollte.

    grundsätzlich kompiliert mit der dev++ den quellcode ohne probleme. daraus schließe ich mal, dass sie logisch soweit in Ordnung sein sollte (?!?!)

    also ich mit meinem unwissen derzeit bedarf noch auf klare hinweise von leuten, die sich mit c++ echt auskennen und evtl. das schon mal gemacht haben...

    THX!

    lg,
    LeFish



  • LeFish schrieb:

    grundsätzlich kompiliert mit der dev++ den quellcode ohne probleme. daraus schließe ich mal, dass sie logisch soweit in Ordnung sein sollte (?!?!)

    ja, syntaktisch mag der code in ordnung sein, aber damit hast du vielleicht 1% aller fehlerquellen ausgeschlossen.
    du könntest mal da fragen: http://www.mikrocontroller.net/
    wie man iic-geräte am parallelport anschliesst. die wahrscheinlichkeit ist gross, dass das da schon mal einer gemacht hat...



  • LeFish schrieb:

    (...) ich mit meinem unwissen derzeit bedarf noch auf klare hinweise (...)

    OK. Hinweis 1 : Aufsummieren

    int ByteWert = 0; 
    
    (...)
    
    ByteWert +  128; // FALSCH
    
    ByteWert += 128; // RICHTIG
    


  • Hallo!

    Ich bin drauf gekommen was ich falsch gemacht habe:

    Stupid habe ich den Anweisungen gefolgt, die auf einer Internetseite gepostet waren. Dort stand, dass man die einzelnen Bytes, die der LM75 nach und nach zurückendet und in dem die Temperatur codiert ist, mit der AND funktion behandeln muss. Soweit so gut. Im Internet stand man sollte als vergleichsbyte 64 nehmen.

    Irgendwie aber sendet mein LM75 immer 126 zurück, wenn ich addieren soll und 62 wenn ich nicht addieren soll.

    Kann mir mal einer erklären, warum mein LM75 anders tickt??

    Vielen Dank!

    lg,
    LeFish



  • LeFish schrieb:

    Dort stand, dass man die einzelnen Bytes, (...) , mit der AND funktion behandeln muss.

    Allerdings ist damit das mathematische AND "&" gemeint und nicht das logische "&&" :

    if (((inp32)(0x379) & 64) == 64) {
           ByteWert += 16;             /*Fünftes Bit auslesen*/
    }
    


  • Hi!

    Axo danke!
    Ich hab das jetzt verändert! Läuft WUNDERBAR! Danke!

    So lernt man im C++ dazu...

    lg,
    LeFish


Anmelden zum Antworten