Spannung auslesen

OK,


Bin auf etwas gekommen:

Bei meinen Schleifenprogrammen ging ja weder die for- noch die while- Schleife.


Durch Zufall kam ih gestern drauf, das ich vergessen hatte, mittels DDRB die PINs als Ausgänge zu deklarieren!! Ein Fehler, der mich nun schon Wochen geplagt und zurückgeworfen hat...

Nun gehen simple schleifen wie:

Code:

---

int i;
int hunderterstelle=5; // z.B. 5
DDRB=0b00001111; //Wichtig!!!!!!

main()
{
for(i=0;i<hunderterstelle;i++)
{
PORTB=PORTB|(1<<PB1);
waitMs(100);
PORTB=PORTB&(~(1<<PB1));
waitMs(100);
}
}

---

Und auch in der Schaltung gehts hervorragend.


Wenn ich aber die Schleife unten an mein ADC-Auswerteprogramm hänge, dann passiert in der Schaltung genau nie etwas.

Ich hatte mir gedacht, dass ich im Programm was falsch mache, aber nun, nachdem die Schleife geht, passiert immer noch nix...

Daher habe ich geschrieben if (spannung==0) {...}
und siehe da, die LEDs mit diesem 'Morsecode' leuchten auf!!



Früher hatte ich jedoch, wie bereits hier beschrieben, die Messbereiche des ADCs gedrittelt, und das funktionierte auch prima. Nur halt, dass er 1) keine Spannung direkt rechnen konnte, 2) Dass es nur 3 Codes geben konnte, statt mit einer Schleife der hunderterstelle entsprechend zu blinken.
Also halt: viel Strom, mittel oder wenig, das konnte er sagen.


Also, nun zeigt der ADC offensichtlich immer 0, egal ob ich auf + , - oder auf gar nichts lege.
Da ich den ADC mit der selben Batterie des ATtiny versorge, kann das nicht sein, es sollten rund etwas unter 1,5V (oder 1500mV, Programm teilt durch 100 -> also 15 mal blinken) rauskommen

Poste mal das komplette Programm.

Dieses Programm war das, was ich eigentlich machen wollte

Code:

---

//----------------------------------------------------------------------
// Titel    : Spannung messen AVR-C
//----------------------------------------------------------------------
// Funktion  : Misst Spannung
// Schaltung : erstmals Minimalbeschaltung
//----------------------------------------------------------------------
// Prozessor : Attiny13
// Takt                : 3.6864 MHz
// Sprache  : C
// Datum    : 03.08.2010
// Version  : 1
// Autor    :
//----------------------------------------------------------------------
#define        F_CPU 3686400        // Taktfrequenz des myAVR-Boards
#include        <avr\io.h>                // AVR Register und Konstantendefinitionen
#include    <inttypes.h>
//----------------------------------------------------------------------

uint16_t readADC(uint8_t channel)
{
        // Funktion 1 zum Auslesen der Spannung

        uint8_t i;                  // Variablen definieren (Zählervariable i + Resultat)
        uint16_t result = 0;

        ADCSRA = (1<<ADEN)|(1<<ADPS2)|(1<<ADPS1); //ADEN = ADC Enable
        // wenn adps1+2 on sind und adps0 off, dann ist der Teilungsfaktor 64 (Tabelle Datasheet)

        ADMUX = channel; //Kanal wählen; REFs0+1 -> interne Referenz 2,56V verwenden, REFS1 gibt es bei Attiny13 nicht
        //externen Kondensator mit 100nF (Aufdruck 104) an AREF auf Masse

        //Dummy-Readout (unten), misst 1* Ergebnis, wird nicht gespeichert
        ADCSRA = ADCSRA | (1<<ADSC); // Schaltet bei ADCSRA das ADSC-Bit ein, d.h. Messung starten
        while(ADCSRA & (1<<ADSC)); //Warte bis Messvorgang vorbei ist

        // Nun 3* Spannung auslesen, Durchschnittswert ausrechnen
        for (i=0; i<3; i++)
        {
                // Schleife, startet 3*
                ADCSRA = ADCSRA |(1<<ADSC); // Einmal messen
                while(ADCSRA & (1<<ADSC));  //Warte bis Messung vorbei

                result = result + ADCW; // Resultate zusammenzählen (R1+R2+R3) -> später alles /3
        }

        ADCSRA = ADCSRA & (~(1<<ADEN)); //ADC wieder deaktivieren

        result=result/3;    // Durchschnittswert

        return result;
}

