ATmega32 ADC vraag

[Verwijderd]

Ik heb een stukje code geschreven om de werking van de AD Converter op de ATmega32(L) te leren kennen.

De code heeft gewerkt en was eerst uitgebreid tot 4 if statements zodat bij stijgende spanning steeds meer uitgangen hoog gezet werden (en ook weer laag als de spanning op poort PA6 daalde).

Maar nu werkt de code niet meer (waarschijnlijk heb ik iets weggehaald maar ik zie niet wat) en ik krijg het met geen mogelijkheid meer werkend.

ziet iemand wat ik vergeet / fout doe?!:

code:

#include <avr/io.h>
#include <util/delay.h>

#define IsPinHigh(PORT, PIN) (((PORT>>PIN) & 0x01) == 0x01)  //input op pin controleren
int i=0;

int main (void)

{
    DDRA |= (1<<PA0 | 1<<PA1 | 1<<PA2 | 1<<PA3); // Set LED1 as output
    DDRB |= (1 << PB0 );

    ADCSRA |= (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0); // Set ADC prescaler to 128 - 125KHz sample rate @ 16MHz

    ADMUX |= (1 << REFS0);
    ADMUX |= (1 << REFS1);
    ADMUX |= (1 << ADLAR);   // Left adjust ADC result to allow easy 8 bit reading
    ADMUX |= (1 << MUX2);     //ADC op poort PA6 gebruiken
    ADMUX |= (1 << MUX1);     //ADC op poort PA6 gebruiken

    ADCSRA |= (1 << ADEN);  // Enable ADC

    ADCSRA |= (1 << ADSC); // Start A2D Conversions

    while (1) // Loop Forever
        {
            unsigned short spanning = ADC;
            if (spanning <40000)
            {
                PORTA |= (1<<PA1);
            }
            else
            {
            PORTA &= ~(1<<PA1);
            }
        }
}

[Sprite_tm]

Wat werkt er precies niet 'Hij doet 't niet' is niet echt een goede probleembeschrijving. Werkt je LEDje+outputpinnetje nog wel, en zoja, heb je dat getest? Blijft je led bij deze code aan of gaat 'ie uit? Heb je je AD-register-settings al gechecked? In andere woorden: wat heb je al geprobeerd en wat waren daar de resultaten van?

Het is hier in EL nogt net niet zo strikt als in de software-subfora, waar zo'n topic met een kwak sourcecode en de vraag 'waarom werkt 't niet' dichtgedaan zou worden, maar wat extra info is toch wel nodig wil dit topic in EL viable zijn.

Nog even wat meer ingaand op je code: als ik er zo snel even overheen lees, start je alleen een enkele conversie buiten je main loop, en heb je verder geen autotriggering aanstaan. Dan zal 'ie alleen de waarde pakken als de AVR aangezet is en doet 'ie inderdaad niet wat je denkt.

[ Voor 20% gewijzigd door Sprite_tm op 08-05-2009 09:35 ]

[mux]

Sterker nog, door jezelf gestructureerd af te vragen wat er in je chain of events fout kan gaan kom je waarschijnlijk vrij snel bij het probleem uit.

[Verwijderd]

Het was dus gewoon inderdaad dat de conversie in mijn main loop gestart moest worden, nou werkt het.

Ik ben nog niet echt lang bezig met programmeren van microcontrollers en ik vind het vrij lastig om voor simpele dingetjes als dit een oplossing te vinden op internet, ik vindt dan meestal weer vrij ingewikkelde dingen of code die niet in C zijn (C is het enige waarmee ik geprogrammeerd hebt met microcontrollers).

En als ik code uit andere voorbeelden pak die ik niet helemaal begrijp krijg je dus fouten zoals deze omdat ik niet weet wat sommige code doet.

De fout was dus dat het eerst wel werkte, dat hij schakelde als de waarde van de ADC onder of boven de 4000 kwam. Toen zaten er meerdere if statements in (ook bij 2000 en 6000), maar toen ik dus de if statements had terug gebracht naar 1 werkte het niet meer. Het deed niks meer (dacht ik).

Wat hij eigenlijk nog wel deed was 1 keer die waarde pakken en aan de hand daarvan PA1 hoog of laag zetten, maar dit had ik nog niet gemerkt en daarom stond dat er ook niet bij.

