AD-Wandlung

[espoir (Gast)]

Hallo,
entschuldigung habe ich mir das Erlaubnis dir zu schreiben.
ich habe dein asm-code in Mikrocontroller-codesammlung gelesen, und ich
habe schon diese Frage schon gestellt und bis jetzt komme nicht zu recht
.
ich benutze ein ATtiny45,und nur ein Kanal(ADC3),AD-Wandler
fonktionniert schon, nur jetzt möcht'ich die Messungen abtasten 20
mal(in ein Feld speicheren) und zwischen Messungen warte ich ein
bestimmte Zeit(50ms), aber das Problem widr die gleiche Wert
gespeichert, und mit Breakpoint krieg'ich schon das richtiges
Ergebnis.
ich habe schon mit Zeit herumspielt, aber ohne wirkung.
ich habe dein asm-code in Mikrocontroller-codesammlung gelesen , aber
ich habe keine Ahnung mit asm,kann mir jemand dabei helfen, ich glaube
das betrefft mein Problem, unter ADC- Wandlung.
soll ich mit normal, oder free running arbeiten?
wenn ja, ich habe den Datashet durch gelesen, und ich soll den ADCSRB
Register einsetzen, aber nach die Rechnung finde ich sass er soll auf 0
eingesetzt werden,d.h ändert sich nichts,was mach'ich falsch weiss'ich
auch nicht mehr.

danke euch

[espoir (Gast)]

kann jemand mir dabei helfen?

[Nils (Gast)]

Hallo espoir,

Mit Breakpoints funktioniert es also so wie Du willst. Nur wenn der
Controller frei läuft, bekommst Du immer den gleichen Wert.

Hmm... Ich würde sagen Dein Timing stimmt nicht. Wartest Du zwischen
den Messungen genügend lange? Was ist das für ein Signal, das Du da
mißt?

Beschreibe doch mal, was Du da machst. Vielleicht kannst Du ja auch den
Quelltext posten.

Gruß, Nils

[espoir (Gast)]

ich messe den Differenzdruck, die als Spannung an AD-Wandler liegt.
mit Timer habe ich verschiedene möglichkeiten ausprobiert,ich meine von
klein bis grossen Werte.
meinst du nicht dass es was mit free running und normal running zu tun
hat.ich schecke hier den quell code

#include "timer.h"
#include <iot45v.h>
#pragma interrupt_handler int_timer0:iv_TIMER0_OVF

unsigned int volatile count=0;
//void wait_10ms(unsigned char time)
unsigned int volatile wait_10ms(unsigned int time)
{
  count=0;
  TCNT0 = 173;          //10ms
  SREG |= (1<<7);       //SREG:Bit 7 – I: Global Interrupt Enable
  TIMSK = (1<<TOIE0);//Timer0 Int. Enable
  //TCCR0B = (1<<CS02);     //Preskaler:256
  TCCR0B = (1<<CS02)|(1<<CS00);
  while(count<time);
  TCCR0B = 0x00;
  return count;


}

void int_timer0(void)
{
  //PORTB=0x17;
  count++;
  TCNT0 = 173;
  TCCR0B = (1<<CS02)|(1<<CS00);
}


/*void get_sensor(void)
{
 //Adc_Init();
 //umsetzen_Spannung();
 } */


/****************adc.c********************/

#include "adc.h"
#include <iot45v.h>

unsigned int volatile Ergebnis;

void Adc_Init(void)
   {
     ADCSRA = 0xC0;           //Durch das setzen von Bit ADEN schaltet
Der AD-Umsetzer ein
   ADMUX = 0x03;           //wählt der Kanal(ADC3) und setzt die
Rferenzspannung auf 5v
  }

unsigned int umsetzen_Spannung(void)
  {
    ADCSRA = 0xD6;                  //AD-Umsetzer Starten und Prescaler
auswählen
  while ( ADCSRA & (1<<ADSC));      //Warte-Schleife bis Ende der
Umsetzung
  Ergebnis=(ADCL+(ADCH<<8));
  PORTB=0x17;
  //return (ADCL+ADCH*256);
  return Ergebnis;       // Im ADCL sind die ersten 8 bits des
Ergebnisses
                        // Im ADCH sind die restlichen 2 Bits
gespeichert

  }

/***********************main.c*********************/

#include <iot45v.h>
#include "adc.h"
#include "timer.h"
//void int_timer0(void);
//#pragma interrupt_handler int_timer0:iv_TIMER0_OVF

unsigned int volatile Ergebnis1,Ergebnis2;
//void get_sensor(void);
unsigned int digital_wert,i;
unsigned int volatile test[20];

//int Ergebnis;

/*void Adc_Init(void)
   {
     ADCSRA = 0x80;           //Durch das setzen von Bit ADEN schaltet
Der AD-Umsetzer ein
   ADMUX = 0x03;           //wählt der Kanal(ADC3) und setzt die
Rferenzspannung auf 5v
  }

 umsetzen_Spannung(void)
  {


    ADCSRA = 0xC3;                  //AD-Umsetzer Starten und Prescaler
auswählen
  while ( ADCSRA & (1<<ADSC));    //Warte-Schleife bis Ende der
Umsetzung
  Ergebnis = ADCL+ADCH*256;       // Im ADCL sind die ersten 8 bits des
Ergebnisses
                                  // Im ADCH sind die restlichen 2 Bits
gespeichert
  return Ergebnis;
  }*/

int Umrechnung(int Druck)
  {
   digital_wert =5.4894 * Druck;
   digital_wert = digital_wert + 57.294;

   return  digital_wert;
   }


void main()
{

   //PORTB=0x17;
   Adc_Init();
   DDRB=0x17;
   PORTB=0x00;
   // while(1)

   wait_10ms(25);
   for(i=0;i<20;i++)
   {
    test[i]= umsetzen_Spannung();
  ADCSRA=0;
    wait_10ms(50);
  PORTB=0x00;
  wait_10ms(50);
   }
   Ergebnis1 = umsetzen_Spannung();
   wait_10ms(200);
   PORTB=0x00;
   wait_10ms(300);
   Ergebnis2 = umsetzen_Spannung();
   wait_10ms(500);
   PORTB=0x00;

   /*for(i=0; i<=19; i++)
   {
        wait_10ms(500);
        test[i]= umsetzen_Spannung();
    //ergebnis1=test[i];
        wait_10ms(1000);
    PORTB=0x17;
    //ergebnis2 = umsetzen_Spannung();
    wait_10ms(1000);
    PORTB=0x00;
    //PORTB=0x17;
  }*/
  //Umrechnung(53);
  //if (Ergebnis > digital_wert)
  while(1);
   }

[Nils (Gast)]

Hallo Espoir,

ich kenne mich mit dem Tiny45 nicht aus, aber ich kann nicht erkennen,
wo Du den Interrupt quittierst. Muß man da nicht irgendwo ein flag
löschen?

Gruß, Nils

PS: Bitte keinen wilden Debug-Code posten, da blickt nun wirklich
keiner  mehr durch...

[espoir (Gast)]

ich glaube nicht.
für den code ist ganz einfach, in timer.c benutze den Timer0 und jedes
10 ms wird ein Interrupt ausgelöst,mit wait fonction warte ein längere
Zeit(mehrfach von 10 ms),
in for schleife wird die messungen 20 mal ausgelesen, und im Feld test
gespeichert,zwischen zwei Messungen warte ich 50*10=500 ms.