ATNEL tech-forum

Re: Mruganie diodami+PWM Atmega 8

2014-02-20T19:54:31+01:00

Napisze post pod postem ale chciałbym wstawić działający kod do generowania płynnego rozjaśniania i ściemniania diody jednocześnie generując sekwencje błysków. Poprawiłem również komentarze bo jednak było sporo w nich błędów.
Niestety nie jest to tak jak być powinno, jednak działa.
Może ktoś pokusi się o przedstawienie poprawnego sposobu generowania błysków dla diody podłączonej do PC5?

[syntax=c]//Krótkie błyski diody podłączonej do PC3
//Płynne rozjasnianie i sciemnianie diody podłączonej do PC4
//Ciągłe wiecenie dioda podłączoną do PC5
//Tkatowanie procesora 8MHz
//Sterowane sprzetowym kanalem CTC
//Diody sa podlaczone katodą do pinu, anodą poprzez rezystor do VCC

#include
#include //dołaczenie pliku nagłówkowego do obsługi przerwań
#include

// definicje zmiennej do sterowania 1 kanałem programowym PWM
// zmienne typu uint8_t, rozdzielczość 8-bitowa
volatile uint8_t pwm1;

// definicje dla preprocesora

#define LED_PIN1 (1<#define LED_PIN2 (1<#define LED_PIN3 (1<

