ATNEL tech-forum

Re: PWM atmega 16

2017-01-08T18:34:47+01:00

@ShutDownSystem

Zapytam z ciekawości czy działa teraz prawidłowo, po ustawieniu preskalera na 1?

Statystyki: Napisane przez anshar — 8 sty 2017, o 18:34

Re: PWM atmega 16

2017-01-08T18:19:29+01:00

Witam

fifi_22 napisał(a):

tylko "rozwaliłeś" mnie tym pytaniem

Bynajmniej nie było to moim zamiarem - myślałem że pokazując ten fragment kodu masz jeszcze gdzieś to pwm_red, pwm... tylko nie wiesz jak to podstawiać/obliczać.

Pozdr.

Statystyki: Napisane przez kicajek — 8 sty 2017, o 18:19

Re: PWM atmega 16

2017-01-06T17:49:35+01:00

Witam
Zadałem pytanie a kol.fifi_22 się obraził i nie odpowiedział.
Jeśli chciałbyś pomysłu jak napędzać licznik tablicy kolorów, to ja wcisnąłem go w programową obsługę PWM'a.
To co zamieszczam nie jest niczym górnolotnym; liczenie tablicy jak i "długość" koloru jest dla każdej barwy inna i jeśli na początku startują razem, to już po kilku obiegach te liczniki rozjeżdżają się i kolor pływa.
Do swoich celów możesz dołożyć jeszcze jeden kolor - droga otwarta.
Nie mogę znaleźć rev.1-B w którym to program wykluczał całkowite zgaszenie "trójLED'a", ale na początek...
[syntax=c]/*
* main.c
*
* Created on: 4 lip 2014
* Author: Andrzej
* ATmega8 8MHz - wew.
*/
#include
#include
#include
#include

#define LED_R_DIR DDRB
#define LED_R_PIN (1<#define LED_R_PORT PORTB
#define LED_R_ON PORTB |= LED_R_PIN
#define LED_R_OFF PORTB &= ~LED_R_PIN

#define LED_G_DIR DDRB
#define LED_G_PIN (1<#define LED_G_PORT PORTB
#define LED_G_ON PORTB |= LED_G_PIN
#define LED_G_OFF PORTB &= ~LED_G_PIN

#define LED_B_DIR DDRB
#define LED_B_PIN (1<#define LED_B_PORT PORTB
#define LED_B_ON PORTB |= LED_B_PIN
#define LED_B_OFF PORTB &= ~LED_B_PIN

#define STEEP 200 // prędkość zmiany kolorów

#define GAMMA(a) (pgm_read_byte(&gamma_correctionR[a])) // macro for RED

const uint8_t gamma_correctionR[] PROGMEM = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5,
5, 5, 5, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 9, 9, 9, 10, 10,
11, 11, 11, 12, 12, 13, 13, 13, 14, 14, 15, 15, 16, 16, 17, 17, 18, 18,
19, 19, 20, 20, 21, 21, 22, 23, 23, 24, 24, 25, 26, 26, 27, 28, 28, 29,
30, 30, 31, 32, 33, 33, 34, 35, 36, 36, 37, 38, 39, 39, 40, 41, 42, 43,
44, 45, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
61, 62, 63, 64, 65, 67, 68, 69, 70, 71, 72, 73, 75, 76, 77, 78, 79, 81,
82, 83, 85, 86, 87, 88, 90, 91, 92, 94, 95, 97, 98, 99,101,102,104,105,
107,108,110,111,113,114,116,117,119,121,122,124,125,127,129,130,132,134,
135,137,139,141,142,144,146,148,149,151,153,155,157,159,161,162,164,166,
168,170,172,174,176,178,180,182,184,186,188,190,192,195,197,199,201,203,
205,208,210,212,214,217,219,221,223,226,228,230,233,235,237,240,242,245,
247,250,252,255
};

void in_out_init (void);
void timer2_init(void);

void kolor_R(void);
void kolor_G(void);
void kolor_B(void);

uint16_t led_R, led_G, led_B; // licznik kroków kolorów
volatile uint8_t licz_R, licz_G, licz_B; // nr komórki tablicy
volatile uint8_t clock, clock_flag;

int main (void){

timer2_init();
in_out_init ();

sei();
while(1){

if(clock_flag){

if(0 ==clock%3){

kolor_R();
}

if(1 ==clock%3){

kolor_G();
}

if(2 ==clock%3){

kolor_B();
}

clock_flag=0;

} // END clock_flag

} // END while

} // END main

