[C] ADC Problem + Software PWM auf Attiny13

[ADC (Gast)]

Hallo Leute,

ich hab folgende Hardware:
PWM Ausgang von Attiny13: PB0
1k POTI an VCC / GND, Schleifer an PB4


Nun möchte ich den Wert vom POTI per ADC abfragen und ihn prozentual als 
PWM ausgeben. Also je nach POTI Stellung den Duty Cicle der PWM ändern.
Folgender Code funktioniert leider nicht, vielleicht kann mir jemand auf 
die Sprünge helfen und ein bisschen was dazu sagen. Wäre nett.

/*
 * AVR_Dimmer.c
 *
 * Created: 30.09.2012 13:26:59
 *  Author: 
 */ 

// interner Oszillator 9,6 Mhz
#define F_CPU 9600000UL

#include <avr/io.h>
#include <avr/interrupt.h>

#define PWM_Output_Port PORTB
#define PWM_Output_Bit 0
#define PWM_Output_DDR DDRB

#define POTI_Input_Port PORTB
#define POTI_Input_Bit 4
#define POTI_Input_DDR DDRB

#define set_bit(var, bit) var |= (1 << bit)
#define clr_bit(var, bit) var &= ~(1 << bit)

uint8_t pwm_counter = 0;
uint8_t volatile pwm_value;
uint16_t adc_in;
uint8_t adc_percent;

int main(void)
{
  
  // Initialisierung
  
  // PWM Output definieren
  set_bit(PWM_Output_DDR, PWM_Output_Bit);
  // ADC Input definieren
  set_bit(POTI_Input_DDR, POTI_Input_Bit);
  
  // ADC initialisieren
  ADCSRA = (1 << ADEN) | (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0);    // ADC aktivieren, Prescaler 128
  ADCSRB = ~(1 << ADTS2) | ~(1 << ADTS1) | ~(1 << ADTS0);  // Free Running Mode
  ADMUX = ~(1 << REFS0) | (1 << MUX1) | ~(1 << MUX0);  // VCC als Referenz, PB4 (ADC2) als Input  
    
  // Timer definieren
  TIMSK0 = (1 << TOIE0);  // Timer0 Overflow Input Enable
  TCCR0B = (1 << CS01);  // Prescaler 8
  TCNT0 = 0;        // Timer Anfangswert 0
  sei();          // Interrupts aktivieren
  
    while(1)
    {
    adc_in = ADCW;  // ADC auslesen
    adc_percent = adc_in / 1024 * 100;
    
    pwm_value = adc_percent / 100 * 255;        
    }
}

// ISR Timer0 Overflow
ISR(TIMER0_OVF_vect) {
  
  pwm_counter++;
  
  if (pwm_value <= pwm_counter) {
    set_bit(PWM_Output_Port, PWM_Output_Bit);
  } else {
    clr_bit(PWM_Output_Port, PWM_Output_Bit);  
  };  
    
}

[kkk (Gast)]

ADC schrieb:
> ADCSRB = ~(1 << ADTS2) | ~(1 << ADTS1) | ~(1 << ADTS0);  // Free Running Mode

Also wenn Du free running nimmst, wo ist dann die passende ISR ?

[ADC (Gast)]

Achso ja dann hab ich das falsch verstanden. Dann muss ich das ändern 
danke.

[ADC (Gast)]

Also ich habe meinen Code nun soweit geändert:

/*
 * AVR_Dimmer.c
 *
 * Created: 30.09.2012 13:26:59
 *  Author: 
 */ 

// interner Oszillator 9,6 Mhz
#define F_CPU 9600000UL

#include <avr/io.h>
#include <avr/interrupt.h>

#define PWM_Output_Port PORTB
#define PWM_Output_Bit 0
#define PWM_Output_DDR DDRB

#define POTI_Input_Port PORTB
#define POTI_Input_Bit 4
#define POTI_Input_DDR DDRB

#define set_bit(var, bit) var |= (1 << bit)
#define clr_bit(var, bit) var &= ~(1 << bit)

void ADC_Init();  // ADC Inititialisierung
uint16_t ADC_Read(uint8_t channel);    // ADC Einzelmessung

uint8_t pwm_counter = 0;
uint8_t volatile pwm_value;
uint16_t volatile adc_in;
uint8_t adc_percent;

int main(void)
{
  
  // Initialisierung
  
  // PWM Output definieren
  set_bit(PWM_Output_DDR, PWM_Output_Bit);
  // ADC Input definieren
  set_bit(POTI_Input_DDR, POTI_Input_Bit);
  
  // ADC initialisieren
  ADC_Init();
    
  // Timer definieren
  TIMSK0 = (1 << TOIE0);  // Timer0 Overflow Input Enable
  TCCR0B = (1 << CS01);  // Prescaler 8
  TCNT0 = 0;        // Timer Anfangswert 0
  sei();          // Interrupts aktivieren
  
    while(1)
    {
    adc_in = ADC_Read(2);  // ADC auslesen
    adc_percent = adc_in / 1024 * 100;
    
    pwm_value = adc_percent / 100 * 255;        
    }
}