int main(void)
{

//***** PROGRAMOWY PWM - 2 KANAŁÓW *******
// ustawienie pinów kanałów programowych PWM jako WYJŚCIA
DDRC |= LED_PIN1;// kierunek pinu PC3 – wyjściowy włączenie diody
DDRC |= LED_PIN2;// kierunek pinu PC4 – wyjściowy włączenie diody
DDRC |= LED_PIN3;// kierunek pinu PC5 – wyjściowy włączenie diody

// wyłączenie diod LED podłączonych katodami do wyjść
PORTC |= LED_PIN2;
//PORTC |= LED_PIN3;

//ustawienie CTC dla Timer2 PB3(wyjscie 8-bit)

TCCR2 |= (1 << WGM21) ; //ustawienie CTC
TCCR2 |= (1 << CS21);//|(1 << CS20)|(1 << CS22); //preskaler 8>>1000000Hz
//99 częstotliwosć 10000Hz(0,0001s)>> (1000000/10000)-1=99
OCR2=99;
TIMSK |= (1<

/*
*
//ustawienie CTC dla Timer1A PB1(wyjscie 16-bit)

//inicjalizacja przerwania
*
TCCR1A |= (1 << WGM12); //ustawienie CTC
TCCR1B |= (1 << CS10);|(1<>(8000000/1024)=7812,5??
//przerwanie co 0,01s 100Hz??, (7812,5/100)-1=77
OCR1A=77;
TIMSK|=(1<

*/

sei ();//włączenie globalnego zezwolenia na przerwania

uint8_t i;// definicja zmiennej i na potrzeby pętli for()

while(1)
{
// pętla rozjaśniająca 6 diod LED
for(i=0;i<255;i++)
{

pwm1=i;

// W związku z dużą nieliniowością zależności prądu diod LED
// i jasności świecenia, wprowadzone jest zmienne opóźnienie
// przy wartościach bliskich zera aby zminimalizować ten efekt
if(i>50) _delay_ms(3);
else _delay_ms(10);
}

// rozświetlenie na maksimum przez 100ms
pwm1=255;

_delay_ms(500);

// pętla stopniowo ściemniająca 6 diod LED
for(i=255;i;i--)
{

pwm1=i;
;

// W związku z dużą nieliniowością zależności prądu diod LED
// i jasności świecenia, wprowadzone jest zmienne opóźnienie
// przy wartościach bliskich zera aby zminimalizować ten efekt
if(i>50) _delay_ms(3);
else _delay_ms(10);
}

// całkowite wygaszenie diod LED przez 100ms
pwm1=0;

_delay_ms(500);
}

}

//Timer 2

ISR(TIMER2_COMP_vect)
{

static uint16_t ms;
static uint8_t cnt;

ms++;

if(ms>=1 && ms<500) PORTC&= ~(1<if(ms>=500 && ms<2500) PORTC|= (1<if(ms>=2500 && ms<3000) PORTC&= ~(1<if(ms>=3000 && ms<15000) PORTC|= (1<if(ms>=15000) ms=0;//zerowanie ms

if(cnt>=pwm1) PORTC |= (1<cnt++;// zwiększanie licznika o 1
}

/*

// Timer 1

ISR( TIMER1_COMPA_vect )
{
static uint8_t mt;

mt++;

if(mt>=1 && mt<6) PORTC&= ~(1<if(mt>=6 && mt<26) PORTC|= (1<if(mt>=26 && mt<31) PORTC&= ~(1<if(mt>=31 && mt<150) PORTC|= (1<if(mt>=150) mt=0;//zerowanie mt
}
*/[/syntax]

Gdyby ktoś chciał zmodyfikowałem lekko fragment związany z Timerem2 wielkość programu spadła z 424 do 382 baitów.
[syntax=c]ISR(TIMER2_COMP_vect)
{

static uint16_t ms;
static uint8_t cnt;

ms++;
//dioda włączona 0,05s,wyłączona 0,2s,dioda włączona 0,05s

if((ms>=1 && ms<500) || (ms>=2500 && ms<3000))
{
PORTC&= ~(1<}
else PORTC|= (1<if(ms>=15000) ms=0;//dioda wyłączona po 1,2s,zerowanie ms

if(cnt>=pwm1) PORTC |= (1<cnt++;// zwiększanie licznika o 1
}[/syntax]

Statystyki: Napisane przez Syntezator — 20 lut 2014, o 19:54

Re: Mruganie diodami+PWM Atmega 8

2014-02-20T18:12:52+01:00

Procesor to Atmega8 strona 97 noty.
Znalazłem jeden ale wszystko psujący błąd..
[syntax=c][TIMSK|=(1<Po tej zmianie obie diody żyją, chociaż w przypadku Timera 1 preskaler musiałem przestawić na 1 aby było coś widać.
Jednak dalej nie wiem jak obliczać parametry dla Timera1.

Uzyskanie zapalania i gaszenia diody znalazłem w wielu wątkach, niestety jak poprawnie uzyskać sekwencje aby nie zakłócać pozostałej części programu już nie.

Masz racje nie do końca rozumiem ich idee, dlatego wrócę do przeanalizowania Poradników i książki.

Statystyki: Napisane przez Syntezator — 20 lut 2014, o 18:12

Re: Mruganie diodami+PWM Atmega 8

2014-02-20T17:28:27+01:00

Chyba nie do końca zrozumiałeś ideę timerów programowych :/ To coś co w przerwaniu może wyglądać mniej więcej tak:
[syntax=c]ISR(vect...){
If (timer_prog) timer_prog--;
}[/syntax]

Sporo na ten temat już napisano na forum...

A czy Timer1 jeden może pracować w trybie CTC, bo nawet nie wiem na jakim procku działasz ?

Statystyki: Napisane przez SylwekK — 20 lut 2014, o 17:28

Re: Mruganie diodami+PWM Atmega 8

2014-02-20T17:18:10+01:00

Wczoraj udało mi się zrealizować sekwencje błysków wykorzystując Timer2.
Niestety próba zrealizowania tego samego wykorzystując Timer1 już nie wypadła tak dobrze, w jaki sposób obliczyć taktowanie dla niego?
Dodatkowo próbując wykorzystać zarówno Timer1 jak i Timer2 realizowała się tylko część związana z Timerem1 dlaczego?
Poniżej podaje kod programu i ustawienia dla Timer1 oraz Timer2.

[syntax=c]//Krótkie błyski diody podłączonej do PB3
//Tkatowanie procesora 8MHz
//Sterowane sprzetowym kanalem CTC
// diody sa podlaczone katodą do pinu, anodą poprzez rezystor do VCC
#include
#include //dołaczenie pliku nagłówkowego do obsługi przerwań

// definicje dla preprocesora

#define LED_PIN1 (1<#define LED_PIN2 (1<

int main(void)
{

// ****** inicjalizacja *********

DDRC |= LED_PIN1;// kierunek pinu PC3 – wyjściowy włączenie diody
DDRC |= LED_PIN2;// kierunek pinu PC4 – wyjściowy włączenie diody

//ustawienie CTC dla Timer2 PB3(wyjscie 8-bit)

TCCR2 |= (1 << WGM21) ; //ustawienie CTC
TCCR2 |= (1 << CS20)|(1 << CS21)|(1 << CS22); //preskaler =1024>>(8000000/1024)
OCR2=77;//częstotliwosc 100Hz(0,01s)
TIMSK |= (1</*
//ustawienie CTC dla Timer1A PB1(wyjscie 16-bit)

//inicjalizacja przerwania co 20ms
*
TCCR1A |= (1 << WGM12); //ustawienie CTC
TCCR1B |= (1 << CS10);|(1<>(8000000/1024)
OCR1A=77;//przerwanie co 0,01s, 100Hz
TIMSK=(1<

*/

sei ();//włączenie globalnego zezwolenia na przerwania

while(1){}

}

//Timer 2

ISR(TIMER2_COMP_vect)
{

static uint8_t ms;

ms++;

if(ms>=1 && ms<6) PORTC&= ~(1<if(ms>=6 && ms<26) PORTC|= (1<if(ms>=26 && ms<31) PORTC&= ~(1<if(ms>=31 && ms<150) PORTC|= (1<if(ms>=150) ms=0;//zerowanie ms
}

/*

// Timer 1

ISR( TIMER1_COMPA_vect )
{
static uint8_t mt;

mt++;

if(mt>=1 && mt<6) PORTC&= ~(1<if(mt>=6 && mt<26) PORTC|= (1<if(mt>=26 && mt<31) PORTC&= ~(1<if(mt>=31 && mt<150) PORTC|= (1<if(mt>=150) mt=0;//zerowanie mt
}
*/[/syntax]

Statystyki: Napisane przez Syntezator — 20 lut 2014, o 17:18

Re: Mruganie diodami+PWM Atmega 8

2014-02-20T11:49:13+01:00

Syntezator napisał(a):

Kolejnym krokiem jaki chciałbym zrobić to wygenerowanie dwóch krótkich błysków i dłuższej przerwy w oparciu o ten timer.

Osobiście do takich efektów wykorzystuję dwie różne metody przede wszystkim w zależności od sytuacji i potrzeb:
- wykorzystująca (wg mnie najprostsza) switch-case gdzie w każdym przebiegu ustalasz dla timera konkretną wartość do odliczenia zanim znowu wejdzie w "przełącznik", a przy zadawaniu wartości wykonujesz też konkretne instrukcje, które sobie zaplanowałeś (tu można by znowu podzielić na kolejne metody, ale mieszał nie będę);

- nieco trudniejsza - choć czy ja wiem czy trudniejsza...po prostu inina - metoda oparta na matrycy bitowej i korzystająca z przesunięć bitowych. Ta również pozwoli na pojedyncze błyski, ale częściej ją wykorzystuje do generowania konkretnych serii zer i jedynek w ustalonym czasie.

Są też i inne sposoby oparte na If...else (w sumie idealnie nadaje się jak mamy tylko dwa czasy), ale ja najbardziej lubię powyższe

Statystyki: Napisane przez SylwekK — 20 lut 2014, o 11:49

Re: Mruganie diodami+PWM Atmega 8

2014-02-19T21:17:27+01:00

Umieść kod w znacznikach "synrax=c"
bo teraz to nic nie widać

Statystyki: Napisane przez Zaba — 19 lut 2014, o 21:17

Re: Mruganie diodami+PWM Atmega 8

2014-02-19T21:23:38+01:00

Dziękuję za podpowiedzi jednak muszę dalej prosić o pomoc.
Zgodnie z zaleceniami zabrałem się za same timery programowe, napisałem trzy funkcje mające za zadanie mrugać diodami.
Pierwsza zaczerpnięta jest w pewnym stopniu z Rozdziału "Wstęp do systemów czasu rzeczywistego str.443, druga "Sterowanie PWM" str.249, trzecia w oparciu o Poradnik "AVR Przerwania Cz.1".
Zgodnie z moim tokiem rozumowania obie powinny zapalać i gasić diodę co 1s, jednak występują zauważalne różnice między 2 a 1 i 3-dlaczego?
Kolejnym krokiem jaki chciałbym zrobić to wygenerowanie dwóch krótkich błysków i dłuższej przerwy w oparciu o ten timer.
[syntax=c]#include
#include //dołaczenie pliku nagłówkowego do obsługi przerwań

// definicje dla preprocesora

#define LED_PIN3 (1<#define LED_TOG PORTC ^= LED_PIN3// makrodefinicja – zmiana stanu diody
#define LED_PIN2 (1<#define LED_PIN1 (1<
volatile uint8_t pwm1;
volatile uint16_t Timer1;

int main(void)
{

// ****** inicjalizacja *********

DDRC |= LED_PIN3;// kierunek pinu PC5 – wyjściowy włączenie diody
DDRC |= LED_PIN2;// kierunek pinu PC4 – wyjściowy włączenie diody
DDRC |= LED_PIN1;// kierunek pinu PC4 – wyjściowy włączenie diody

//ustawienie CTM dla Timer2 PB3(wyjscie 8-bit)
//TCCR2 |= (1 << COM20); //ustawienie set at TOP
TCCR2 |= (1 << WGM21) ; //ustawienie CTC
TCCR2 |= (1 << CS20)|(1 << CS21)|(1 << CS22); //preskaler =1024>>(8000000/1024)
OCR2=77;//częstotliwosc 100Hz(0,01s)
TIMSK |= (1<
sei ();//włączenie globalnego zezwolenia na przerwania

while(1)
{
if(!Timer1){
Timer1=100; //zmiana stanu co 100*0,01s=1s
PORTC ^= LED_PIN3;
pwm1=100;//zmiana stanu co 100*0,01s=1s??
}
}
}

ISR(TIMER2_COMP_vect)
{
uint8_t x;
static uint8_t cnt;
static uint8_t ms;
ms++;

x=Timer1;
if (x) Timer1=--x;

if(cnt>=pwm1) PORTC |= (1<cnt++;

if(ms>99)
{
ms=0;
PORTC^=(1<}

}[/syntax]

Statystyki: Napisane przez Syntezator — 19 lut 2014, o 20:57

Re: Mruganie diodami+PWM Atmega 8

2014-02-15T14:26:31+01:00

Zobacz jak ja steruję diodami RGB przez PWM, link znajdziesz w moim podpisie. Na dniach będę modyfikował kod, ale ten co tam jest działa bez zarzutu.

Statystyki: Napisane przez kila — 15 lut 2014, o 14:26

Re: Mruganie diodami+PWM Atmega 8

2014-02-15T13:18:07+01:00

Musisz wywalić wszystkie delay, zamiast pętli for zastosować inną pracę ze zmiennymi no i przede wszystkim musisz poczytać o timerach programowych, bo one są podstawą opóźnień przy nieblokujących programach.

Statystyki: Napisane przez SylwekK — 15 lut 2014, o 13:18

Mruganie diodami+PWM Atmega 8

2014-02-19T21:23:11+01:00

Witam wszystkich jest to mój pierwszy post na forum oraz pierwszy program jaki staram się stworzyć.
Na wstępie chwiałbym podziękować Panu Mirkowi za tak wspaniałą książkę oraz poradniki, bez nich nie zdecydował bym się na rozpoczęcie nauki programowania.
Teraz przejdę do sedna sprawy, mam problem z odpowiednim napisaniem programu. Składa się z dwóch części, oddzielnie działają idealnie jednak razem już nie wychodzi to co sobie zaplanowałem
Program oparty jest w 99% na książce jednak przerobiłem go na Atmege 8(wiem źle zrobiłem ale tak to jest jak człowiek się nie słucha mądrzejszych..).
Pierwsza część odpowiada za szybkie mrugnięcia diodą pod kanałem PB1, druga opiera się na PWM i ma za zadanie płynnie rozjaśniać oraz przyciemniać diodę podłączoną do PB3.
Co trzeba zmienić aby wykonywanie drugiej części nie powodowało opóźnienia wykonywania pierwszej?
Jeśli brakuję jakiś informacji to bardzo przepraszam, postaram się odpowiedzieć na wszelkie pytania..jeśli je tylko zrozumiem
[syntax=c]//Płynne rozjaśnianie oraz ściemnianie dwóch diod Led podłączonych pod wyjścia PB1 oraz PB3
//Sterowane sprzętowym kanałem PWM
// diody są podłączone katodą do pinu, anodą poprzez rezystor do VCC
#include
#include

// definicje dla preprocesora
#define LED_PIN1 (1<#define LED_ON PORTB &= ~LED_PIN1// makrodefinicja – załączenie diody
#define LED_OFF PORTB |= LED_PIN1// makrodefinicja – wyłączenie diody
//#define LED_TOG PORTB ^= LED_PIN1// makrodefinicja – zmiana stanu diody

#define LED_PIN2 (1<#define LED_PIN3 (1<
int main(void)
{

// ****** inicjalizacja *********
DDRB |= (LED_PIN1) |(1<DDRC |= LED_PIN2;// kierunek pinu PC4 – wyjściowy włączenie diody
DDRC |= LED_PIN3;// kierunek pinu PC5 – wyjściowy włączenie diody

//DDRB |=(1<

//DDRB |= (1</*
//ustawienie PWM dla PB1(wyjscie 16-bit)
TCCR1A |= (1 << COM1A1); //ustawienie set at TOP
TCCR1A |= (1 << WGM10)|(1 << WGM12); //ustawienie Fast PWM na 8-bit
TCCR1B |= (1 << CS10); //preskaler =1
*/
//ustawienie PWM dla PB3(wyjscie 8-bit)
TCCR2 |= (1 << COM21); //ustawienie set at TOP
TCCR2 |= (1 << WGM21) | (1 << WGM20); //ustawienie Fast PWM
TCCR2 |= (1 << CS20); //preskaler =1

uint8_t i;// definicja zmiennej i na potrzeby pętli for()

while(1)
{

//pętla krótkich błysków dla wyjścia PB1
LED_ON;// zapal diodę 1
_delay_ms(100);// oczekiwanie 0.1s (100ms)
LED_OFF;// zgaś diodę
_delay_ms(50);// oczekiwanie 0.1s
LED_ON;// zapal diodę 1
_delay_ms(100);// oczekiwanie 0.1s (100ms)
LED_OFF;// zgaś diodę
_delay_ms(800);// oczekiwanie 1s

// pętla ściemniająca diody LED PB3

for(i=0;i<255;i++)
{
//OCR1A=i;
OCR2 =i;

// W związku z dużą nieliniowością zależności prądu diod LED
// i jasności świecenia, wprowadzone jest zmienne opóźnienie
// przy wartościach bliskich zera aby zminimalizować ten efekt
//dla wartości 255 diody są wygaszone
if(i>205) _delay_ms(10); // dla zakresu 190-255 krok 20ms(końcówka wygaszania)
else _delay_ms(3);
}

// całkowite wygaszenie diody LED przez 200ms PB3
//OCR1A=255;
OCR2=255;

_delay_ms(300);

// pętla stopniowo rozjaśniająca diody LED PB3
for(i=255;i;i--)
{
//OCR1A=i;
OCR2=i;

// W związku z dużą nieliniowością zależności prądu diod LED
// i jasności świecenia, wprowadzone jest zmienne opóźnienie
// przy wartościach bliskich zera aby zminimalizować ten efekt
if(i>205) _delay_ms(10); //dla zakresu 220-255 krok 15ms(początek rozjaśniania)
else _delay_ms(3);
}

// całkowite rozjaśnienie diody LED przez 100ms PB3
//OCR1A=0;
OCR2=0;

_delay_ms(50);

}
}[/syntax]

Statystyki: Napisane przez Syntezator — 15 lut 2014, o 13:00