ATNEL tech-forum 2014-08-20T19:58:43+01:00 https://forum.atnel.pl/feed.php?f=4&t=8071&mode 2014-08-20T19:58:43+01:00 2014-08-20T19:58:43+01:00 https://forum.atnel.pl/viewtopic.php?t=8071&p=92222#p92222 <![CDATA[Re: Sterowanie PWM i wł/wył portów, problem z INTx]]> atmel napisał(a):

Pierwszym błędem jest wywołanie funkcji "inicjalizacja" w przerwaniu...

Bez tej inicjalizacji program mi się nie uruchamia na uC.

atmel napisał(a):

Kolejny to zupełnie zbędne ciągłe ustawianie "pull-up'a" (PORTB = (1<<PD2);)...

Program na początku pisałem patrząc na inny i jakoś mi to umknęło.

[syntax=c]PORTD = ~(1<<PD2);[/syntax]
Tu chodziło mi o to, żeby PWM dostał jeden sygnał po podłączeniu zasilania aby się uruchomił bez konieczności przyciskania przycisku.

Mam jeszcze takie pytanie czy maskowanie tutaj zapewnia lepsze działanie czy po prostu tak jest poprawniej?

A tak poza tym to program działa w 100% tak jak chciałem. Dziękuję bardzo za pomoc, omówienie i wyjaśnienie :)

Statystyki: Napisane przez Aress — 20 sie 2014, o 19:58

]]> 2014-08-20T12:38:18+01:00 2014-08-20T12:38:18+01:00 https://forum.atnel.pl/viewtopic.php?t=8071&p=92142#p92142 <![CDATA[Re: Sterowanie PWM i wł/wył portów, problem z INTx]]>
Kolejny to zupełnie zbędne ciągłe ustawianie "pull-up'a" (PORTB = (1<<PD2);) w funkcji "przycisk". Zapewne chodziło o "pull-up" dla PD2, a nie PB2, dlatego tę linię można zupełnie usunąć, gdyż takowa znajduje się już w funkcji "inicjalizacja".

Następnie kolejna uwaga dotycząca ustawiania kierunku portów. Nie wiem jakie było założenie, ale w tym wypadku wszystkie piny oprócz PD2 będą wyjściami:

[syntax=c]PORTD = ~(1<<PD2);[/syntax]
Nie powinno być w ten sposób?:

[syntax=c]PORTD &= ~(1<<PD2);[/syntax]
Podobnie sytuacja wygląda w głównej pętli "while" programu. Tam również warto użyć maskowania (jeżeli zmianie ma ulec stan jedynie niektórych pinów).

"SIGNAL(SIG_INTERRUPT0)" jest to przestarzały zapis i lepiej używać: "ISR(INT0_vect)".

Przechodząc do sedna problemu, przy pierwszym naciśnięciu klawisza wywoływana jest funkcja "tryb2", później "tryb3", a następnie zmianie ulega jedynie zmienna "n" nie wywołując przy tym żadnych akcji. Dobrze byłoby ustawiać jej stan przed instrukcją wyboru "switch". Można to zrobić w dwojaki sposób:
1. Używając reszty z dzielenia [syntax=c]n = n++ % 3;[/syntax]
2. Używając warunku [syntax=c]if (++n > 3) n = 1;[/syntax]

Cały kod przedstawia się następująco:
[syntax=c]#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>

#define swich bit_is_clear(PIND, 2)
#define PWM_A (1<<PB1)

void inicjalizacja()
{
DDRD |= 1<<PD2;
PORTD |= 1<<PD2;
DDRB |= PWM_A;
DDRC |= 1<<PC2 | 1<<PC0;

// INICJALIZACJA PWM
TCCR1A |= 1<<WGM10 | 1<<COM1A1;
TCCR1B |= 1<<CS11;

MCUCR |= 1<<ISC00;
GICR |= 1<<INT0;
sei();
}

char przycisk(void)
{
if (swich) {
_delay_ms(30);
if (swich)
while (swich);
else return 0;
return 1;
} else return 0;
// Eliminacja drgań styków
}

void tryb1(void)
{
OCR1A = 235;
}

void tryb2(void)
{
OCR1A = 140;
}

