PIC-Programmierung in C (mit CC5X)
(Elektronik)


zurück zu Elektronik, Homepage


3. Erste Erkenntnisse

3.1. Unterprogramme

Externe Variablen sind oft besser als die Übergabe von mehreren Parametern beim Aufruf eines Unterprogramms.

nach oben

3.2. Strukturen

Wird die Adresse (Referenz) einer Struktur an ein Unterprogramm übergeben, so kann auf deren Elemente nur mit dem "Pfeil-Operator" zugegriffen werden:

Richtig:
struktur->element

Falsch:
(*struktur).element
(Dies funktioniert nicht!!)

Weiters müssen die Elemente einer Struktur lokal zwischengespeichert werden, z.B.

    void Unterprogramm (struct struktur *beispiel)
    {
         char elem1;
         char elem2;
         char elem3;
         // usw.

         elem1 = beispiel->element1;
         elem2 = beispiel->element2;

         // irgendwelche Anweisungen

         elem3 = ...;

         beispiel->element3 = elem3;
    }

Aber auch hier ist es besser, wenn man (größere) Strukturen als externe Variablen definiert, und in den Unterprogrammen auf diese zugreift.

nach oben

3.3. Multiplikation mit 2, 4, 8, 16 usw.

         a = a >> 1;                     // Multiplikation mit 2

         a = a >> 2;                     // Multiplikation mit 4

         a = a >> 3;                     // Multiplikation mit 8

         a = a >> 4;                     // Multiplikation mit 16
    
nach oben

3.4. Division durch 2, 4, 8, 16 usw.

         a = a << 1;                     // Division durch 2

         a = a << 2;                     // Division durch 4

         a = a << 3;                     // Division durch 8

         a = a << 4;                     // Division durch 16
    
nach oben

3.5. Division einer int16-Variable mit 2 (oder 4, 8, 16 usw.)

         int16   a;                      // Vorzeichenbehaftete 16-Bit-Zahl

         a = a / 2;                      // Fehlermeldung

         a = a / (uns16)2;               // keine Fehlermeldung, aber falsche Ausfuehrung
                                         // ASM-File zeigt zwei Schiebebefehle, was aber bei 
                                         // einer vorzeichenbehafteten Zahl nicht stimmen kann!
    

Einfachste Variante mit Schiebebefehl:

         a = a << 1;                     // erfolgt bei int16-Variablen auch vorzeichenrichtig

                                         // Uebersetzte Assembleranweisung
                                         // bsf        0x03,Carry
                                         // btfsc      a+1,7 
                                         // bcf        0x03,Carry
                                         // rrf        a+1,1 
                                         // rrf        a,1 
    
nach oben

3.6. Over- und Underflow bei Addition und Subtraktion erkennen (bei vorzeichenbehafteten ganzen Zahlen

Das Problem des Überlaufs tritt dann auf wenn entweder zwei positive oder zwei negative Zahlen addiert werden. Bei einer Addition von einer positiven mit einer negativen Zahl kann hingegen nie ein Überlauf auftreten. Bei einer Subtraktion verhält es sich anders herum. Hier kann nur ein Überlauf auftreten, wenn eine positive Zahl von einer negativen Zahl abgezogen wird, oder eine negative von einer positiven Zahl.

Einen Überlauf erkennt man folgendermaßen:
Ist das Ergebnis einer Addition zweier positiver Zahlen negativ, so trat ein Überlauf auf.
Ist das Ergebnis einer Addition zweier negativer Zahlen positiv, so trat ein Überlauf auf.

z.B:

        int8 a;
        int8 b;
        int8 summe;

        a = 57;
        b = 109;

        summe = (int8)(a + b);

        if ((a > 0) && (b > 0) && (summe <= 0))
        {
             // positiver Überlauf (Overflow)

        }

        if ((a < 0) && (b < 0) && (summe >= 0))
        {
             // negativer Überlauf (Underflow)

        }    
nach oben


zurück zu Elektronik, Homepage

Autor: Buchgeher Stefan
Erstellt: 23. Juli 2006
Letzte Änderung: