for Schleife einsetzen

[Francis C. (Firma: Privat) (danger19xx)]

Hallo Z'men,

anhang eines AD-Wandlers von AT89C51CC03 habe das Programm unten 
geschrieben geschrieben. Aber ich weiss nicht genau, wo die For-Schleife 
einzubringen ist, wenn ich die Messwerte im Bereich 150MicroS und 
4200MicroS auch mit jedem Potis P16 und P17 einlesen moechte, denn ich 
die Werte mit beiden Potis im Bereich von 1ms - 256ms.

Lange Rede kurzer Sinn, hier das Programm:

/****************************************************************************************************/
    /*  Dieses Programm namens "recht_2.C" gibt ein zeitlich komplett parametrierbares                  */
    /*  Rechtecksignal am Port-Pin P1.0 aus.                                                            */
    /* Damit kann man waehrend des Betriebs die Breitenwerte des Signals einstellen                     */
    /* -->fuer die positive Impulsbreite tp wird der Trimm-Poti P1.6 im Bereich 1ms bis 256ms verwendet */
    /* -->fuer die negative Impulsbreite tn wird der Trimm-Poti P1.7 im Bereich 1ms bis 256ms verwendet */
    /* Der A/D-Wandler wird im 8-Bit-Modus betrieben                                                    */
    /*                                                                                                  */
    /****************************************************************************************************/

/*** Einbinden von Include-Dateien ***/
#include<stdio.h>
#include<at89c51cc03.h>



void main (void)     // Start des Hauptprogramms
{
    unsigned int wert_p16, wert_p17;  //Variablen zur Aufnahme des Teilergebnisses von Trimm-Poti p1.6 und p1.7
    unsigned int wert;              //Variable zur Aufnahme des zusammengesetzten Gesamtergebnisses

    /**************************************************************/
    /*  Initialisierung der seriellen Schnittstelle 0 des CC03ers */
    /*  Schnittstellenparameter: 9600Baud, 8 Datenbit, 1 Stopp-Bit*/
    /*  asynchroner Betrieb                                       */
    /**************************************************************/
    SCON=0x52;
    TMOD |=0x20;
    TH1=0xfd;
    TR1=1;
    TI=1;
    
    /* Initialisierung des A/D-Wandlers */
    ADCF = 0xc0;    // Port P1.6 und P1.7 als Analogeingang definieren,
                    // d.h., CH6 und CH7 sollen angesprochen werden
    ADCON = 0x20;   // Enable ADC, mit ADEN =1 und
                    // SCH2, SCH1, SCH2 sollen respektiv die Werte 110 und 111
                    // um den P1.0 steuern zu können...


    printf("\x1b\x48\x1b\x4a"); //löschen des Bildschirms
 
    while(1)
    {
        ADCON &= ~0x07;             // Sicher stellen, dass SCH2, SCH1, SCH0 auf null initialisiert sind
        ADCON |= 0x06;              // Auswahl von CH6
        ADCON &= ~0x40;             // Standard Mode
        ADCON = ADCON | 0x08;       // Start der Wandlung
        
        while ((ADCON & 0x10)==0);  //warten bis Wandlung fertig ist

        ADCON = ADCON & 0xef;       // End of Conversion Bit löschen
        wert_p16 = ADDH;            //Ergebnis des eingestellten Wertes von Poti P1.6 speichern

        /*Das vermeiden vom Programmabsturz */
        if(wert_p16==0)
        {
            wert_p16++;
        }
        _wait_ms(wert_p16);
        printf("tp hat den wert: %u ms\n\n", wert_p16); // Ausgabe von tp(positive Impulbreite)


        ADCON &= ~0x07;             // Sicher stellen, dass SCH2, SCH1, SCH0 auf null initialisiert sind
        ADCON |= 0x07;              // Auswahl von CH7
        ADCON &= ~0x40;             // Standard Mode
        ADCON = ADCON | 0x08;       // Start der Wandlung
        
        while ((ADCON & 0x10)==0);  //warten bis Wandlung fertig ist

        ADCON = ADCON & 0xef;       // End of Conversion Bit löschen
        wert_p17 = ADDH;             //Ergebnis des eingestellten Wertes von Poti P1.7 speichern

        
        /*Das vermeiden vom Programmabsturz */
        if(wert_p17==0)
        {
            wert_p17++;
        }
        _wait_ms(wert_p17);
        printf("tn hat den wert: %u ms\n\n", wert_p17); // Ausgabe von tn

        wert = wert_p16 + wert_p17; //tp + tn zusammenfuegen

    
        printf("die gesamte Impulsbreite ist: %u ms\n\n", wert);  //Ausgabe der gesamten Impulsbreite --> (tp + tn)
      


    }//end while
    
 

} //end main()

[Bitflüsterer (Gast)]

Ist ja furchtbar. Fang das am Besten nochmal von vorne an.

Es ist wesentlich besser, die Speicherung des AD-Wandlungsergebnises und 
die Umstellung des Kanals in einer Interrupt-Routine zu erledigen.

Dann, wenn das funktioniert, stellst Du in (ich würde mal sagen in der 
selben Interrupt-Routine) das Timerregister für die PWM um.

Die Hauptschleife ist im wesentlichen leer (falls Du die Ausgabe nicht 
wirklich brauchst).

Eine For-Schleife kommt da überhaupt nicht vor.

[Bitflüsterer (Gast)]

Ach, und noch ein Hinweis:

Die Bits in den Steuerregistern haben Namen, die auch in at89c51cc03.h 
definiert sind. Verwende die und nicht irgendwelche Literale, die Du 
dann in Kommentaren lang und breit erklären musst.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Für den Anfang kann man die Interrupts (die das Ganze nicht einfacher 
machen) auch weglassen und Alles in der Hauptschleife machen. Nur für 
die PWM muss eben ein Hardwaretimer herhalten. Aber genau dafür sind die 
ja auch im uC eingebaut...

[Peter D. (peda)]

Wo hast Du den Code her?
Er funktioniert nicht, die printf dauern ja schon >1ms je Zeichen.

Für 150 .. 4200µs mußt Du den Timer T2 nehmen und in dessen Interrupt 
das RCAP2 entsprechend umladen.

[Francis C. (Firma: Privat) (danger19xx)]

Danke erstmal fuer die schnelle Antwort ;)

@Bitfluesterer
Heuuu, leider haben wir noch nicht den Interrupt-Kapitel behandelt. es 
gilt auch fuer die PMW...
Zur Aufgabe habe ich als Hinweise, die For-Loop zu benutzen, um den 
Zeitbereich zw 150ms und 4200ms darzustellen.

@Lothar
damit die Werte im Bereich 150microS und 4200microS auch mit dem 
Oszilloskop geprueft/dargestellt werden koennen, gaben sie mir als 
Hinweis eine For-Loop zu benutzen. ich habe folgendes z.B direkt nachdem 
wait_ms()-Funktion probiert und natuerlich als Datentyp "float" 
deklariert:

        for(wert_p17==0.150; wert_p17<=4.2; (wert_p17++*0.001))
        {
            printf("tn hat den wert: %3.2f ms\n\n", wert_p17);
        }

@Peter,
ich habe das Programm selber geschrieben ;) und es laeuft(Halleluja)
Es ist wahr, dass ich printf mit 1ms schon laeuft, aber waehrend ich an 
den Potis drehe, wird die Impulsbreite immer groesser(max 510ms). 
Hauptsache ist es, dass ich kein NULL im meiner wait_ms()funktion habe, 
um den Abstuerz des Programms zu vermeiden(deshalb die if-loop).

Danke nochmal fuer die Hilfe.

[Easylife (Gast)]

g r u s e l i g.

a) statt

if(wert_p17==0)
{
    wert_p17++;
}
_wait_ms(wert_p17);

kannst du doch auch einfach schreiben:

if(wert_p17>0) {
  _wait_ms(wert_p17);
}

b) wie soll "for(wert_p17==0.150; wert_p17<=4.2; (wert_p17++*0.001))" 
denn compilieren?

"wert_p17==0.150" ist ein Vergleich.
Vermutlich wolltest du "wert_p17=0.150" hier schreiben.

Was soll "(wert_p17++*0.001)" machen?
Ich nehme mal an, es soll "(wert_p17+=0.001)" heissen?

Und was genau soll diese Schleife jetzt hilfreiches machen, ausser dass 
sie dir 4050 Float-Werte zwischen 0.15 und 4.2 auf den Schirm 
printet????


Mit viel Phantasie und einigen runden Glasgegenständen lese ich heraus, 
dass es dir eigentlich darum geht, deine Potiwerte von 0-255 in 
Delay-Werte zwischen 150us und 4200us umrechnen möchtest.

Für das eigentliche Delay nützt dir dann allerdings die Funktion 
"_wait_ms()" wenig.

Weiter sagt mir die Glaskugel, dass du statt "_wait_ms()" eine 
For-Schleife verwenden willst, um Delays im us-Bereich zu bekommen.

Ich sehe in deinem Programm allerdings auch keine Anweisungen, die einen 
Output-Port toggeln würden, damit du deine PWM mit einem Oszilloskop 
sichtbar machen könntest.

Offenbar reicht dir bisher die printf Ausgabe auf deinem Schirm, dass 
die Delay-Werte überhaupt berechnet wurden?

Rätsel,....

[Francis C. (Firma: Privat) (danger19xx)]

Hi Easylife,

das sind sehr wertvolle Hinweise von dir, die ich NIE dazugekommen 
waere.

Du hast eine sehr gute Glaskugel!

Ich folge diese Hinweise und poste meine Ergnisse erneuert.

VG

[Daniel F. (df311)]

und ich frage mich schon seit mindestens 10 Minuten warum oben von 
Leitwerten anstatt von Widerständen die Rede ist. An falsch geschriebene 
Sekunden hätte ich nicht gedacht...

Francis Chaleu schrieb:
> (deshalb die if-loop)

if-schleifen gibt es nicht, hat es noch nie gegeben und wird es auch nie 
geben...

[Rufus Τ. F. (rufus)]

Daniel F. schrieb:
> if-schleifen gibt es nicht, hat es noch nie gegeben und wird es auch nie
> geben...

Das ist bei Programmiersprachen wie bei idiotensicheren Systemen auch:

Hat man erstmal was idiotensicher bekommen, erfinden sie einen besseren 
Idioten ...

[Easylife (Gast)]

Ich kann mir gut vorstellen, dass If-Schleifen irgendwann PLEASE mal in 
INTERCOM auftauchen werden. "COME FROM" gibt's da ja schon ;-)

[Francis C. (Firma: Privat) (danger19xx)]

Soooli...

Oh je!!

Ihr habt mir eine richtige Lektion erteilt (Nie Wieder schreiben oder 
denken, dass "if" eine Schleife ist, auch wenn man es nicht so gemeint 
hat ;) )
Auf jeden Fall bin ich ein Stueck weiser geworden. Danke!!!

Weiser bin ich auch in sofern geworden, da ich anhang die guten Hinweise 
von Easylife das Programm verbessert habe (um ehrlich zu sein, habe 
ich eigentlich die mir gestellte Aufgabe besser verstanden).

Anbei, wie versprochen, das bearbeitete Programm. Ich muss zugeben, dass 
ich mir noch etwa schwer tue, was die for-Schleife (am Ende des 
Programms) anbelangt.

Also mit der For-Schleife soll es moeglich sein, die werte zw. 
150microSekunden und 4200microSekunden darzustellen. Hiermit danke ich 
euch im Voraus fuer die Inputs...

    /**********************************************************************************************************/
    /*  Dieses Programm namens "recht_3.C" gibt ein zeitlich komplett parametrierbares                         */
    /*  Rechtecksignal am Port-Pin P1.0 aus.                                                                   */
    /* Damit kann man waehrend des Betriebs die Breitenwerte des Signals einstellen                            */
    /* -->fuer die positive Impulsbreite tp wird der Trimm-Poti P1.6 im Bereich 1micros bis 10micros verwendet */
    /* -->fuer die negative Impulsbreite tn wird der Trimm-Poti P1.7 im Bereich 1micros bis 10micros verwendet */
    /* Der A/D-Wandler wird im 8-Bit-Modus betrieben                                                           */
    /*                                                                                                         */
    /***********************************************************************************************************/