void tryb3(void)
{
OCR1A = 50;
}

ISR(INT0_vect)
{
static uint8_t n = 1;
if (przycisk())
if (++n > 3) n = 1;// Można również zamiast tej linijki zastąpić ją takim zapisem: "n = n++ % 3;"
switch (n) {
case 1:tryb1();break;
case 2:tryb2();break;
case 3:tryb3();break;
}
}

int main(void)
{
inicjalizacja();
PORTD &= ~(1<<PD2);
while(1) {
PORTC &= ~(1<<PC2);
PORTC |= 1<<PC0;
_delay_ms(200);
PORTC &= ~(1<<PC0);
PORTC |= 1<<PC2;
_delay_ms(200);
}
return 0;
}[/syntax]

Statystyki: Napisane przez atmel — 20 sie 2014, o 12:38

]]> 2014-08-20T06:29:07+01:00 2014-08-20T06:29:07+01:00 https://forum.atnel.pl/viewtopic.php?t=8071&p=92117#p92117 <![CDATA[Re: Sterowanie PWM i wł/wył portów]]> Mam 2 problemy ze swoim programem.
1- Czasami jest tak, że program przełącza PWM na 3 tryby ale prawie cały czas jest tak, że przechodzi tylko przez 2.
2- Jak przełącza się po trybach to jak dojdzie do ostatniego (tego co jest przed "default") to, żeby przejść do początku trzeba wcisnąć dwa razy przycisk.

[syntax=c]#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>

#define swich bit_is_clear(PIND,2)
#define PWM_A (1<<PB1)



void inicjalizacja(){

DDRD |= (1<<PORTD2);
PORTD |= (1<<PORTD2);

DDRB |= (PWM_A);

DDRC |= (1<<PC0)|(1<<PC2);


// INICJALIZACJA PWM
TCCR1A |= (1<<WGM10);
TCCR1A |= (1<<COM1A1);
TCCR1B |= (1<<CS11);



MCUCR |= (1<<ISC00);
GICR |=(1<<INT0);
sei();


}

char przycisk(void)
{

PORTB = (1<<PD2);
if(swich)
{
_delay_ms(30);
if(swich) {while (swich){};}
else return 0;
return 1;
}
else return 0;

// Eliminacja drgań styków
}

void tryb1(void){

OCR1A = 235;

}

void tryb2(void){

OCR1A = 140;

}

void tryb3(void){

OCR1A = 50;

}

SIGNAL(SIG_INTERRUPT0){

inicjalizacja();
static char n=1;


if(przycisk())n++;
switch (n)
{
case 1:
tryb1();
break;

case 2:
tryb2();
break;

case 3:
tryb3();
break;

default:
n=1;

}

}

int main(void){

inicjalizacja();

PORTD = ~(1<<PD2);

while(1){

PORTC = (1<<PC0);
_delay_ms(200);
PORTC = (1<<PC2);
_delay_ms(200);
}
return 0;
}[/syntax]

Statystyki: Napisane przez Aress — 20 sie 2014, o 06:29

]]> 2014-08-10T08:02:26+01:00 2014-08-10T08:02:26+01:00 https://forum.atnel.pl/viewtopic.php?t=8071&p=90896#p90896 <![CDATA[Re: Sterowanie PWM i wł/wył portów]]>

Statystyki: Napisane przez Aress — 10 sie 2014, o 08:02

]]> 2014-08-09T21:23:50+01:00 2014-08-09T21:23:50+01:00 https://forum.atnel.pl/viewtopic.php?t=8071&p=90866#p90866 <![CDATA[Re: Sterowanie PWM i wł/wył portów]]> http://www.embedded.com/design/prototyping-and-development/4025691/Build-a-Super-Simple-Tasker
Biblioteki autorstwa Artura Lipowskiego tu (wymaga zalogowania):
http://www.avrfreaks.net/index.php?module=Freaks%20Academy&func=viewItem&item_id=725&item_type=project