In ieder geval bedankt want het heeft me weer vooruit geholpen!

[Sprite_tm]

Het probleem wat je waarschijnlijk hebt is dat je door middel van shotgun debugging (proberen 'aan te voelen' waar het probleem ligt, en zoniet trial&error er dichterbij proberen te komen) een bestaand programma probeert om te werken. Als je in het vervolg nog es tegen zo'n probleem aanloopt, probeer dan eens van elke regel code precies uit te zoeken wat er gebeurt. Kan best zijn dat je zolang je nog beginner bent voor elke bit de datasheets in moet duiken en dat elke regel je 5 minuten kost; uiteindelijk vind je fouten zoals deze gegarandeerd en is de kennis van bijvoorbeeld in dit geval de AD-converter een stuk toegenomen.

[Verwijderd]

@ Sprite_tm

Ik heb het nu allemaal nagezocht en ben opnieuw begonnen met code die ik dus zelf geschreven heb met commentaar zodat duidelijker is of ik alles wel goed begrepen heb.

ik heb nu de volgende code:

code:

#include <avr/io.h>

int
main(void)
{
    DDRA |= (1<<PA0); // PA0 is output

    ADMUX |= (1 << REFS0);  //Vergelijken met intern 2.56V Voltage (geen condensator op AREF pin)
    ADMUX |= (1 << REFS1);
    ADMUX |= (1 << MUX2);   // Op poort PA6 staat een variabele spanning
    ADMUX |= (1 << MUX1);

    ADCSRA |= (1 << ADEN);  // ADC mogelijk maken

    ADCSRA |= (1 << ADSC);  // Start AD conversation
    while (1)
    {
        unsigned short spanning = ADC;

        if (spanning > X)
        {
            PORTA |= (1<<PA0);
        }
        else
        {
            PORTA &= ~(1<<PA0);
        }
    }
}

Als ik nu de spanning op PA6 verander dan wordt poort PA0 op hoog gezet boven 0.2V ongeveer. Maakt niet uit welk getal ik bij X invoer (ik heb van 1000 tot 60000 geprobeerd en van alles ertussen).

Maar nu zit ik dus weer vast ik weet nu wat alles doet maar ik zie niet waarom die waarde in de if statement aanpassen geen effect heeft

[Sprite_tm]

Errm, weet je 100% zeker dat het bovenstaande de code is die je hebt staan? Er zit namelijk nog steeds dezelfde bug in

[Verwijderd]

Neej sorry

Dit is de code die ik nu heb:

code:

#include <avr/io.h>

int
main(void)
{
    DDRA |= (1<<PA0); // PA0 is output

        ADMUX |= (1 << REFS0);  //Vergelijken met intern 2.56V Voltage (geen condensator op AREF pin)
        ADMUX |= (1 << REFS1);
        ADMUX |= (1 << MUX2);   // Op poort PA6 staat een variabele spanning
        ADMUX |= (1 << MUX1);

        ADCSRA |= (1 << ADEN);  // ADC mogelijk maken
        

    while (1)
    {
        ADCSRA |= (1 << ADSC);  // Start AD conversation
        unsigned short spanning = ADC;

        if (spanning > X )
        {
            PORTA |= (1<<PA0);
        }
        else
        {
            PORTA &= ~(1<<PA0);
        }
    }
}

de conversie wordt gestart binnen mijn while loop.
Ik heb geen externe condensator aan mijn AREF poort hangen omdat ik die hier geen heb maar in een ander topic zei iemand dat dit niet per-se nodig is.

Maar hij blijft schakelen bij +/- 0.2V op PA6. Maakt niet uit wat ik bij X invul

[Verwijderd]

Je moet wel even wachten tot de AD converter klaar is, voordat je de waarde uitleest. Zoek het ADIF vlaggetje op, die wordt hoog als de AD converter klaar is.

60000 bij X invullen heeft natuurlijk ook geen zin, je AD converter is maar 10 bits.

[Sprite_tm]

Hoe heb je de AREF wel aangesloten dan? Niet toevallig aan de ground gehangen? Kan je (met een multimeter) es meten wat er op AREF staat?
En nog iets: je start je AD-conversie wel elke keer, maar je wacht nooit tot 'ie afgelopen is. Wat gebeurt er als je een

C:

while(ADCSRA&(1 << ADSC)) ;

achtergooit? (Die bit word namelijk 0 zodra de conversie klaar is, is makkelijker dan ADIF te checken.)

En inderdaad, je hebt je left-adjust-bit-set-code weggehaald, je moet er dus wel rekening mee houden dat je resultaat maar 10bits is en niet verder dan 1024 gaat.

[ Voor 29% gewijzigd door Sprite_tm op 08-05-2009 14:01 ]

[Verwijderd]

@ real_Firefly
Dat dacht ik ook maar ik heb dus eerst een testprogramma geschreven om de werking van ADC te leren begrijpen.
Was een vergelijkbaar programma als dit (maar wat wel werkte), met dat programma ben ik waardes gaan invoeren en die heb ik vergeleken met de spanning die op de poort stond. ik kwam tot de 61000 bij 2.44 V, 50000 bij 2V en 10000 bij 0,2V (en nog meer tussenliggende waardes maar zo heb je een beeld waarom ik 60000 gebruikte om te testen).
Maar misschien dat ik het toen anders heb gedaan dat weet ik niet meer (is weer paar weken geleden heb ondertussen paar andere projectjes gehad). Ik heb inderdaad dus de left adjust bit weg gehaald alleen ik zat totaal niet op te letten . Maar voor de verdere werking zou dit volgens mij geen effect moeten hebben behalve dat ik naar minder grote waardes moet zoeken toch?

En ik ga nu kijken naar dat ADIF.
Maar ik heb om de spanning te regelen op poort PA6 een spanningsdeler met een potmeter zodat ik gewoon kan draaien om de spanning te veranderen. Als ik nu het programma start en ik ga draaien zodat de spanning op PA6 boven de 0.2V komt dan wordt PA0 hoog, als ik dan terug draai en de spanning komt onder de 0,2V wordt PA0 weer laag.
Als de ADC niet klaar zou zijn zou hij toch eigenlijk helemaal niet moeten schakelen of zie ik dit verkeerd?

Edit:
@ Sprite_tm
Als ik op AREF meet staat er 2.62V op. De AREF zit verder nergens op aangesloten en dan meet ik de ground en de AREF pin als plus.
En met die while loop kan ik niet helemaal volgen waar ik die neer zou moeten zetten, hij gaat dan toch juist alleen uitvoeren wat er in die while loop staat als de ADC nog bezig is? want zodra die 0 wordt gaat die uit die loop?

[ Voor 21% gewijzigd door Verwijderd op 08-05-2009 14:16 ]

[Sprite_tm]

Verwijderd schreef op vrijdag 08 mei 2009 @ 14:05:
[...]
En met die while loop kan ik niet helemaal volgen waar ik die neer zou moeten zetten, hij gaat dan toch juist alleen uitvoeren wat er in die while loop staat als de ADC nog bezig is? want zodra die 0 wordt gaat die uit die loop?

En dat is helemaal de bedoeling: je wilde toch wachten tot de AD-converter klaar is? Let vooral ook op de ; achter de while-loop: hij doet dus niets totdat de AD-conversie klaar is.

[Verwijderd]

Ja ik had het volgens mij al begrepen

code:

#include <avr/io.h>

int
main(void)
{
    DDRA |= (1<<PA0); // PA0 is output

        ADMUX |= (1 << REFS0);  //Vergelijken met intern 2.56V Voltage (geen condensator op AREF pin)
        ADMUX |= (1 << REFS1);
        ADMUX |= (1 << MUX2);   // Op poort PA6 staat een variabele spanning
        ADMUX |= (1 << MUX1);

        ADCSRA |= (1 << ADEN);  // ADC mogelijk maken
        

    while (1)
    {
        ADCSRA |= (1 << ADSC);  // Start AD conversation
        while(ADCSRA&(1 << ADSC));

                unsigned short spanning = ADC;
        {
        }
        if (spanning > 1000)
        {
            PORTA |= (1<<PA0);
        }
        else
        {
            PORTA &= ~(1<<PA0);
        }
    }
}

Zo staat dat toch goed of niet? eerst de conversie starten, wachten tot die klaar is en de waarde in de variabele zetten en dan verder gaan met het programma.

Maar nog steeds heb ik hetzelfde probleem

[Sprite_tm]