/*** Einbinden von Include-Dateien ***/
#include<stdio.h>
#include<at89c51cc03.h>

unsigned char bit dIn_out @ 0x90;   // Port-Pin P1.0 bekommt den Variablen-Namen 
                                    //zugeordnet


void main (void)     // Start des Hauptprogramms
{
   float wert_p16, wert_p17;  //Variablen zur Aufnahme des Teilergebnisses von Trimm-Poti p1.6 und p1.7
   float wert;              //Variable zur Aufnahme des zusammengesetzten Gesamtergebnisses

    /**************************************************************/
    /*  Initialisierung der seriellen Schnittstelle 0 des CC03ers */
    /*  Schnittstellenparameter: 9600Baud, 8 Datenbit, 1 Stopp-Bit*/
    /*  asynchroner Betrieb                                       */
    /**************************************************************/
    SCON=0x52;
    TMOD |=0x20;
    TH1=0xfd;
    TR1=1;
    TI=1;
    
    /* Initialisierung des A/D-Wandlers */
    ADCF = 0xc0;    // Port P1.6 und P1.7 als Analogeingang definieren,
                    // d.h., CH6 und CH7 sollen angesprochen werden
    ADCON = 0x20;   // Enable ADC, mit ADEN =1 und
                    // SCH2, SCH1, SCH2 sollen respektiv die Werte 0, 0, 0
                    // um den P1.0 steuern zu können...


    printf("\x1b\x48\x1b\x4a"); //löschen des Bildschirms
 

    /*Endlosschleife*/
    while(1)
    {
        ADCON &= ~0x07;             // Sicher stellen, dass SCH2, SCH1, SCH0 auf null initialisiert sind
        ADCON |= 0x06;              // Auswahl von CH6
        ADCON &= ~0x40;             // Standard Mode
        ADCON = ADCON | 0x08;       // Start der Wandlung
        
        while ((ADCON & 0x10)==0);  //warten bis Wandlung fertig ist

        ADCON = ADCON & 0xef;       // End of Conversion Bit löschen
        wert_p16 = ADDH;            //Ergebnis des eingestellten Wertes von Poti P1.6 speichern

        wert_p16=((wert_p16*10.0)/255.0)+0.04; //Umwandlung in microSekunde mit Skala von 0.040 microSekunden
       
        dIn_out=0; //High Pegel am Port-Pin P1.0
        printf("tp hat den Wert: %3.3f microSekunde\n\n", wert_p16);



        ADCON &= ~0x07;             // Sicher stellen, dass SCH2, SCH1, SCH0 auf null initialisiert sind
        ADCON |= 0x07;              // Auswahl von CH7
        ADCON &= ~0x40;             // Standard Mode
        ADCON = ADCON | 0x08;       // Start der Wandlung
        
        while ((ADCON & 0x10)==0);  //warten bis Wandlung fertig ist

        ADCON = ADCON & 0xef;       // End of Conversion Bit löschen
        wert_p17 = ADDH;             //Ergebnis des eingestellten Wertes von Poti P1.7 speichern
        
        wert_p17=((wert_p17*10.0)/255.0)+0.04; //Umwandlung in microSekunden mit Skala von 0.040 microSekunden

        dIn_out=1; // Low Pegel am Port-Pin P1.0
        printf("tn hat den Wert: %3.3f microSekundes\n\n", wert_p17);


        wert = wert_p16 + wert_p17; //gesamte Impulsbreite tp + tn 

        for(wert=0.15; wert<=4.2; wert+=0.04)
        {
            printf("die gesamte Impulsbreite ist: %3.3f microSekundes\n\n", wert);  //Ausgabe der Impulsbreite
        }
      


    }//end while
    
 

} //end main()

[Easylife (Gast)]

Leider hast du die Aufgabe eben gar nicht verstanden.

Deine printf() Aufrufe musst du rausnehmen. Die brauchen viel zu viel 
Zeit.

Ich versuche dir mal die Aufgabe zu erklären:

Du sollst ein Programm schreiben, das auf einem I/O Pin eine PWM macht, 
die du mit einem Oszilloskop messen kannst.