Tak w ramach zabawy uruchomiłem kiedyś przykład z tej paczki na attiny2313 i atmedze8. Na attiny można było tylko pomigać diodą, za mało flasha i ramu ;) Na atmedze wyświetlałem sobie wartości timerów na LCD i bawiłem się dodając w funkcjach delaye i zmieniając ich priorytety, patrząc czy się zawiesi :D. Np dając duże opóźnienie w funkcji wyświetlania na LCD spadała częstotliwość odświeżania, ale timer mierzył czas poprawnie, bo miał wyższy priorytet. Gdy zamieniłem priorytety, timer gubił impulsy, bo procesor mielił delayem, który miał wyższy priorytet niż obsługa timera. Nic poważniejszego nie testowałem. Kod przykładu przerobiony przeze mnie wyglądał tak:

main.c
[syntax=c]#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/sleep.h>
#include <util/delay.h>
#include "sst/sst_timer.h"
#include "LCD/lcd44780.h"

#define TIMER_TASK_PRIO (SST_MIN_TASK_PRIO + 2)
#define EVENT_TASK_PRIO (SST_MIN_TASK_PRIO + 1)

SST_TaskID_T timer_task_id;
SST_TaskID_T event_task_id;

static CPU_Base_T ticks;

SST_TICKER_DEFINE(ticker, 1);


inline void ioinit(void) {

#if defined (__AVR_ATmega8__)

TCCR2 |= (1 << WGM21); // tryb CTC
TCCR2 |= (1 << CS22); // prescaler 64
OCR2 = (uint8_t) (F_CPU / 64 / 1000); // 1ms
TIMSK |= (1 << OCIE2);

#elif defined (__AVR_ATtiny2313__)

TCCR0A |= (1 << WGM01); // tryb CTC
TCCR0B |= (1 << CS02) | (1 << CS00); // prescaler 1024
OCR0A = (uint8_t) (F_CPU / 1024 / 100); // 100ms
TIMSK |= (1 << OCIE0A);

#endif

lcd_init();

}


void timer_task_func(SST_Event_T e)
{


ticks++;

// do some other processing

// sometime start event triggered task
if (0 == (ticks % 3))
{
SST_PostEvent(event_task_id, 3, ticks);

}
if (0 == (ticks % 8))
{
SST_PostEvent(event_task_id, 8, ticks);
}

}



void event_task_func(SST_Event_T e)
{

lcd_locate(0,0);
lcd_int((uint16_t)e.sig);

lcd_locate(1,0);
lcd_int((uint16_t)e.par);
lcd_str(" ");

}


void SST_Start(void)
{

// perform some IO anf HW initialization
ioinit();

timer_task_id = SST_CreateTask(TIMER_TASK_PRIO, timer_task_func);
event_task_id = SST_CreateTask(EVENT_TASK_PRIO, event_task_func);

// create a periodic task - period is 100 calls of ticker
(void) SST_MakeTimedTask(timer_task_id, 100, true, &ticker);

// enable interrupts
SST_INT_UNLOCK();

}


void SST_OnIdle(void)
{

sleep_enable();
sleep_cpu();
sleep_disable();

}


int main(void)
{
SST_Run();
}


// this is an ISR function for periodic timer interrupt
#if defined (__AVR_ATmega8__)
ISR(TIMER2_COMP_vect)
#elif defined (__AVR_ATtiny2313__)
ISR(TIMER0_COMPA_vect)
#endif
{

SST_DECLARE_ISR;

// do some timer HW housekeeping (if needed)

SST_ISR_ENTRY(SST_MIN_INT_PRIO+1);

// timer tick
SST_TimerTick(&ticker);

SST_ISR_EXIT();

}[/syntax]

dodatkowo w pliku sst_base_def.h trzeba sobie ustawić kilka rzeczy. U mnie wyglądało to tak:
[syntax=c]#define SST_MAX_NO_OF_TASKS 2
#define SST_MAX_EV_QUEUE_LEN 2
#define SST_MAX_TASK_PRIO 100
#define SST_USE_EOI 0

#define SST_USE_SIGNAL_MASK 0
#define SST_USE_LAZY_TIMER 0


typedef uint8_t CPU_Base_T;
typedef uint8_t CPU_SR_T;[/syntax]

Wrzucę na wszelki wypadek w załączniku cały projekt bez bibliotek Mirka, bo nie jestem pewien czy czasem nie edytowałem czegoś w reszcie plików.