...Niet helemaal. Mijn while-ding is een enkel statement, dus de tab voor unsigned short etc hoeft niet, netzoals de { } erna overbodig is. (Je hele indentation is trouwens wat vreemd, hethele rijtje ADMUX hoort ook een tab eerder te staan.)

Verder lijkt je code nu OK te zijn, dus als ik jou was zou ik de hardware eens beginnen te verdenken, misschien dat je daar wat in kan vinden, of misschien is het zoiets lulligs als de verkeerde AVR in je makefile of ide hebben staan.

[mux]

Verwijderd schreef op vrijdag 08 mei 2009 @ 14:05:
@ real_Firefly

Edit:
@ Sprite_tm
Als ik op AREF meet staat er 2.62V op. De AREF zit verder nergens op aangesloten en dan meet ik de ground en de AREF pin als plus.

Dit is ook niet goed. AREF zweeft. Zodra aref ge-comparet wordt met één van je ADC-bits zal hij daar naartoe getrokken worden. Je moet AREF aan je Vcc hangen, anders loopt alles sowieso in de soep.

[Verwijderd]

Ik had de tabs al aangepast en de {} al weg gehaald, zag het ook toen ik later nog een keer mijn bericht terug las.

@ hierboven op Vcc (dit is toch pin 30 van de uC?) staat 5 volt. Op AREF staat 2,62 moet ik die volgens jou gewoon aan elkaar hangen?

de code zoals ik hem nu heb is dus zo:

code:

#include <avr/io.h>

int
main(void)
{
    DDRA |= (1<<PA0); // PA0 is output

    ADMUX |= (1 << REFS0);  //Vergelijken met intern 2.56V Voltage (geen condensator op AREF pin)
    ADMUX |= (1 << REFS1);
    //ADMUX |= (1 << ADLAR); // Left adjust ADC result to allow easy 8 bit reading
    ADMUX |= (1 << MUX2);   // Op poort PA6 staat een variabele spanning
    ADMUX |= (1 << MUX1);

    ADCSRA |= (1 << ADEN);  // ADC mogelijk maken
        
    while (1)
    {
        ADCSRA |= (1 << ADSC);  // Start AD conversation

        while(ADCSRA&(1 << ADSC));

        unsigned short spanning = ADC;

        if (spanning > 1000)
        {
            PORTA |= (1<<PA0);
        }
        else
        {
            PORTA &= ~(1<<PA0);
        }
    }
}

De indentation (weer wat geleerd ) is zo wel goed toch?

Ik zal wel naar de hardware te gaan kijken maar dat wordt na het weekend want dit weekend heb ik geen tijd meer

[mux]

Ja en ja. (antwoord op beide vragen )

[Comp-Freak]

Aref is intern toch aan vcc te hangen, of 2,56 volt ofzo? Dan kan je hem zwevend laten, of met een C-tje naar de ground voor betere prestaties.

quote: datasheet

Internal reference voltages of nominally 2.56V or AVCC are provided On-chip. The voltage reference
may be externally decoupled at the AREF pin by a capacitor for better noise performance.

[Verwijderd]

Ik ben nu alle hardware aan het nakijken, en ga denk ik toch maar een condensator aan de AREF hangen.

Maar wat ik zo gek vindt is dat het wel gewerkt heeft, en dat er geen veranderingen zijn aangebracht in de hardware zo ver ik weet. Maar ik ga alles loshalen voor zover mogelijk en een keer opnieuw aansluiten en hopelijk is het dan verholpen!

[Verwijderd]

Ik ben er alweer een aantal uurtjes mee bezig geweest en had het gister zo ver dat het al beter werkte!
Ik had alles wat ik aan de microcontroller had hangen los gehaald en alleen de voeding, de spanningsdeler en 1 uitgang aangesloten en toen werkte het.

De waarde in de if statement had effect op het moment van schakelen (het programma schakelde bij een waarde van 1000 in de if statement als bij een lage spanning en bij een waarde van 30000 bij een veel hogere spanning).

Toen ik dingen ging proberen met meerdere uitgangen werkte het helaas niet meer, ook niet meer toen ik weer terug ging naar 1 uitgang.

Ik heb geen idee wanneer het niet meer werkt, dus wat er verkeerd zit. Heeft iemand ideen waar ik eens naar kan kijken?