D.h. du hast dann sowas wie

while(1)
{
  dIn_out=1;    // output pin auf high setzen
  wait(t_on);   // eine gewisse Zeit warten
  dIn_out=0;    // output pin auf low setzen
  wait(t_off);  // wieder eine gewisse Zeit warten
}

Da deine Wartezeiten im Bereich von 150us bis 4200us (=4.2ms) sein 
sollen, kannst du für "wait()" nicht die Funktion "_wait_ms()" nehmen.

Stattdessen wurde dir empfohlen das Delay über eine For-Schleife zu 
machen, und das sieht dann so aus:

void wait(unsigned t)
{
  unsigned i;
  for (i=0; i<t; i++)
    ;
}

D.h. du benutzt einfach eine leere for-schleife, die nichts anderes tut 
als i von 0 bis t zählen zu lassen.
Dafür braucht der Microcontroller eine gewisse Zeit, dadurch entsteht 
ein Delay.
Wie viel Zeit in Abhängigkeit von t vergeht, musst du mit dem 
Oszilloskop messen, und dann t mit einem entsprechenden Faktor 
multiplizieren um auf eine genau definierte Zeit zu kommen.

Es kann auch sein, dass die Schleife so schnell durchläuft, dass du 
damit keine 4200us mehr hinbekommst, in dem Fall musst wait() 
entsprechend mehrmals aufrufen, bzw. 2 Schleifen ineinander schachteln.

Am besten testest du erstmal mal folgendes aus:

  unsigned i;
  unsigned t = 10000;

  while(1)
  {
    dIn_out=1;    // output pin auf high setzen

    for (i=0; i<t; i++)
      ;

    dIn_out=0;    // output pin auf low setzen

    for (i=0; i<t; i++)
      ;
  }

und misst mal die Frequenz auf dem Output pin.
Dann kann man dir weiterhelfen einen entsprechenden Faktor zu berechnen.


Am Ende musst du auch noch berücksichtigen, dass ja dein Potentiometer 
abgefragt werden soll, daher wäre es auch wichtig zu prüfen, ob eine A/D 
Wandlung innerhalb der 150us überhaupt zu machen ist.

[Michael R. (Firma: Brainit GmbH) (fisa)]

Easylife schrieb:
> Stattdessen wurde dir empfohlen das Delay über eine For-Schleife zu
> machen, und das sieht dann so aus:

void wait(unsigned t)
{
  unsigned i;
  for (i=0; i<t; i++)
    ;
}

Ich fürchte nur der Compiler bzw. dessen Optimizer wird dir einen 
gröberen Strich durch die Rechnung machen...

[Easylife (Gast)]

Dann stell halt -O0 ein
;-)

[Francis C. (Firma: Privat) (danger19xx)]

Hoi Zämen,

Vielen Vielen Dank Easylife!

Ich bin nur überrascht, wie du mein Anliegen besser als mich kennst.
Obwohl ich es zigmal gelesen habe, bin ich auf diese Lösung nie 
gekommen.

Aber so gut erklaert und ganz besonders sehr gut detailliert.
Phenomenal und sensationell, wenn man sich sehr gut auskennt ;-)

Danke fuer die investierte Zeit(!), denn es ist nicht immer 
selbsverstaendlich.

Deine Hinweise werde ich im Programm einsetzen und natuerlich sofort 
Posten!!!!

VG

[bones (Gast)]

Moin,

ich möchte dieses Beispiel gern aufgreifen, da ich selber gerade damit 
beschäftigt bin und mir sich dieses Beispiel eines Delay in Form einer 
For-Schleife zwar in der Theorie erschließt, praktisch aber nicht 
funktioniert.
Bei dem von Easylife genannten Wert für t=10000, ergibt sich an Portpin 
1.0 eine Frequenz von 3,55 Hz, was einer Periodendauer T = 282 ms 
entspricht. Bei einem symmetrischen Rechtecksignal wäre tp und tn somit 
T/2 bzw. 141ms.
Um nun die Impulsbreite (tp) und die Impulspause (tn) mit beiden Poti´s 
von 0,150 ms bis 4,2 ms einstellen zu können ist genau welcher Faktor zu 
verwenden?