main ()                                                // Hauptprogramm, startet bei Power ON und Reset
{
        int spannung; //Definiere Ganzzahl-Variable Spannung
        int einer,zehner, hunderter, startwert, mittelwert, endwert;
        int i=0;
        int j =0;
        int k =0;

        while (true)
        {

                uint16_t result = readADC(0); // ruft die ADC Funktion auf an Pin0 =ADC0

                spannung = result*3086;
                spannung = spannung/1000;

                startwert=spannung/10;
                hunderter=startwert/100;
                mittelwert=startwert-100*hunderter;
                zehner=mittelwert/10;
                endwert=mittelwert-10*zehner;
                einer=endwert;

                for (i=0;i<(einer);i++)
                {
                        DDRB=0b00001111;
                        PORTB=PORTB|(1<<PB0);
                        waitMs(50);
                        PORTB=PORTB&(~(1<<PB0));
                        waitMs(50);
                }

                for (j=0;j<(zehner);j++)
                {
                        DDRB=0b00001111;
                        PORTB=PORTB|(1<<PB1);
                        waitMs(50);
                        PORTB=PORTB&(~(1<<PB1));
                        waitMs(50);
                }

                for (k=0;k<(hunderter);k++)
                {
                        DDRB=0b00001111;
                        PORTB=PORTB|(1<<PB2);
                        waitMs(50);
                        PORTB=PORTB&(~(1<<PB2));
                        waitMs(50);
                }

                waitMs(1100);

        }

        return 0;
}
//----------------------------------------------------------------------

---

Als das nicht ging (besser gesagt nichts passierte), schrieb ich zahlreiche Testprogrammen, wie z.b. dass er nur die Hunderterstelle ausgeben sollte, sonst das gleiche wwie oben. Als das auch nicht ging, sollte er hunderter und Zehner schreiben (Wie gesagt, ich rechne in mV, das durch 10-> 125 (1-2-5) dh. 1,25V)

Code:

---

if (spannung==0)  // Problem: spannung = laut adc immer 0
                {
                        PORTB=PORTB|(1<<PB1)|(1<<PB2);
                        waitMs(330);
                        PORTB=PORTB&(~(1<<PB1));
                        waitMs(80);
                        PORTB=PORTB|(1<<PB2);
                        waitMs(80);
                        PORTB=PORTB&(~(1<<PB2));
                        waitMs(80);
                }

---

Das dazugefügt führt immer dazu, dass das Passiert, also muss ADC immer gleich null sein...


Auch das hier

Code:

---

//----------------------------------------------------------------------
// Titel    : Spannung messen AVR-C
//----------------------------------------------------------------------
// Funktion  : Misst Spannung
// Schaltung : erstmals Minimalbeschaltung
//----------------------------------------------------------------------
// Prozessor : Attiny13
// Takt                : 3.6864 MHz
// Sprache  : C
// Datum    : 03.08.2010
// Version  : 1
// Autor    :
//----------------------------------------------------------------------
#define        F_CPU 3686400        // Taktfrequenz des myAVR-Boards
#include        <avr\io.h>                // AVR Register und Konstantendefinitionen
#include    <inttypes.h>
//----------------------------------------------------------------------