de code die ik nu gebruik:

code:

#include <avr/io.h>

int main(void)
{
    DDRA |= (1<<PA0);

    while (1)                           // Oneindige loop
    {
        ADCSRA |= (1 << ADEN);              // ADC mogelijk maken

        ADMUX |= (1 << REFS0);              // Vergelijken met intern 2.56V Voltage (geen condensator op AREF pin)
        ADMUX |= (1 << REFS1);

        ADMUX |= (1 << ADLAR);              // Left adjust ADC result to allow easy 8 bit reading

        ADMUX |= (1 << MUX2);               // Op poort PA6 staat een variabele spanning
        ADMUX |= (1 << MUX1);

        
        ADCSRA |= (1<<ADSC);            // Start AD Conversie

        while(ADCSRA&(1 << ADSC));      // Wacht totdat de conversie klaar is
        
        unsigned short spanning = ADC;  // Digitale waarde opslaan in warmte
        
        if (spanning > 10000)               // Als warmte boven een bepaalde waarde komt wordt PA0 hoog gezet
        {
            PORTA |= (1<<PA0);
        }
        else
        {
            PORTA &= ~(1<<PA0);         // Als wartme niet meer hoog genoeg is wordt PA0 laag
        }
    }
}

Maar als ik deze code laat runnen op de microcontroller dan wordt PA0 altijd hoog en blijft hoog (verandert niet als spanning op PA6 verandert). Ook de spanning op PA6 als het programma opstart maakt geen verschil.

[Verwijderd]

Waarom initialiseer je de AD converter elke keer opnieuw?
Waarom gebruik je left adjust?
Heb je AVCC aan VCC gehangen?

[Verwijderd]

Ik initialisser de AD converter niet meer elke keer opnieuw, ik heb van alles geprobeerd waarom de code die gister wel werkte het nu niet meer deed en had daarom het initialiseren ook in de while loop gezet maar dat staat nu alweer in de main loop.

Ik gebruik left adjust omdat ik begonnen ben met een programmatje waar dat ook in zat en toen heb ik alle waardes vergeleken (dus welke digitale waarde hoort bij welke spanning) en daarom ben ik die weer gaan gebruiken.

En waarom zou ik nu AVCC aan VCC moeten hangen? een aantal posts geleden zei je nog de AREF aan VCC. Maar ik heb geen van beide gedaan.

Wat ik volgens de data sheet wel moet doen is aan de AREF een condensator hangen, dit heb ik ook niet gedaan omdat in een ander topic iemand zei dat dat wel nauwkeuriger is maar dat het niet perse nodig is.

[Verwijderd]

Verwijderd schreef op dinsdag 12 mei 2009 @ 13:20:


En waarom zou ik nu AVCC aan VCC moeten hangen? een aantal posts geleden zei je nog de AREF aan VCC. Maar ik heb geen van beide gedaan.

AVCC moet altijd aan VCC hangen, staat in de datasheet.

Volgens mij heb ik nergens gezegd dat AREF an VCC moet hangen. Sterker nog, dat mag absoluut niet als je de interne referentie gebruikt.

[Verwijderd]

ssj3gohan schreef op vrijdag 08 mei 2009 @ 16:31:
[...]


Dit is ook niet goed. AREF zweeft. Zodra aref ge-comparet wordt met één van je ADC-bits zal hij daar naartoe getrokken worden. Je moet AREF aan je Vcc hangen, anders loopt alles sowieso in de soep.

Maar AVCC hangt wel aan VCC. Is al de hele tijd zo geweest dus daar ligt het niet aan, ik zei eerder van niet maar de ATmega32 zit op een printje waar de AVCC is doorgelust naar de VCC. Ik had niet goed gekeken toen ik zei dat dat nie zo was

[ Voor 16% gewijzigd door Verwijderd op 12-05-2009 14:10 ]

[Jewest]

waarom elke keer:
unsigned short spanning = ADC;
en niet gewoon 1 keer boven in unsigned short spanning?
waarschijnlijk haalt je compiler dit er uit maar ik zou er niet van uit gaan.
Haal de instellingen van je AD conversie uit je while lus.

