Forum: Mikrocontroller und Digitale Elektronik AD-Wandler von AT89C51: Impulsbreite mit zwei Potis einstellen


Announcement: there is an English version of this forum on EmbDev.net. Posts you create there will be displayed on Mikrocontroller.net and EmbDev.net.
von Francis C. (Gast)


Angehängte Dateien:

Lesenswert?

hallo Z'me,

me voici de nouveau...

die Impulsbreite eines Rechtecksignal soll ueber zwei Trimm-Potis 
einstellbar sein. Der Bereich der Einstellung liegt zw. 1ms - 256ms, 
sowohl fuer die negative (t_n) Impulsbreite  als auch fuer die positive 
(t_p) Impulsbreite.
Wobei t_n + t_p die gesamte Impulsbreite formen, sollen sie jedoch 
unabhaengig/getrennt betrieben.

Meine Probleme:
1- Wie kann ich t_n und t_p getrennt betreiben, denn, wenn ich nur t_n 
(poti) einstelle, bekomme ich den Wert2 ausgegeben?
2- nur die Werte (1 u. 2) werden ausgegeben, obwohl ich sie 
Zeiteinstellung berechenet habe und ausgeben moechte

Im Anhang das Beispiel des Herstellers (seite 155) und ein PrintScreen 
anbei mein C-Code
1
/*** Einbinden von Include-Dateien ***/
2
#include <stdio.h>                  // Standard Ein-/Ausgabefunktionen
3
#include <at89c51cc03.h>            // CC03er-Grundregister
4
5
6
/*** Festlegung der benoetigen SFRs ***/
7
//near unsigned char P_1  @  0x90;    // Port P1 als Ganzes festlegeen, d.h. der komplette
8
                                   
9
10
11
12
/********************************************************************************************/
13
/*** Start des Hauptprogramms ***************************************************************/
14
/********************************************************************************************/
15
16
void main (void)     // Start des Hauptprogramms
17
{
18
    /*Definition der benoetigten Variablen*/
19
    unsigned int wert1;// Variable zur Berechnung des A/D-Wandler Ergebnisses an Poti 1-->t_p 
20
    unsigned int wert2;// Variable zur Berechnung des A/D-Wandler Ergebnisses an Poti 2-->t_n
21
    unsigned int t_p;//fuer die positive Imspulsbreite
22
    unsigned int t_n;//fuer die negative Impulsbreite   
23
24
    /**************************************************************/
25
    /*  Initialisierung der seriellen Schnittstelle 0 des CC03ers */
26
    /*  Schnittstellenparameter: 9600Baud, 8 Datenbit, 1 Stopp-Bit*/
27
    /*  asynchroner Betrieb                                       */
28
    /**************************************************************/
29
30
    SCON=0x52;
31
    TMOD |=0x20;
32
    TH1=0xfd;
33
    TR1=1;
34
    TI=1;
35
36
    /* Punkt 2, Analog-/Digital-Wandler initialisieren! */
37
    ADCF = 0xc0;        // Portpin P1.6 und P1.7 als Analogeingaenge definieren
38
    ADCON = 0x20;       // ADC einschalten --> ADEN = 1
39
40
    /* Bildschirm loeschen und Cursor auf Home-Position */
41
    printf("\x1b\x48\x1b\x4a");
42
43
    /* Bildschirm-Ueberschrift */
44
    printf("Programm zuer Einstellung einer Impulsbreite\n");
45
    printf("==================================================\n\n");
46
    //printf("\n\n\n***********Menu*************\n");
47
    printf("\n\n\n   positive Impulsbreite am Port P1.6, Bereich 1- 256ms!");
48
    printf("\n\n   negative Impulsbreite am Port P1.7, Bereich 1- 256ms!");
49
50
    //ADCON &= 0xf8;// alle Kanaele auf null setzen
51
52
    while(1)
53
    {
54
 
55
        if ((ADCON |= 0x06))   // Kanal 6 ausgewaehlt
56
        {
57
            printf("\n\n\n Port P1_6 wird ausgegeben: \n");
58
            ADCON = (ADCON | 0x08);                     // Einmalige Wandlung des ADUs starten!
59
            while((ADCON & 0x10) == 0);                 // Warte bis A/D-Wandlung beendet ist!
60
            ADCON = ADCON & 0xef;                       // Wandlungsendebit ADEOC auf log. 0 setzen!
61
            wert1 = ((ADDH << 2) + (ADDL & 0x03));       // Ergebnisregister auslesen u. zusammenbauen!
62
            t_p = (256 / 1024) * wert1;                  // positive Impulsbreite berechnen!
63
            if (wert1 == 0) t_p = 1;         // Wenn Wert ist null, t_p ist 1 ms (niedrigste Impulsbreite)
64
            if (wert1 > 1024) t_p = 256;     // Wenn Wert groesser 1024, t_p ist 256 ms (hoechstte Impulsbreite)
65
            printf("\x1b\x59\x2c\x34 %u    ", wert1);    // Cursor positionieren und Ergebnis in Dezimal ausgeben
66
            printf("\x1b\x59\x32\x34 %u ms    ", t_p);   // als positive Impulsbreite ausgeben!
67
            _wait_ms(2000);           
68
        }
69
70
        if (ADCON |= 0x07)//Wenn ADU eingeschalten und Kanal 7 ausgewaehlt
71
        {
72
            printf("\n\n\n Port P1_7 wird ausgegeben: \n");
73
            ADCON = (ADCON | 0x08);                     // Einmalige Wandlung des ADUs starten!
74
            while((ADCON & 0x10) == 0);                 // Warte bis A/D-Wandlung beendet ist!
75
            ADCON = ADCON & 0xef;                       // Wandlungsendebit ADEOC auf log. 0 setzen!
76
            wert2 = ((ADDH << 2) + (ADDL & 0x03));       // Ergebnisregister auslesen u. zusammenbauen!
77
            t_n = (256 / 1024) * wert2;                  // positive Impulsbreite berechnen!
78
            if (wert2 == 0) t_n = 1;         // Wenn Wert ist null, t_p ist 1 ms (niedrigste Impulsbreite)
79
            if (wert2 > 1024) t_n = 256;     // Wenn Wert groesser 1024, t_p ist 256 ms (niedrigste Impulsbreite)
80
            printf("\x1b\x59\x2c\x34 %u    ", wert2);    // Cursor positionieren und Ergebnis in Dezimal ausgeben
81
            printf("\x1b\x59\x32\x34 %u ms    ", t_n);   // als positive Impulsbreite ausgeben!
82
            _wait_ms(2000);           
83
        }
84
    }
85
86
    /* Endlosschleife zum ordnungsgemaessen Abschluss des Programms ist
87
       hier nicht mehr notwendig, da ja das Programm selber als End-
88
       losschleife laeuft !
89
    */
90
91
}
92
93
/********************************************************************************************/
94
/*** Ende des Hauptprogramms, d.h. Ende des gesamten Programms! *****************************/
95
/********************************************************************************************/

