mit Poti LEDs stufenlos ausgeben

[Djerun (Gast)]

Die LED’s sollen anhand eines Potentiometer-Wertes leuchten. Dabei steht 
jedes LED für 12,5%. Das jeweils nächste LED soll stufenlos hoch, bzw. 
runtergedimmt werden.


Zum leuchten bringe ich sie. Nur nicht Stufenlos.

[Mainboard (Gast)]

Und nun?
Was erwartest Du?

[Djerun (Gast)]

Damit man die LEDs per Micronctroller ansteuern kann und sie stufenlos 
hoch un runter gedimmt werden können

[Udo S. (urschmitt)]

Na dann: Soft-PWM ist dein Zauberwort.

[Der kleine Nils (Gast)]

Djerun schrieb:
> Die LED’s sollen anhand eines Potentiometer-Wertes leuchten.

Klar soweit.

Djerun schrieb:
> Dabei steht
> jedes LED für 12,5%. Das jeweils nächste LED soll stufenlos hoch, bzw.
> runtergedimmt werden.

Jede LED steht für 12,5% und dann "stufenlos" passt nicht zu 100% in 
meine Welt. Sehe ich das richtig, dass die 12,5% das Poti in 
entsprechende Bereiche einteilen und innerhalb des Bereiches die 
jeweilige LED heller bzw. dunkler werden soll? Also wenn quasi der 
maximale Helligkeitsweit on LED X erreicht ist dann startet beginnt die 
nächste LED mit ihrer minimalen Leuchtkraft?

[Djerun (Gast)]

die erste LED soll bei einem Poti stand von 12.5% voll leuchten.
die zweite LED bei 25% des Potis stand voll leucht. usw.

und zwischen diesen werten soll immer die nächste led heller werden.

[Karl H. (kbuchegg)]

Djerun schrieb:
> die erste LED soll bei einem Poti stand von 12.5% voll leuchten.
> die zweite LED bei 25% des Potis stand voll leucht. usw.
>
> und zwischen diesen werten soll immer die nächste led heller werden.


Gut.
Dann kümmere dich mal darum, dass du deine unbekannte Anzahl von LED 
unabhängig voneinander dimmen kannst.

Das Zauberwort 'Soft-PWM' ist ja schon gefallen.
Und ja, du wirst einen Timer dazu brauchen.

FAQ: Timer

[Christian B. (chbalnuweit)]

Ja wie bereits erwähnt: Soft-PWM!
Dein AVR wird kaum 8 PWM-Kanäle haben ;-)

AD-Wert des Poti einlesen und dann entsprechend die Pulsweiten berechnen 
und auf die LEDs geben.

[Djerun (Gast)]

Danke

[Karl H. (kbuchegg)]

Für eine LED an einem AVR könnte eine einfache Software-PWM zb so 
aussehen.

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

#define LED_DDR   DDRB
#define LED_PORT  PORTB
#define LED1_PIN  PB1

volatile uint8_t dimmLed1;

ISR( TIMER0_OVF_vect )       // Overflow Interrupt Vector
{
  static uint8_t pwmCnt;

  pwmCnt++;

  if( dimmLed1 > pwmCnt )
    LED_PORT |= ( 1 << LED1_PIN );
  else
    LED_PORT &= ~( 1 << LED1_PIN );
}
 
int main()
{
  LED_DDR |= ( 1 << LED1_PIN );

  dimmLed1 = 128;  // Helligkeit der LED
 
  TIMSK |= (1<<TOIE0);  // den Overflow Interrupt des Timers freigeben
  TCCR0 = (1<<CS00);    // Vorteiler 1, jetzt zählt der Timer bereits
 
 
  sei();                // und Interrupts generell freigeben

 
  while( 1 )
  {                     // hier braucht nichts mehr gemacht werden.
  }                     // der Timer selbst sorgt dafür, dass die ISR Funktion
}                       // regelmäßig aufgerufen wird

[Djerun (Gast)]

Danke viel mal. Ich werde es versuchen ;)

[(Gast) (Gast)]

All you need auf dem Silbertablett, aber nur weil jetzt Wochenende ist 
:)

http://www.mikrocontroller.net/articles/Soft-PWM
http://www.mikrocontroller.net/articles/LED-Fading
http://www.mikrocontroller.net/articles/AD-Wandler