Heel stom idee maar misschien werkt het.
probeer eens:
while((ADCSRA&(1 << ADSC)) == 0); // Wacht totdat de conversie gestart is
while(ADCSRA&(1 << ADSC)); // Wacht totdat de conversie klaar is
Het kan zijn dat je AD conversie nog niet eens gestart is.

Kijk ook even wat er in je object/link file staat, het kan zijn dat je compiler je while lus er uit heeft geoptimaliseerd.

Het is al weer tijden geleden dat ik met de atmel heb geprutst.

[Verwijderd]

Dit is de code zoals ik hem nu heb

code:

#include <avr/io.h>

int main(void)
{
    DDRA |= (1<<PA0);

    ADCSRA |= (1 << ADEN);              // ADC mogelijk maken

    ADMUX |= (1 << REFS0);              // Vergelijken met intern 2.56V Voltage (geen condensator op AREF pin)
    ADMUX |= (1 << REFS1);

    ADMUX |= (1 << ADLAR);              // Left adjust ADC result to allow easy 8 bit reading

    ADMUX |= (1 << MUX2);               // Poort PA6 wordt gebruikt voor omzetting Analoog naar Digitaal
    ADMUX |= (1 << MUX1);

    while (1)                           // Oneindige loop
    {   
        ADCSRA |= (1<<ADSC);            // Start AD Conversie

        while(ADCSRA&(1 << ADSC));      // Wacht totdat de conversie klaar is
        
        unsigned short spanning = ADC;  // Digitale waarde opslaan in warmte
        
        if (spanning < 100)             // Als warmte boven een bepaalde waarde komt wordt PA0 hoog gezet
        {
            PORTA |= (1<<PA0);
        }
        else
        {
            PORTA &= ~(1<<PA0);         // Als wartme niet meer hoog genoeg is wordt PA0 laag
        }
    }
}

De instellingen van de ad conversie zijn uit mijn while lus (zoals ik hierboven ook al gezegd heb).

En die unsigned short staat toch goed? want zo wordt er telkens opnieuw een waarde ingezet. Anders zou die de hele tijd dezelfde waarde als in het begin zijn.

Ik zal nu proberen of dat wachten tot de conversie gestart is werkt.

Ik ben nog niet zo heel lang bezig met de ATmega, ik ben sowieso nog niet zo heel lang bezig met microcontrollers in het algemeen, en ik heb niet echt een idee wat je bedoelt met de object/ link file?


edit:
Dat Wachten totdat conversie gestart is maakt geen verschil

[ Voor 7% gewijzigd door Verwijderd op 12-05-2009 14:44 ]

[Jewest]

Het is netter om het volgende te doen:

code:

int main(void)
{
   unsigned short spanning;  // declaratie van locale var

   while(1)
   {
      spanning = ADC;
   }   

}

Je C code wordt in assembler code omgezet en dan naar machine instructies.
Vaak wordt de assembler code op schijf opgeslagen en niet verwijdert.
kijk even met wordpad of notepad in alle files, ik dacht dat het obj files waren.
je zult dan je c code boven de assembler instructies vinden, soms worden stukken code niet in assembler door gevoerd omdat je compiler deze er uit optimaliseert.

welke ide gebruik je?

[Verwijderd]

Jewest schreef op dinsdag 12 mei 2009 @ 14:53:
Het is netter om het volgende te doen:

code:

int main(void)
{
   unsigned short spanning;  // declaratie van locale var

   while(1)
   {
      spanning = ADC;
   }   

}

Je C code wordt in assembler code omgezet en dan naar machine instructies.
Vaak wordt de assembler code op schijf opgeslagen en niet verwijdert.
kijk even met wordpad of notepad in alle files, ik dacht dat het obj files waren.
je zult dan je c code boven de assembler instructies vinden, soms worden stukken code niet in assembler door gevoerd omdat je compiler deze er uit optimaliseert.

welke ide gebruik je?

Ik heb de spanning nu ook boven gedeclareerd.

Ik kan de bestanden niet vinden.

En mijn ide is de compiler? Ik gebruik de AVR Dragon programmer en AVR studio voor het schrijven van mijn programma. Of bedoel je dit niet.

edit: De uC was kapot daarom werkte het niet. Andere uC en alles doet het. Iedereen in ieder geval bedankt voor alle hulp

[ Voor 6% gewijzigd door Verwijderd op 12-05-2009 15:43 ]