von Francis C. (Gast)


Lesenswert?

Danke und Gruss

von Nop (Gast)


Lesenswert?

Ist Dir bewußt, daß (256 / 1024) in C eine Integer-Division ist und das 
Ergebnis des Ausdrcukes somit immer 0 ist?

von Francis C. (Gast)


Lesenswert?

Bonsoir Messieurs,

Nop schrieb:
> Ist Dir bewußt, daß (256 / 1024) in C eine Integer-Division ist
> und das
> Ergebnis des Ausdrcukes somit immer 0 ist?

Danke fuer den Hinweis. Ich habe es rausgenommen.

Es funktioniert ein Stueck weit. Aber ich bekomme:

 -maximum 250 ms anstatt 256 ms, was die hoechst positive Impulsbreite 
anbelangt
 -minimum 0 ms anstatt 1 ms, was die niedrigst positive Impulsbreite 
anbelangt

Noch einen Hinweis von euch, bitte?


Ich habe mein Programm wie folgt komplett neu umgeschrieben:
1
/*** Einbinden von Include-Dateien ***/
2
#include <stdio.h>                  // Standard Ein-/Ausgabefunktionen
3
#include <at89c51cc03.h>            // CC03er-Grundregister
4
5
6
/*** Festlegung der benoetigen SFRs ***/
7
//nicht noetig, da im include vorhanden
8
                                   
9
10
11
12
/********************************************************************************************/
13
/*** Start des Hauptprogramms ***************************************************************/
14
/********************************************************************************************/
15
16
void main (void)     // Start des Hauptprogramms
17
{
18
    /*Definition der benoetigten Variablen*/
19
    unsigned char t_p;//Variable zur Ermittlung des A/D-Wandler Ergebnisses an Poti 1-->t_p
20
              //positive Impulsbreite
21
    unsigned char t_n;//Variable zur Ermittlung des A/D-Wandler Ergebnisses an Poti 1-->t_p
22
              //negative Impulsbreite
23
24
    /**************************************************************/
25
    /*  Initialisierung der seriellen Schnittstelle 0 des CC03ers */
26
    /*  Schnittstellenparameter: 9600Baud, 8 Datenbit, 1 Stopp-Bit*/
27
    /*  asynchroner Betrieb                                       */
28
    /********************Punkt 2***********************************/
29
30
    SCON=0x52;
31
    TMOD |=0x20;
32
    TH1=0xfd;
33
    TR1=1;
34
    TI=1;
35
36
    /* Punkt 3: Analog-/Digital-Wandler initialisieren! */
37
    ADCF = 0xc0;        // Portpin P1.6 und P1.7 als Analogeingaenge definieren
38
    ADCON = 0x20;       // ADC einschalten --> ADEN = 1
39
40
    /* Punkt 4: Bildschirm loeschen und Cursor auf Home-Position */
41
    printf("\x1b\x48\x1b\x4a");
42
43
    /* Punkt 5: Bildschirm-Ueberschrift */
44
    printf("Programm zuer Einstellung einer Impulsbreite\n");
45
    printf("==================================================\n");
46
    printf("\n\n\n Der AD-Wandler wird im 8 Bits Modus betrieben.");
47
    printf("\n\n   positive Impulsbreite t_p am Port P1.6, Bereich 1- 256ms!");
48
    printf("\n\n   negative Impulsbreite t_n am Port P1.7, Bereich 1- 256ms!");
49
    printf("");
50
51
    ADCON &= 0xf8;// alle Kanaele auf null setzen
52
 
53
       while(1)
54
       {
55
            if((ADCON & 0xfe)!=0xff)
56
            {            
57
                ADCON &= 0xf8;  //alle Kanaele freimachen
58
                ADCON |= 0x06;  //Kanal 6 auswaehlen
59
                ADCON |= 0x08;  //AD-Wandler starten--> ADSST = 1
60
                while((ADCON & 0x10) == 0);     // Warte bis A/D-Wandlung beendet ist!
61
                ADCON = ADCON & 0xef;           // Wandlungsendebit ADEOC auf log. 0 setzen!
62
                t_p = ADDH;       // Ergebnisregister auslesen
63
64
                printf("\n\n\n die positive Impulsbreite t_p ist: ");
65
                printf("\x1b\x59\x32\x34 %u ms    ", t_p);   // als positive Impulsbreite ausgeben!
66
                
67
                //Um im Bereich 1 - 256ms sicher zu bleiben
68
                if (t_p <1) t_p = 1;
69
                if (t_p >256) t_p = 256;
70
            }
71
72
                
73
            if((ADCON & 0xff)!=0xfe)
74
            {
75
                ADCON &= 0xf8;  //alle Kanaele freimachen
76
                ADCON |= 0x07;  //Kanal 6 auswaehlen          
77
                ADCON |= 0x08;  //AD-Wandler starten-->ADSST = 1 
78
                while((ADCON & 0x10) == 0);     // Warte bis A/D-Wandlung beendet ist!
79
                ADCON = ADCON & 0xef;           // Wandlungsendebit ADEOC auf log. 0 setzen!
80
                t_n = ADDH;     // Ergebnisregister auslesen
81
                                    //und um eins erhoehen
82
                                    //damit die Impulsbreite im Bereich bleibt
83
84
                printf("\n\n\n die negative Impulsbreite t_n ist: ");
85
                printf("\x1b\x59\x32\x34 %u ms    ", t_n);   // als negative Impulsbreite ausgeben!
86
87
                //Um im Bereich 1 - 256ms sicher zu bleiben
88
                if (t_n <1) t_n = 1;
89
                if (t_n >256) t_n = 256;
90
91
            }
92
            _wait_ms(2000);
93
        }
94
       
95
96
    /* Endlosschleife zum ordnungsgemaessen Abschluss des Programms ist
97
       hier nicht mehr notwendig, da ja das Programm selber als End-
98
       losschleife laeuft !
99
    */
100
101
}
102
103
/********************************************************************************************/
104
/*** Ende des Hauptprogramms, d.h. Ende des gesamten Programms! *****************************/
105
/********************************************************************************************/

von tommy (Gast)


Lesenswert?

Francis C. schrieb:
> if (t_p >256) t_p = 256;

t_p ist unsigned char und kann Werte von 0 bis 255 annehmen.