[dirk h. (Gast)]

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

uint16_t pwmtable[32]={

    0, 1, 2, 2, 2, 3, 3, 4, 5, 6, 7, 8, 10, 11, 13, 16, 19, 23,
    27, 32, 38, 45, 54, 64, 76, 91, 108, 128, 152, 181, 215, 255
};

unsigned char ADC_value=0;
char brightness;
char pwm_count=0;
char LED;




ISR(TIMER0_OVF_vect)
{

  pwm_count++;

  if(pwm_count<brightness)
  {
    PORTB  |=(1<<LED);
  }
  else
  {
    PORTB  &=  ~(1<<LED);
  }

}



int main(void)
{

ADMUX |=(1<<REFS0)|(1<<ADLAR)|(1<<MUX0);
ADCSRA |= (1<<ADEN)|(1<<ADSC)|(1<<ADFR)|(1<<ADPS0)|(1<<ADPS2)|(1<<ADIF);

TCCR0  |=  (1<<CS00);//|(CS02);
TIMSK  |=  (1<<TOIE0);

DDRB=0xff;

sei();

//ADC_value=97;
int x;

  while(1)
  {
    ADC_value=ADCH;
    
    if(ADC_value<32){  PORTB=0x00; LED=0;}
    if((ADC_value>=32)&&(ADC_value<32*2)){  PORTB=0x01;     LED=1;}
    if((ADC_value>=32*2)&&(ADC_value<32*3)){  PORTB|=0x03;    LED=2;}
    if((ADC_value>=32*3)&&(ADC_value<32*4)){  PORTB|=0x07;    LED=3;}
    if((ADC_value>=32*4)&&(ADC_value<32*5)){  PORTB|=0x0f;    LED=4;}
    if((ADC_value>=32*5)&&(ADC_value<32*6)){  PORTB|=0x1f;    LED=5;}
    if((ADC_value>=32*6)&&(ADC_value<32*7)){  PORTB|=0x3f;     LED=6;}
    if((ADC_value>=32*7)&&(ADC_value<32*8)){  PORTB|=0x7f;     LED=7;}

    x=ADC_value%32;
    
    brightness=pwmtable[x];//ADC_value%32;
    

    
    ADCSRA  |=  (1<<ADSC);

  }




}

[dirk h. (Gast)]

die letzte zeile gehört noch raus...

ADCSRA  |=  (1<<ADSC);

[dirk h. (Gast)]

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

uint16_t pwmtable[32]={

    0, 1, 2, 2, 2, 3, 3, 4, 5, 6, 7, 8, 10, 11, 13, 16, 19, 23,
    27, 32, 38, 45, 54, 64, 76, 91, 108, 128, 152, 181, 215, 255
};

char ADC_value=250;
char brightness;
char pwm_count;
char LED=7;
int x;



ISR(TIMER0_OVF_vect)
{

  pwm_count++;

  if(pwm_count<brightness)
  {
    PORTB  |=(1<<LED);
      
  }
  else
  {  
    PORTB&=~(255<<LED);
  }

}

ISR(ADC_vect)
{
    
  ADC_value=ADCH;
    
  LED=ADC_value/32;

    
  brightness=pwmtable[ADC_value%32];
  
  ADCSRA|=(1<<ADSC);
  

}

int main(void)
{

ADMUX |=(1<<REFS0)|(1<<ADLAR)|(1<<MUX0);
ADCSRA |= (1<<ADEN)|(1<<ADPS0)|(1<<ADPS2)|(1<<ADIE)|(1<<ADSC);


TCCR0  |=  (1<<CS00);
TIMSK  |=  (1<<TOIE0);


DDRB=0xff;

sei();


ADCSRA|=(1<<ADSC);

  while(1)

}

[c-hater (Gast)]

Djerun schrieb:

> Zum leuchten bringe ich sie. Nur nicht Stufenlos.

Tja, dann solltest du das vielleicht ändern, wenn "stufenlos" dein Ziel 
ist...

Früher (tm) nannte man die dazu nötige Tätigkeit "programmieren". 
Solltest du vielleicht auch mal versuchen...

Als Tipp: das ist was anderes, als fremden Quelltext per Copy&Paste zu 
übernehmen...