Aha, kompilowałem pod toolchainem atmela. W winavr nie znajdzie pliku bool.h, trzeba go dorobić ręcznie i dołączyć.

Statystyki: Napisane przez Federerer — 9 sie 2014, o 21:23

]]> 2014-08-09T07:44:38+01:00 2014-08-09T07:44:38+01:00 https://forum.atnel.pl/viewtopic.php?t=8071&p=90803#p90803 <![CDATA[Re: Sterowanie PWM i wł/wył portów]]>

Federerer jak to nie stwarza Ci żadnego problemu to chętnie zobaczę jaki jest jeszcze na to sposób.

Statystyki: Napisane przez Aress — 9 sie 2014, o 07:44

]]> 2014-08-09T00:04:45+01:00 2014-08-09T00:04:45+01:00 https://forum.atnel.pl/viewtopic.php?t=8071&p=90797#p90797 <![CDATA[Re: Sterowanie PWM i wł/wył portów]]> a jeśli nie ma nic do roboty to uśpi procesor do następnego przerwania od timera. Jutro wrzucę i opiszę, bo myślę, że koncepcja jest dość ciekawa, a nie znalazłem w sieci przykładów zastosowania. Jedyne co, to trzeba pilnować użycia stosu, bo jak "się zagnieździmy" za bardzo to program pójdzie w maliny ;)

Statystyki: Napisane przez Federerer — 9 sie 2014, o 00:04

]]> 2014-08-08T23:15:47+01:00 2014-08-08T23:15:47+01:00 https://forum.atnel.pl/viewtopic.php?t=8071&p=90796#p90796 <![CDATA[Re: Sterowanie PWM i wł/wył portów]]>

SPAM:
Ja z kolei na potrzeby dość rozbudowanego projektu musiałem dynamicznie tworzyć zadania oraz funkcje, które będą im przyporządkowywane, dodatkowo z wywłaszczeniem. Niestety nie znalazłem żadnego gotowego rozwiązania i myślałem żeby całkiem przejść na ASM'a, ale przy tak świetnych poradnikach Mirka o wstawkach asemblerowych postanowiłem wszystko napisać w C, a jedynie krytyczne modyfikacje stosu umieścić w takich właśnie procedurkach :D

Problem autora tematu nie wymaga jednak aż tak złożonego podejścia, dlatego z pewnością z przedstawionym powyższym kodem wszystko będzie działać jak należy ;)

Statystyki: Napisane przez atmel — 8 sie 2014, o 23:15

]]> 2014-08-08T22:57:37+01:00 2014-08-08T22:57:37+01:00 https://forum.atnel.pl/viewtopic.php?t=8071&p=90795#p90795 <![CDATA[Re: Sterowanie PWM i wł/wył portów]]> [syntax=c]DDRB = 0x02;[/syntax]

a tak:
[syntax=c]DDRB = (1<<PB1);[/syntax]

Wtedy łatwiej innym analizować kod ;)

atmel napisał(a):

"scheduler z dispatcher'em" (system operacyjny [jakiś RTOS])


Ja ostatnio uruchomiłem na avrach Super Simple Tasker. Tylko, że trochę to zasobożerne w porównaniu do timera, ale zadania można kolejkować i jest też coś w stylu wywłaszczania.

Z prostszych rozwiązań z timerami programowymi, można np tak:

main.c
[syntax=c]/*
* main.c
*
* Created on: 18-07-2014
* Author: Federerer
*/


#include <avr/io.h>
#include "soft_timer.h"

void tsr_timer1(void);
void tsr_timer2(void);
void tsr_timer3(void);
void tsr_timer4(void);
void tsr_timer5(void);

timer_t timer1, timer2, timer3, timer4, timer5;

int main (void) {

DDRD = (1<<PD0) | (1<<PD1) | (1<<PD2) | (1<<PD3) | (1<<PD4);

set_timer( &timer1, 100, tsr_timer1 );
set_timer( &timer2, 250, tsr_timer2 );
set_timer( &timer3, 700, tsr_timer3 );
set_timer( &timer4, 1100, tsr_timer4 );
set_timer( &timer5, 1300, tsr_timer5 );

enable_timers();

while(1) {

//pusta pętla

}

}

void tsr_timer1(void) {

PORTD ^= (1<<PD0);// jakieś miganie ledem

}

void tsr_timer2(void) {

PORTD ^= (1<<PD1);

}

void tsr_timer3(void) {

PORTD ^= (1<<PD2);

}

void tsr_timer4(void) {

PORTD ^= (1<<PD3);

}

void tsr_timer5(void) {

PORTD ^= (1<<PD4);

}[/syntax]

soft_timer.h
[syntax=c]/*
* soft_timer.h
*
* Created on: 19-07-2014
* Author: Federerer
*/

#ifndef SOFT_TIMER_H_
#define SOFT_TIMER_H_

#ifdef __cplusplus
extern "C" {
#endif

// maksymalna ilość timerów
#define TIMERS_COUNT 5

typedef struct {

uint16_t interval;
uint16_t time;
void (*wsk)(void);

} timer_t;


extern timer_t *wskazniki[];
extern uint8_t timer_n;

void enable_timers(void);

void set_timer ( timer_t * timer, uint16_t interval, void (*wsk)(void) );

void timer_event(void);

#ifdef __cplusplus
}
#endif

#endif /* SOFT_TIMER_H_ */[/syntax]

soft_timer.c
[syntax=c]#include <avr/io.h>
#include <avr/interrupt.h>
#include "soft_timer.h"

timer_t *wskazniki[TIMERS_COUNT];
uint8_t timer_n;

void enable_timers(void) {

// może wymagać modyfikacji tak, by przerwanie wywoływane było co 1 ms
TCCR0A |= (1 << WGM01); // tryb CTC
TCCR0B |= (1 << CS01) | (1 << CS00); // prescaler 64
OCR0A = (uint8_t) (F_CPU / 64 / 1000); // 1ms
TIMSK |= (1 << OCIE0A);

sei();

}

void set_timer ( timer_t * timer, uint16_t interval, void (*wsk)(void) ) {

timer->interval = interval;
timer->time = interval;
timer->wsk = wsk;
wskazniki[timer_n] = timer;
timer_n++;

}

void timer_event(void) {

for(uint8_t i=0; i < timer_n; i++) {

wskazniki[i]->time--;

if(!(wskazniki[i]->time)) {

wskazniki[i]->time = wskazniki[i]->interval;
if(wskazniki[i]->wsk) wskazniki[i]->wsk();

}

}

}


ISR(TIMER0_COMPA_vect){

timer_event();

}[/syntax]

Statystyki: Napisane przez Federerer — 8 sie 2014, o 22:57

]]> 2014-08-08T23:04:11+01:00 2014-08-08T22:46:43+01:00 https://forum.atnel.pl/viewtopic.php?t=8071&p=90794#p90794 <![CDATA[Re: Sterowanie PWM i wł/wył portów]]> 1. Zmianę stanu portu C zrealizować w przerwaniu od któregoś timer'a.
2. Przycisk obsługiwać poprzez przerwanie zewnętrzne (INTx).

Jest oczywiście jeszcze całe mnóstwo sposobów, ale podaje te, które się "nie zemszczą", bo z doświadczenia wiem, że chcąc zrobić coś na szybko "na około" to w najmniej odpowiednim momencie da o sobie znać. Mimo tej zasady i raczej bezkompromisowego zwolennika przerwań, podam sposób, który powinien działać, ale nie polecam go na dłuższą metę.
Oczywiście jeśli jest to finalny program i wszystko działa jak należy oraz nie planujesz jego późniejszej rozbudowy to poniższy kod może być jak najbardziej ok ;)

[syntax=c]int main(void)
{
inicjalizacja();
uint16_t Time = 0;
while (1) {
if (Time == 200)
PORTC = 0x01;
else if (Time == 400) {
PORTC = 0x02;
Time = 0;
}
jasnosc();
Time++;
_delay_ms(1);
}
return 0;
}[/syntax]

Ma to oczywiście tę wadę, że przy naciśnięciu przycisku ten czas dodatkowo wydłuży się o 60ms (swoją drogą trochę zbyt dużo, spokojnie wystarczy 20-30ms), ale to już pozostawiam Tobie do dalszych rozważań nad tym, czy jest to wogóle dobra droga, bo moim zdaniem NIE i radzę zastosowanie przerwań.