von tommy (Gast)


Lesenswert?

Hallo,
bist Du weiter gekommen?

t_n betrifft das natürlich auch.

a la prochaine

von Francis C. (Gast)


Lesenswert?

Hello Zusammen,

anbei die Loesung, falls jemand doch am Ueberlegen ist...

Jedoch brauche ich einen kleinen Tip:
ich soll jetzt die Zeit der beiden Potis so einstellen, dass sie 
zwischen 150micro.Sek und 4200micro.Sek liegen. die vom Hersteller 
programmierte delay-Funktion _wait_ms() ist nur fuer millisekunkden 
gedacht. Zum feintuning habe ich deshalb die for-Schleife 
(Zeitverzoegerungschleife) wie und angewendet, aber der Oszilloskop gibt 
minimum 2ms Zeitperiode und nicht 150 micro-Sekunde. Was soll ich hier 
nochmal beruecksichtigen?

--->Danke schon mal fuer die Inputs...
1
            t_p = (4200.0 / 256) * aktuellerWert;
2
3
            if(t_p < 150) t_p = 150;        //unterer Wert 150micro sek.
4
            if(t_p > 4200) t_p = 4200;      //oberer wert 4200micro sek.
5
            for(i=0; i<=t_p; i++)          //Zeitverzoegerungsschleife

Anbei die Loesung der ersten Aufgabe, wie vorhin gesagt
1
/*** Einbinden von Include-Dateien ***/
2
#include <stdio.h>                  // Standard Ein-/Ausgabefunktionen
3
#include <at89c51cc03.h>            // CC03er-Grundregister
4
5
6
/*** Festlegung der benoetigen SFRs ***/
7
unsigned char bit OUT @ 0x90;
8
                                   
9
10
/********************************************************************************************/
11
/*** Start des Hauptprogramms ***************************************************************/
12
/********************************************************************************************/
13
14
void main (void)     // Start des Hauptprogramms
15
{
16
    /*Definition der benoetigten Variablen*/
17
    unsigned int t_p;   //Variable zur Ermittlung des A/D-Wandler Ergebnisses an Poti 1-->t_p
18
                        //positive Impulsbreite
19
    unsigned int t_n;   //Variable zur Ermittlung des A/D-Wandler Ergebnisses an Poti 1-->t_p
20
                        //negative Impulsbreite
21
    unsigned char aktuellerWert;    //Hilfsvariable
22
23
    /**************************************************************/
24
    /*  Initialisierung der seriellen Schnittstelle 0 des CC03ers */
25
    /*  Schnittstellenparameter: 9600Baud, 8 Datenbit, 1 Stopp-Bit*/
26
    /*  asynchroner Betrieb                                       */
27
    /********************Punkt 2***********************************/
28
29
    SCON=0x52;
30
    TMOD |=0x20;
31
    TH1=0xfd;
32
    TR1=1;
33
    TI=1;
34
35
    /* Punkt 3: Analog-/Digital-Wandler initialisieren! */
36
    ADCF = 0xc0;        // Portpin P1.6 und P1.7 als Analogeingaenge definieren
37
    ADCON = 0x026;      // ADC einschalten-->ADEN = 1
38
                        //und Kanal 6 auswaehlen
39
          
40
41
    /* Punkt 4: Bildschirm loeschen und Cursor auf Home-Position */
42
    printf("\x1b\x48\x1b\x4a");
43
44
    /* Punkt 5: Bildschirm-Ueberschrift */
45
    printf("Programm zuer Einstellung einer Impulsbreite\n");
46
    printf("==================================================\n");
47
    printf("\n\n\n Der AD-Wandler wird im 8 Bits Modus betrieben.");
48
    printf("\n\n   positive Impulsbreite t_p am Port P1.6, Bereich 1- 256ms!");
49
    printf("\n\n   negative Impulsbreite t_n am Port P1.7, Bereich 1- 256ms!");
50
    printf("");
51
52
    //ADCON &= 0xf8;// alle Kanaele auf null setzen
53
 
54
       while(1)
55
       {
56
            /*Hier wird die Einstellung von t_n mithilfe des Trimm-Potis an P1.7 durchgefuehrt*/
57
            ADCON &= 0xfe;  //Kanal 6 auswaehlen;
58
            OUT = 1;
59
            
60
            ADCON |= 0x08;  //AD-Wandler starten--> ADSST = 1
61
            while((ADCON & 0x10) == 0);     // Warte bis A/D-Wandlung beendet ist!
62
            ADCON = ADCON & 0xef;           // Wandlungsendebit ADEOC auf log. 0 setzen!
63
            aktuellerWert = ADDH;           // Ergebnisregister auslesen, nur Im 8 Bits-Modus betrieben
64
                                            // ADDL wird daher nicht benoetigt
65
            t_p = aktuellerWert+1;          // zur Vermeidung, dass t_p den Wert null bekommt und
66
                                            // und mindest Wert von eins hat.
67
            _wait_ms(t_p);                  // t_p als Uebergabeparameter
68
69
           /*Hier wird die Einstellung von t_n mithilfe des Trimm-Potis an P1.7 durchgefuehrt*/
70
            OUT = 0; 
71
            ADCON |= 0x01;      // Umschalten auf Kanal 7 (Trimm-Poti an P1.7)
72
                                // dies erfolgt durch die letzte Bit-Aenderung
73
                                // des aktuellen Wert im ADCON
74
                                        
75
            ADCON |= 0x08;      // AD-Wandler starten-->ADSST = 1 
76
            while((ADCON & 0x10) == 0);     // Warte bis A/D-Wandlung beendet ist!
77
            ADCON = ADCON & 0xef;           // Wandlungsendebit ADEOC auf log. 0 setzen!
78
            aktuellerWert = ADDH;           // Ergebnisregister auslesen, nur im 8 Bits-Modus betrieben
79
                                            // ADDL wird daher nicht benoetigt
80
            t_n = aktuellerWert+1;      //zur Vermeidung, dass t_n den Wert null bekommt und
81
                                        //und mindest Wert von eins hat.
82
            _wait_ms(t_n);              //t_n als Uebergabeparameter
83
        }
84
       
85
86
    /* Endlosschleife zum ordnungsgemaessen Abschluss des Programms ist
87
       hier nicht mehr notwendig, da ja das Programm selber als End-
88
       losschleife laeuft !
89
    */
90
91
}
92
93
/********************************************************************************************/
94
/*** Ende des Hauptprogramms, d.h. Ende des gesamten Programms! *****************************/
95
/********************************************************************************************/

