C auf PIC16F1937 komisches Verhalten oder auch nicht!?



  • Hallo Leute bzw. Dirk,

    danke für eure Beiträge, hab mich deshalb auch in die Richtung noch etwas eingelesen!

    Was ich aber noch nich ganz verstanden habe, ist der Unterschied zwischen

    einer "statischen" und nicht statischen globalen Variablen innerhalb eines Modules!?

    Konnte mehr oder weniger entnehmen, dass eine nicht-statische Variable von außen zugreifbar ist, aber was bedeutet das von "außen" in dem Kontext!

    Wenn ich foo.h die entspreche foo.c habe, und ich habe in foo.c eine Variable ohne static deklariert. Habe die foo.h in der main.c includiert, kann ich ja von da aus NICHT auf die variable in der foo.c zugreifen!? oder ist das anders gemeint?

    Grüße



  • NullBockException schrieb:

    Wenn ich foo.h die entspreche foo.c habe, und ich habe in foo.c eine Variable ohne static deklariert. Habe die foo.h in der main.c includiert, kann ich ja von da aus NICHT auf die variable in der foo.c zugreifen!?

    Doch, kannst Du. Du musst die Variable nur deklarieren (Z. 4 in main.c )

    // main.c
    #include "foo.h"
    
    extern const char *s;
    
    int main(void) {
      func();
      s = "Hallo Welt!";
      func();
    }
    
    // foo.h
    #ifndef FOO_H
    #define FOO_H
    void func(void);
    #endif
    
    // foo.c
    #include <stdio.h>
    
    //static const char* s = "Hello, World!";
    const char *s = "Hello, World!";
    
    void func(void) { puts(s); }
    


  • Ahhhh Klick .... optimal.. Danke:)

    d.h. im Module foo.c selbst macht es aber keine Unterschied ob ich ne Variable static ist oder nich, nur wenn ich eben von außen zugreifen will.. Richtig?


  • Mod

    NullBockException schrieb:

    d.h. im Module foo.c selbst macht es aber keine Unterschied ob ich ne Variable static ist oder nich, nur wenn ich eben von außen zugreifen will.. Richtig?

    Du (und vor allem der Compiler!) weiß dann unter Garantie, dass sich der Wert nur durch Vorgänge innerhalb von foo.c ändern kann. Das macht es aber auch nicht viel besser, die wesentlichen Nachteile der globalen Variablen werden dadurch nur unwesentlich abgeschwächt.



  • @SeppJ : Danke für den Hinweis:)

    Ich hab jetzt bisschen refactoring betrieben und (wo es möglich war) auf globale variablen innheralb der c-files verzichtet und keinem mehr in den h-files 🙂

    Nun habe ich noch ein weiteres Anliegen:)

    Ich möchte eine Delay Funktion implementiren, welche Asyncron zu den anderen Modulen (kooperativen Multitasking) läuft!

    Nun habe ich da eine unsigned int (16Bit) counter , welche ich ständig im timer interrupt hochzähle.

    wenn ich nun in meiner Delayfunktion den alten wert merke, und den neuen davon abziehe müsste doch IMMER ein positiver wert raukomemn auch wenn der Alte und der neue Wert vor und nach dem überlaufe bzw. - zu + spirngen.

    Bedinung: Aufruf Interval der Delay funktion liegt unter einem unsigned int überlauf!

    Oder hab ich nen Denkfehler.. Überlauf doch beachten?

    Pseudo:

    unsigned int counter;
    unsigned int old;
    typedef unsigned char BOOL;

    void timer_interrupt(void)
    {
    ++counter;
    }

    BOOL Delay()
    {
    int diff= (int)(old - counter);
    if(diff>=1000)
    {
    return 1;
    }
    return 0;
    }

    void main()
    {
    while(1)
    {
    if(Delay())
    {
    //Klingeling
    }
    }
    }}


  • Mod

    Es würde ja funktionieren, wenn du wirklich mit unsigned int rechnen würdest. Aber aus mir völlig unverständlichen Gründen packst du das Ergebnis in einen (signed) int. Wundert dich dann, dass du negative Werte bekommst?

    Willst du wirklich globale Variablen in einer Multithreaded-Umgebung benutzen? Wenn das vorher schon nicht empfehlenswert war, so ist das bei mehreren Threads erst recht super-tödlich. Falls dein Programm mehr als nur ein Beispiel ist, machst du auch prompt alles falsch.



  • Sorry mit code Tags

    unsigned int counter;
    unsigned int old;
    typedef unsigned char BOOL;
    
    void timer_interrupt(void)
    {
    ++counter;
    }
    
    BOOL Delay()
    {
    int diff= (int)(old - counter);
    if(diff>=1000)
    {
    return 1;
    }
    return 0;
    }
    
    void main()
    {
    while(1)
    {
    if(Delay())
    {
    //Klingeling
    }
    }
    }}
    


  • Es handelt sich ja um kooperativen Multitasking, ich hätte in dem fall nur die counter variable global, was is das schlimm?

    achso stimmt , aber wenn ich eine postiven unsigend int auf int caste kommt ja das gleiche Ergbniss , soweit die zahl unter 32767 ist!?

    ja ok wenn ich sowas mache

    nt diff= (unsigned int)(old - counter);
    

  • Mod

    1. Lass die dummen Casts weg. Was denkst du, was die machen sollen? Fakt ist, sie machen überhaupt gar nichts!
    2. Habe ich gesagt "packst du das Ergebnis in einen (signed) int". Das machst du immer noch. Natürlich passiert immer noch das gleiche.



  • Ok Danke Sepp,

    ich schau mir das nochmal an 😃

    Aber trotzdem nochmal zu meiner globalen counter Variable! Welche als static in der in der delayTimer.c befindet. Wie kann ich das "nicht-global" lösen?

    Bin für jegliche Tipps und Einwände offen 🤡 .. oder wie würdest du so einen delay Methode implementieren?

    Grüßle



  • NullBockException schrieb:

    Sorry mit code Tags

    So ist das genauso unlesbar.
    Du solltest dich für einen Einrückungsstil entscheiden.


Anmelden zum Antworten