uint16_t readADC(uint8_t channel)
{
        // Funktion 1 zum Auslesen der Spannung

        uint8_t i;                  // Variablen definieren (Zählervariable i + Resultat)
        uint16_t result = 0;

        ADCSRA = (1<<ADEN)|(1<<ADPS2)|(1<<ADPS1); //ADEN = ADC Enable
        // wenn adps1+2 on sind und adps0 off, dann ist der Teilungsfaktor 64 (Tabelle Datasheet)

        ADMUX = channel; //Kanal wählen; REFs0+1 -> interne Referenz 2,56V verwenden, REFS1 gibt es bei Attiny13 nicht
        //externen Kondensator mit 100nF (Aufdruck 104) an AREF auf Masse

        //Dummy-Readout (unten), misst 1* Ergebnis, wird nicht gespeichert
        ADCSRA = ADCSRA | (1<<ADSC); // Schaltet bei ADCSRA das ADSC-Bit ein, d.h. Messung starten
        while(ADCSRA & (1<<ADSC)); //Warte bis Messvorgang vorbei ist

        // Nun 3* Spannung auslesen, Durchschnittswert ausrechnen
        for (i=0; i<3; i++)
        {
                // Schleife, startet 3*
                ADCSRA = ADCSRA |(1<<ADSC); // Einmal messen
                while(ADCSRA & (1<<ADSC));  //Warte bis Messung vorbei

                result = result + ADCW; // Resultate zusammenzählen (R1+R2+R3) -> später alles /3
        }

        ADCSRA = ADCSRA & (~(1<<ADEN)); //ADC wieder deaktivieren

        result=result/3;    // Durchschnittswert

        return result;
}

main ()                                                // Hauptprogramm, startet bei Power ON und Reset
{
        int spannung; //Definiere Ganzzahl-Variable Spannung
        int einer,zehner, hunderter, startwert, mittelwert, endwert=0;
        int i=0;

        DDRB=0b00001111;

        while (true)
        {

                uint16_t result = readADC(0); // ruft die ADC Funktion auf an Pin0 =ADC0

                spannung = result*3086;
                spannung = spannung/100000; // zB. 15 = 1500mV

                PORTB=PORTB|(1<<PB1); //kurzer LED - Test
                waitMs(10);
                PORTB=PORTB&(~(1<<PB1));
                waitMs(100);

                if (spannung==0)  // Problem: spannung = laut adc immer 0
                {
                        PORTB=PORTB|(1<<PB1)|(1<<PB2);
                        waitMs(330);
                        PORTB=PORTB&(~(1<<PB1));
                        waitMs(80);
                        PORTB=PORTB|(1<<PB2);
                        waitMs(80);
                        PORTB=PORTB&(~(1<<PB2));
                        waitMs(80);
                }

                if ((spannung>0)&(spannung<=15))
                {
                        PORTB=PORTB|(1<<PB1);
                        waitMs(100);
                        PORTB=PORTB&(~(1<<PB1));
                        waitMs(100);

                }

                if ((spannung>15)&(spannung<40))
                {
                        PORTB=PORTB|(1<<PB2);
                        waitMs(100);
                        PORTB=PORTB&(~(1<<PB2));
                        waitMs(100);

                }

                if (spannung>40)
                {
                        PORTB=PORTB|(1<<PB1);
                        waitMs(100);
                        PORTB=PORTB&(~(1<<PB1));
                        waitMs(100);
                        PORTB=PORTB|(1<<PB2);
                        waitMs(100);
                        PORTB=PORTB&(~(1<<PB2));
                        waitMs(100);

                }

                waitMs(1100);

        }

        return 0;
}

//----------------------------------------------------------------------

---

zeigt immer 0 an.

So, jetzt habe ich den Code (der nicht geht) so umgeschrieben, dass er nicht mehr die Spannung ausrechnet, sondern den ADC Wert ausgibt.

wieder mit for-Schleife.


Dieses mal habe ich vier Widerstände, und siehe da:

Vor dem Ersten zeigt er 1020 an (Einerstelle nicht ausgegeben), beim 2ten 760, beim 3tten 510 und dann kommt das Problem: Danach zeigt er nichts an, obwohl ja noch ein Wiederstand dahinter ist.


Also: er MÜSSTE 256 anzeigen, tut er aber einfach nicht!!! Wieso gibt es sowas????