Statystyki: Napisane przez atmel — 8 sie 2014, o 22:46

]]> 2014-08-08T22:31:42+01:00 2014-08-08T22:31:42+01:00 https://forum.atnel.pl/viewtopic.php?t=8071&p=90793#p90793 <![CDATA[Re: Sterowanie PWM i wł/wył portów]]> Statystyki: Napisane przez Aress — 8 sie 2014, o 22:31

]]> 2014-08-08T22:15:18+01:00 2014-08-08T22:15:18+01:00 https://forum.atnel.pl/viewtopic.php?t=8071&p=90787#p90787 <![CDATA[Re: Sterowanie PWM i wł/wył portów]]> Umieść pętle "while" z obu funkcji jako jedną obejmującą wywołania tych funkcji. Funkcja "inicjalizacja" powinna być wywoływana tylko raz przed główną pętlą programu.

[syntax=c]int main(void)
{
inicjalizacja();
while (1) {
miganie();
jasnosc();
}
return 0;
}[/syntax]

Nie zamieszczam całego kodu, a tylko ten fragment, bo z funkcji "miganie" oraz "jasnosc" wystarczy usunąć pętle "while" oraz wywołanie funkcji "inicjalizacja".

Rozumiem, że chciałeś zrobić coś na wzór zadań (wątków), ale do takich działań niezbędny jest tzw "scheduler z dispatcher'em" (system operacyjny [jakiś RTOS]), albo chociaż obsługa timerów (również programowych).
W związku z czym zapewne nie będziesz miał zakładanych rezultatów, ponieważ program przez funkcję "miganie" zostanie wstrzymany na 400ms...

Aha i tak na przyszłość umieszczaj kod na forum w znacznikach SYNTAX a nie Code.

Statystyki: Napisane przez atmel — 8 sie 2014, o 22:15

]]> 2014-08-20T06:43:49+01:00 2014-08-08T21:59:42+01:00 https://forum.atnel.pl/viewtopic.php?t=8071&p=90784#p90784 <![CDATA[Sterowanie PWM i wł/wył portów, problem z INTx]]> Program, który napisałem wykonuje tylko tą czynność która jest pierwsza w poleceniu " int main(void) ". Jak jest na początku " miganie " to steruje portami, a gdy daje na początek " jasnosc " to działa tylko PWM.
Prosiłbym o podpowiedź jak to można połączyć aby działało wszystko razem. Pozdrawiam.

[syntax=c]#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>

#define swich bit_is_clear(PINB,0)
#define PWM_A (1<<PB1)



void inicjalizacja(void)
{

// USTAWIENIE WYJŚĆ
DDRB |= (PWM_A); //Wyjścia PWM

DDRB = 0x02;
DDRC = 0x07;

PORTB = 0x01;
PORTC = 0x00;

// INICJALIZACJA PWM
TCCR1A |= (1<<WGM10);
TCCR1A |= (1<<COM1A1);
TCCR1B |= (1<<CS11);

}

char przycisk(void)
{

PORTB = 0x01;
if(swich)
{
_delay_ms(60);
if(swich) {while (swich){};}
else return 0;
return 1;
}
else return 0;

// Eliminacja drgań styków
}

void czas1(void)
{
//Sterowanie prędkością
OCR1A = 200; //Kanał PWM


}

void czas2(void)
{
//Sterowanie prędkością
OCR1A = 50; //Kanał PWM


}

void miganie(void)
{
inicjalizacja();
while(1)
{
_delay_ms(200);
PORTC = 0x01;
_delay_ms(200);
PORTC = 0x02;
}
}

void jasnosc(void)
{

inicjalizacja();
static char n=1;
while(1)
{
if(przycisk())n++;
switch (n)
{
case 1:
czas1();
break;

case 2:
czas2();
break;

default:
n=1;
break;
}
}
}


int main(void)
{


miganie();

jasnosc();
return 0;
}[/syntax]

Proszę poprawić post .... kody umieszczamy w znacznikach SYNTAX -SunRiver

Statystyki: Napisane przez Aress — 8 sie 2014, o 21:59

]]>