ISR(TIMER2_COMP_vect) // obsługa pwm programowy

{

static uint8_t cnt;
static uint16_t takt;
if (cnt >= GAMMA(licz_R)) LED_R_ON; else LED_R_OFF; //dioda R
if (cnt >= GAMMA(licz_G)) LED_G_ON; else LED_G_OFF; //dioda G
if (cnt >= GAMMA(licz_B)) LED_B_ON; else LED_B_OFF; //dioda B

cnt++;
takt++;
if(takt >STEEP){ // STEEP - ustawiane w #define
takt =0;
clock_flag =1;
clock ++;
}
}

void in_out_init (void){
LED_R_DIR |= LED_R_PIN;
LED_G_DIR |= LED_G_PIN;
LED_B_DIR |= LED_B_PIN;
}

void timer2_init(void){

TCCR2 |= (1 << WGM21); // tryb CTC multipleksera
TCCR2 |= (1<TIMSK |= (1<
OCR2 = 20;

}

void kolor_R(void){

led_R ++;
if(led_R> 1280) led_R =0;

if(led_R <256) licz_R =led_R;
else if(led_R >255 && led_R < 769) licz_R =255;
else if(led_R >768 && led_R <1024) licz_R = (1024 -led_R);
else licz_R =0;

}

void kolor_G(void){

led_G ++;
if(led_G> 1285) led_G =0; // +5 do R

if(led_G <256) licz_G =led_G;
else if(led_G >255 && led_G < 774) licz_G =255;
else if(led_G >773 && led_G <1029) licz_G = (1029 -led_G);
else licz_G =0;

}

void kolor_B(void){

led_B ++;
if(led_B> 1290) led_B =0; // +5 do G

if(led_B <256) licz_B =led_B;
else if(led_B >255 && led_B < 779) licz_B =255;
else if(led_B >778 && led_B <1034) licz_B = (1034 -led_B);
else licz_B =0;

}

/* * * I T O B Y B Y Ł O N A T Y L E * * */[/syntax]

Trochę to rozlazłe, ale dla celów poglądowych przepisałem to do jednego pliku.

Pozdr.

Statystyki: Napisane przez kicajek — 6 sty 2017, o 17:49

Re: PWM atmega 16

2017-01-06T00:27:15+01:00

Ustaw preskaler na 1.

Statystyki: Napisane przez anshar — 6 sty 2017, o 00:27

Re: PWM atmega 16

2017-01-05T22:53:04+01:00

Witam serdecznie!
Akurat robię akrylową lampkę i chciałbym, aby również zmieniała płynnie kolory, ale bardzo powoli.

Wymyśliłem, aby przemieszczać się w przestrzeni barw HSV, aby maksymalnie uprościć pętlę główną. Dla szybko zmieniających się kolorów program działa wyśmienicie, ale gdy ustawię ustawię czas kroku na dłuższy, o wiele dłuższy, diody LED tak jakby w przeskakują, przejścia nie działają płynnie, nie działa to ładnie. Wstawiam kodzik, HSV daje duże możliwości, z resztą pan Mirek gdzieś już o tym wspominał.

[syntax=c]/*
* main.c
*
* Created on: 21 gru 2016
* Author: SDS
*/

#include
#include
#include
#include
#include

uint8_t RED1=255,GREEN2=255,BLUE3=255;
uint8_t i = 0;

// ------ gamma RED = 1,0
const uint8_t gamma_correctionR[] PROGMEM = {
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71,
72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
90, 91, 92, 93, 94, 95, 96, 97, 98, 99,100,101,102,103,104,105,106,107,
108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,
126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,
144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,
162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,
180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,
198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,
216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,
234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,
252,253,254,255
};

// ------ gamma GREEN = 2,0
const uint8_t gamma_correctionG[] PROGMEM = {
0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 4, 5,
5, 5, 5, 6, 6, 6, 7, 7, 7, 8, 8, 8, 9, 9, 10, 10, 10, 11,
11, 12, 12, 13, 13, 14, 14, 14, 15, 15, 16, 16, 17, 17, 18, 19, 19, 20,
20, 21, 21, 22, 23, 23, 24, 24, 25, 26, 26, 27, 28, 28, 29, 30, 30, 31,
32, 32, 33, 34, 35, 35, 36, 37, 38, 38, 39, 40, 41, 42, 42, 43, 44, 45,
46, 47, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61,
62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 73, 74, 75, 76, 77, 78, 79, 80,
81, 82, 84, 85, 86, 87, 88, 89, 91, 92, 93, 94, 95, 97, 98, 99,100,102,
103,104,105,107,108,109,111,112,113,115,116,117,119,120,121,123,124,126,
127,128,130,131,133,134,136,137,138,140,141,143,144,146,147,149,151,152,
154,155,157,158,160,161,163,165,166,168,169,171,173,174,176,178,179,181,
183,184,186,188,190,191,193,195,196,198,200,202,204,205,207,209,211,213,
214,216,218,220,222,224,225,227,229,231,233,235,237,239,241,243,245,247,
249,251,253,255
};
// ------ gamma BLUE = 2,0
const uint8_t gamma_correctionB[] PROGMEM = {
0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 4, 5,
5, 5, 5, 6, 6, 6, 7, 7, 7, 8, 8, 8, 9, 9, 10, 10, 10, 11,
11, 12, 12, 13, 13, 14, 14, 14, 15, 15, 16, 16, 17, 17, 18, 19, 19, 20,
20, 21, 21, 22, 23, 23, 24, 24, 25, 26, 26, 27, 28, 28, 29, 30, 30, 31,
32, 32, 33, 34, 35, 35, 36, 37, 38, 38, 39, 40, 41, 42, 42, 43, 44, 45,
46, 47, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61,
62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 73, 74, 75, 76, 77, 78, 79, 80,
81, 82, 84, 85, 86, 87, 88, 89, 91, 92, 93, 94, 95, 97, 98, 99,100,102,
103,104,105,107,108,109,111,112,113,115,116,117,119,120,121,123,124,126,
127,128,130,131,133,134,136,137,138,140,141,143,144,146,147,149,151,152,
154,155,157,158,160,161,163,165,166,168,169,171,173,174,176,178,179,181,
183,184,186,188,190,191,193,195,196,198,200,202,204,205,207,209,211,213,
214,216,218,220,222,224,225,227,229,231,233,235,237,239,241,243,245,247,
249,251,253,255
};

#define GAMMAR(a) (pgm_read_byte(&gamma_correctionR[a])) // macro for RED
#define GAMMAG(a) (pgm_read_byte(&gamma_correctionG[a])) // macro for GREEN
#define GAMMAB(a) (pgm_read_byte(&gamma_correctionB[a])) // macro for BLUE

volatile uint16_t counter;
//uint8_t key_lock = 0;

#define SECX ( 400 )

void hsv2rgb( uint8_t hue, uint8_t sat, uint8_t val, uint8_t * redv, uint8_t * greenv, uint8_t * bluev );
void mDelay( uint16_t delay );

int main() {

PRR |= (1<ACSR |= (1<
PCMSK |= (1<GIMSK |= (1<
DDRB |= (1<DDRB |= (1<DDRB |= (1<
DDRB &= ~(1<PORTB &= ~(1<
DDRB &= ~(1<PORTB |= (1<
TCCR0A |= (1<TCCR0B |= (1<OCR0A = 24;
TIMSK |= (1<
_delay_ms(10);

//set_sleep_mode( SLEEP_MODE_PWR_DOWN );
sei();

while(1) {
if( !counter ) {
hsv2rgb( i++,255,255,&RED1,&GREEN2,&BLUE3 );
counter = SECX;
}

//if( !key_lock && !(PINB & (1<//key_lock=1;
//
//_delay_ms(150);
//sleep_enable();
//hsv2rgb(255,0,255,&RED1,&GREEN2,&BLUE3);
//_delay_ms(1);
//sei();
//sleep_cpu();
//
// } else if( key_lock && (PINB & (1<}
}

ISR( PCINT0_vect ) {
//sleep_disable();
}

void mDelay( uint16_t delay ) {
for( ; delay > 0; --delay ) {
_delay_ms(1);
}
}

void hsv2rgb( uint8_t hue, uint8_t sat, uint8_t val, uint8_t * redv, uint8_t * greenv, uint8_t * bluev ) {
uint16_t region, remainder, p, q, t;

if( sat == 0 ) {
*redv = GAMMAR( val );
*greenv = GAMMAG( val );
*bluev = GAMMAB( val );
} else {
region = hue * 6 / 256;
remainder = ( hue * 6 ) % 256;

p = ( val * ( 255 - sat )) / 256;
q = ( val * ( 255- ( sat * remainder) / 256)) / 256;
t = ( val * ( 255- ( sat * ( 255 - remainder )) / 256 )) / 256;

switch ( region ) {
case 0:
*redv = GAMMAR( val ); *greenv = GAMMAG( t ); *bluev = GAMMAB( p );
break;

case 1:
*redv = GAMMAR( q ); *greenv = GAMMAG( val ); *bluev = GAMMAB( p );
break;

case 2:
*redv = GAMMAR( p ); *greenv = GAMMAG( val ); *bluev = GAMMAB( t );
break;

case 3:
*redv = GAMMAR( p ); *greenv = GAMMAG( q ); *bluev = GAMMAB( val );
break;

case 4:
*redv = GAMMAR( t ); *greenv = GAMMAG( p ); *bluev = GAMMAB( val );
break;

case 5:
*redv = GAMMAR( val ); *greenv = GAMMAG( p ); *bluev = GAMMAB( q );
break;
}
}
}

ISR( TIMER0_COMPA_vect ) {
static uint8_t licznik;
uint16_t n;

if(licznik>=RED1) PORTB |= (1< if(licznik>=GREEN2) PORTB |= (1< if(licznik>=BLUE3) PORTB |= (1< licznik++;

n = counter;
if( n ) counter = --n;
}[/syntax]

Jeśli ktoś by wiedział, co poradzić, aby przy dłuższych czasach nie było takich brzydkich przeskoków, chętnie się douczę

PROGRAMIŚCI GÓRĄ !

Statystyki: Napisane przez ShutDownSystem — 5 sty 2017, o 22:53

Re: PWM atmega 16

2017-01-05T19:15:34+01:00

witam,

fifi_22 napisał(a):

Głowię się i głowię i nie mogę wymyślić. Jeżeli ktoświe jak to rozwiązać to proszę o odp.

używasz cnt uint8_t, to w np timerze0, możesz zmieniać wartości też w zakresie 8bit.
pwm_red, pwm_green, pwm_blue, pwm_white.
rozumiem że "pwm_white", to czwarty kanał do koloru tylko białego.
pobaw się w zmianę tych wartości uzależniając je od siebie nawzajem. np. coś jakoś tak.
[syntax=c]volatole uint8_t flag_red, flag_green, flag_blue, flag_white;[/syntax]
w przerwaniu : jeżeli jest flaga koloru to się rozjaśnia, a jeżeli nie to się ściemnia .
[syntax=c]if(pwm_red<255 && flag_red) pwm_red ++;
else
if(pwm_red) pwm_red--;
if(pwm_green<255 && flag_green) pwm_green++;
else
if(pwm_green) pwm_green--;
if(pwm_blue<255 && flag_blue) pwm_blue++;
else
if(pwm_blue) pwm_blue--;
if(pwm_white<255 && flag_white) pwm_white++;
else
if(pwm_white) pwm_white--;[/syntax]
trzeba by jeszcze dopisać obsługę tych flag, ale to już tylko cztery sztuki.
Mogą być w petli.
[syntax=c]if(pwm_red == 255) {flag_blue = 0; flag_green = 1;}
if(pwm_green == 255) {flag_red = 0; flag_blue = 1;}
if(pwm_blue == 255) {flag_green = 0; flag_red = 1;}
if(!pwm_white && !pwm_red) flag_white = 1; else if(pwm_white == 255 && !pwm_red) flag_white =0;[/syntax]
może jakoś_takoś sobie nimi żonglować:),
albo jakoś zupełnie inaczej . bo sporo kodu wyszło.
Hmm... może lepiej uzależnić je od czasu nie od siebie.

Statystyki: Napisane przez Daro69 — 5 sty 2017, o 19:15

Re: PWM atmega 16

2017-01-05T18:39:00+01:00

Witam
Po pierwsze - wklej poprawnie ten fragment kodu.
Czy ktoś wie... no na pewno, ale musisz pokazać to czego nie rozumiesz oraz w jaki sposób zamierzasz zwiększać te pwm_red, pwm_ .... liniowo, czy korekcją GAMMA.

fifi_22 napisał(a):

Ostatnio kupiłem Pańską książkę bluebook.

...no no, i już w połowie książki

Pozdr.

Statystyki: Napisane przez kicajek — 5 sty 2017, o 18:39