// ISR Timer0 Overflow
ISR(TIMER0_OVF_vect) {
  
  pwm_counter++;
  
  if (pwm_value <= pwm_counter) {
    set_bit(PWM_Output_Port, PWM_Output_Bit);
  } else {
    clr_bit(PWM_Output_Port, PWM_Output_Bit);  
  };  
    
}

// ADC Initialisierung
void ADC_Init(void) {
  
  uint16_t result;
  
  // VCC als Referenz
  ADMUX = ~(1 << REFS0);
  
  // Frequenzvorverteiler 128
  ADCSRA = (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0);
  
  // ADC aktivieren
  ADCSRA |= (1 << ADEN);
    
  // Dummy Readout
  
  ADCSRA |= (1 << ADSC);  // eine ADC Wandlung
  while (ADCSRA & (1 << ADSC)) {;};  // auf Abschluss warten
  result = ADCW;  // Ergebnis muss einmal gelesen werden sonst wird die nächste Wandlung nicht übernommen
    
}

// ADC Einzelmessung
uint16_t ADC_Read(uint8_t channel) {

  // Kanal wählen
  ADMUX = (ADMUX & ~(0x1F)) | (channel & 0x1F);
  ADCSRA |= (1 << ADSC);    // eine Wandlung
  while (ADCSRA & (1 << ADSC)) {;};  // auf Ergebnis warten
  
  return ADCW;  // Ergebnis zurückgeben
  
}

Jedoch bekomme ich immer noch kein PWM Signal aus PB0. Sobald ich aber 
mit dem Finger an die Pins PB1 / PB2 komme, so bekomme ich ein PWM 
Signal. Folglich muss was an meiner ADC Routine falsch sein oder?

[holger (Gast)]

// PWM Output definieren
  set_bit(PWM_Output_DDR, PWM_Output_Bit);
  // ADC Input definieren
  set_bit(POTI_Input_DDR, POTI_Input_Bit);

Interessant: Eingang und Ausgang werden also
mit einer Eins im DDR gesetzt? ;)

[ADC (Gast)]

Oh man wie peinlich. Sowas kann auch nur mir passieren.
Leider immer noch das gleiche Phänomen

[Stefan E. (sternst)]

  ADCSRB = ~(1 << ADTS2) | ~(1 << ADTS1) | ~(1 << ADTS0);  // Free Running Mode
  ADMUX = ~(1 << REFS0) | (1 << MUX1) | ~(1 << MUX0);  // VCC als Referenz, PB4 (ADC2) als Input

  ADMUX = ~(1 << REFS0);

Da ist offenbar Nachholbedarf für Bit-Arithmetik, denn keine dieser 
Zeilen macht das, was von dir beabsichtigt ist. Die ADMUX-Zeile z.B. 
setzt das ADLAR-Bit.

    adc_percent = adc_in / 1024 * 100;
    
    pwm_value = adc_percent / 100 * 255;

Und auch bei der Integer-Arithmetik hapert es. Dass zur Zeit überhaupt 
irgendwelche unterschiedlichen Werte in pwm_value stehen, liegt an der 
fehlerhaften ADMUX-Zeile. Wenn die erst mal korrigiert ist, steht da 
immer nur 0 drin.

[ADC (Gast)]

Stefan Ernst schrieb:
> adc_percent = adc_in / 1024 * 100;
>
>     pwm_value = adc_percent / 100 * 255;Und auch bei der Integer-Arithmetik 
hapert es. Dass zur Zeit überhaupt
> irgendwelche unterschiedlichen Werte in pwm_value stehen, liegt an der
> fehlerhaften ADMUX-Zeile. Wenn die erst mal korrigiert ist, steht da
> immer nur 0 drin.

Das kommt davon wenn man noch auf dem PC denkt, wo Floatberechnungen ja 
kein Problem sind. facepalm

[ADC (Gast)]

Also egal ob ich

ADMUX = 0x00

 oder

ADMUX &= ~(1 << REFS0)

 schreibe, ich habe immer noch den gleichen Effekt, dass sich die PWM 
nur dann ändert, wenn ich mit dem Finger auf die Pins PB1 / PB2 vom 
Tiny13 komme.

[ADC (Gast)]

Ok, das Problem mit dem Finger und dem Wert habe ich nun behoben. Mal 
wieder ein peinlicher Fehler den man selber nicht sieht. VCC vom Attiny 
nicht angeschlossen.

Jedoch gibt mein ADC immer noch nix zurück jmd eine Idee?

[ADC (Gast)]

Mit Hardware PWM funktioniert nun alles, auch der ADC

[Borsty B. (mantabernd)]

Hi,

mich würde interessieren wie die Umrechung in Prozent denn nun aussieht?

Würdest du den kompletten, funktinoierenden Code nochmal posten?
Danke!

Gruß

[ADC (Gast)]

Ich habe einen viel einfacheren Weg gewählt.

Ein 10bit Wert geht ja von 0 - 1023 und ein 8bit Wert von 0 - 255. Das 
einfachste zum umwandeln ist dann einfach durch 4 zu teilen.

[Unwissender (Gast)]

ADLAR = 1
Consequently, if
the result is left adjusted and no more than 8-bit precision is 
required, it is sufficient to read ADCH.