von Francis C. (Gast)


Lesenswert?

Bonsoir tout le monde,

ich habe mein Programm verbessert und es scheint richtig zu sein, aber 
bitte natuerlich jemand, einen Blick darauf zu werfen. Ansonsten ist es 
abgeschlossen.

anbei den Code
1
/*** Einbinden von Include-Dateien ***/
2
#include <stdio.h>                  // Standard Ein-/Ausgabefunktionen
3
#include <at89c51cc03.h>            // CC03er-Grundregister
4
5
6
/*** Festlegung der benoetigen SFRs ***/
7
unsigned char bit OUT @ 0x90;
8
                                   
9
10
/********************************************************************************************/
11
/*** Start des Hauptprogramms ***************************************************************/
12
/********************************************************************************************/
13
14
void main (void)     // Start des Hauptprogramms
15
{
16
    /*Definition der benoetigten Variablen*/
17
    unsigned int t_p;   //Variable zur Ermittlung des A/D-Wandler Ergebnisses an Poti 1-->t_p
18
                        //positive Impulsbreite
19
    unsigned int t_n;   //Variable zur Ermittlung des A/D-Wandler Ergebnisses an Poti 1-->t_p
20
                        //negative Impulsbreite
21
    unsigned char aktuellerWert;    //Hilfsvariable fuer den ADDH
22
    
23
    unsigned int i;//Zaehlvariable...
24
25
26
    /**************************************************************/
27
    /*  Initialisierung der seriellen Schnittstelle 0 des CC03ers */
28
    /*  Schnittstellenparameter: 9600Baud, 8 Datenbit, 1 Stopp-Bit*/
29
    /*  asynchroner Betrieb                                       */
30
    /********************Punkt 2***********************************/
31
32
    SCON=0x52;
33
    TMOD |=0x20;
34
    TH1=0xfd;
35
    TR1=1;
36
    TI=1;
37
38
    /* Punkt 3: Analog-/Digital-Wandler initialisieren! */
39
    ADCF = 0xc0;        // Portpin P1.6 und P1.7 als Analogeingaenge definieren
40
    ADCON = 0x026;      // ADC einschalten-->ADEN = 1
41
                        //und Kanal 6 auswaehlen
42
          
43
44
    /* Punkt 4: Bildschirm loeschen und Cursor auf Home-Position */
45
    printf("\x1b\x48\x1b\x4a");
46
47
    /* Punkt 5: Bildschirm-Ueberschrift */
48
    printf("Programm zuer Einstellung einer Impulsbreite\n");
49
    printf("==================================================\n");
50
    printf("\n\n\n Der AD-Wandler wird im 8 Bits Modus betrieben.");
51
    printf("\n\n   positive Impulsbreite t_p am Port P1.6, Bereich 150- 4200micro-Sekunden!");
52
    printf("\n\n   negative Impulsbreite t_n am Port P1.7, Bereich 150- 4200micro-Sekunden!");
53
    printf("");
54
55
    //ADCON &= 0xf8;// alle Kanaele auf null setzen
56
 
57
       while(1)
58
       {
59
            /*Hier wird die Einstellung von t_n mithilfe des Trimm-Potis an P1.7 durchgefuehrt*/
60
            ADCON &= 0xfe;  //Kanal 6 auswaehlen;
61
            OUT = 1;
62
            
63
            ADCON |= 0x08;  //AD-Wandler starten--> ADSST = 1
64
            while((ADCON & 0x10) == 0);     // Warte bis A/D-Wandlung beendet ist!
65
            ADCON = ADCON & 0xef;           // Wandlungsendebit ADEOC auf log. 0 setzen!
66
            aktuellerWert = ADDH;           // Ergebnisregister auslesen, nur Im 8 Bits-Modus betrieben
67
                                            // ADDL wird daher nicht benoetigt
68
69
            t_p = (4200 / 256) * aktuellerWert;//positive Impulsbreite berechnen
70
71
            if(aktuellerWert < 9) t_p = 150;        //unterer Wert 150micro sek.
72
            for(i=0; i<=aktuellerWert; i++);          //Zeitverzoegerungsschleife
73
           
74
75
           /*Hier wird die Einstellung von t_n mithilfe des Trimm-Potis an P1.7 durchgefuehrt*/
76
            OUT = 0; 
77
            ADCON |= 0x01;      // Umschalten auf Kanal 7 (Trimm-Poti an P1.7)
78
                                // dies erfolgt durch die letzte Bit-Aenderung
79
                                // des aktuellen Wert im ADCON
80
                                        
81
            ADCON |= 0x08;                  // AD-Wandler starten-->ADSST = 1 
82
            while((ADCON & 0x10) == 0);     // Warte bis A/D-Wandlung beendet ist!
83
            ADCON = ADCON & 0xef;           // Wandlungsendebit ADEOC auf log. 0 setzen!
84
            aktuellerWert = ADDH;           // Ergebnisregister auslesen, nur im 8 Bits-Modus betrieben
85
                                            // ADDL wird daher nicht benoetigt
86
            t_n = (4200 / 256) * aktuellerWert; // negative Impulsbreite berechnen
87
88
            if(aktuellerWert < 9) t_n = 150;        //unterer Wert von 150micro sek.
89
            for(i=0; i<=aktuellerWert; i++);          //Zeitverzoegerungsschleife
90
             
91
        }
92
       
93
94
    /* Endlosschleife zum ordnungsgemaessen Abschluss des Programms ist
95
       hier nicht mehr notwendig, da ja das Programm selber als End-
96
       losschleife laeuft !
97
    */
98
99
}
100
101
/********************************************************************************************/
102
/*** Ende des Hauptprogramms, d.h. Ende des gesamten Programms! *****************************/
103
/********************************************************************************************/

von Francis C. (Gast)


Lesenswert?

A la prochaine...

von Peter D. (peda)


Lesenswert?

Francis C. schrieb:
> for(i=0; i<=aktuellerWert; i++);          //Zeitverzoegerungsschleife

Wie kommst Du darauf, daß diese Schleife genau n*1µs dauert und alle 
anderen Programmteile nichts dauern?

Nimm doch einfach das PCA und setze das Vergleichsregister 
(CCAPnH,CCAPnL) bei jedem Interrupt auf die gewünschte Zeit. Das PCA 
kann auch Pins direkt togglen (P1.3-P1.7) oder Du machst es auch im 
Interrupt.
Den ADC kann man bequem im Main wandeln lassen, das kostet dann keine 
zusätzliche Zeit. Man kann aber auch den ADC-Interrupt nehmen.

P.S.
Lange Quelltexte immer als Anhang!
Man scrollt sich sonst zu Tode (siehe hier).

: Bearbeitet durch User

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.