ATNEL tech-forum

Re: Attiny13 + 2 PWM programowe + dwa zadania równoległe.

2019-11-16T13:37:53+01:00

Przy kopiowaniu zabrakło Ci jakiegoś nawiasu klamrowego }
Taki przynajmniej masz komunikat.
Sprawdź sobie jeszcze raz skopiowany kod.

Statystyki: Napisane przez MirkoT — 16 lis 2019, o 13:37

Re: Attiny13 + 2 PWM programowe + dwa zadania równoległe.

2019-11-15T23:42:58+01:00

23:42:27 **** Incremental Build of configuration Release for project zzzz ****
make all
'Building file: ../button.c'
'Invoking: AVR Compiler'
avr-gcc -Wall -Os -fpack-struct -fshort-enums -ffunction-sections -fdata-sections -std=gnu99 -funsigned-char -funsigned-bitfields -mmcu=attiny13 -DF_CPU=9600000UL -MMD -MP -MF"button.d" -MT"button.o" -c -o "button.o" "../button.c"
In file included from ../button.c:3:0:
../led.h:17:5: error: expected '=', ',', ';', 'asm' or '__attribute__' before 'typedef'
typedef struct LedConfigSet {
^
In file included from ../button.c:4:0:
../button.h:8:5: error: expected '=', ',', ';', 'asm' or '__attribute__' before 'typedef'
typedef struct ButtonConfigSet {
^
../button.c:8:5: error: expected '=', ',', ';', 'asm' or '__attribute__' before 'static'
static void doFunction(Button * const me);
^
../button.c: In function 'rawState':
../button.c:12:31: error: 'ButtonConfigSet' has no member named 'port'
return *me->config->port & me->config->mask;
^
../button.c:12:50: error: 'ButtonConfigSet' has no member named 'mask'
return *me->config->port & me->config->mask;
^
../button.c: In function 'Button_init':
../button.c:22:13: warning: implicit declaration of function 'doFunction' [-Wimplicit-function-declaration]
doFunction(me);
^
../button.c: At top level:
../button.c:47:10: warning: conflicting types for 'doFunction' [enabled by default]
void doFunction(Button * const me)
^
../button.c:22:13: note: previous implicit declaration of 'doFunction' was here
doFunction(me);
^
../button.c: In function 'doFunction':
../button.c:51:34: error: 'ButtonConfigSet' has no member named 'onFunction'
if(me->config->onFunction)
^
../button.c:52:41: error: 'ButtonConfigSet' has no member named 'onFunction'
(*me->config->onFunction)();
^
../button.c:56:34: error: 'ButtonConfigSet' has no member named 'offFunction'
if(me->config->offFunction)
^
../button.c:57:41: error: 'ButtonConfigSet' has no member named 'offFunction'
(*me->config->offFunction)();
^
../button.c: In function 'rawState':
../button.c:13:5: warning: control reaches end of non-void function [-Wreturn-type]
}
^
make: *** [button.o] Błąd 1

23:42:27 Build Finished (took 237ms)

Statystyki: Napisane przez bobuss88 — 15 lis 2019, o 23:42

Re: Attiny13 + 2 PWM programowe + dwa zadania równoległe.

2019-11-14T22:50:27+01:00

[syntax=c]/* button.h */

#ifndef BUTTON_H_
#define BUTTON_H_

#define DEBOUNCE_MS 10

typedef struct ButtonConfigSet {
volatile uint8_t *port;
uint8_t mask;
void (*onFunction)(void);
void (*offFunction)(void);
} ButtonConfigSet;

typedef struct Button {
uint16_t debounceTicks;
uint8_t state;
__flash const ButtonConfigSet *config;
} Button;

void Button_init(Button * const me, __flash const ButtonConfigSet *config);
void Button_service(Button * const me);

#endif /* BUTTON_H_ */[/syntax]

[syntax=c]/* button.c */

#include "led.h"
#include "button.h"

#define DEBOUNCE_TICKS ((unsigned long)TICKS_PER_SEC * DEBOUNCE_MS / 1000)

static void doFunction(Button * const me);

static inline uint8_t rawState(Button * const me)
{
return *me->config->port & me->config->mask;
}

void Button_init(Button * const me, __flash const ButtonConfigSet *config)
{
me->config = config;
me->debounceTicks = DEBOUNCE_TICKS;
me->state = rawState(me);

doFunction(me);
}

void Button_service(Button * const me)
{

uint8_t tmp = rawState(me);

if(tmp==me->state)
{
me->debounceTicks = DEBOUNCE_TICKS;
}
else
{
if(!me->debounceTicks || !--me->debounceTicks)
{
me->state = tmp;
doFunction(me);
}
}

}

void doFunction(Button * const me)
{
if(!me->state) /* low depressed */
{
if(me->config->onFunction)
(*me->config->onFunction)();
}
else
{
if(me->config->offFunction)
(*me->config->offFunction)();
}
}[/syntax]

[syntax=c]/* led.h */

#ifndef LED_H_
#define LED_H_

#include
#include "pwm.h"

#define TICKS_PER_SEC ((PWM_RESOLUTION)*(PWM_FREQUENCY))

#define LED_FADE_TICKS(min,max,seconds) ((max-min)?(uint32_t)seconds*TICKS_PER_SEC/(max-min):0)
#define LED_ON_OFF_TICKS(seconds) ((uint32_t)seconds * TICKS_PER_SEC)

#define FLASH_MEM __flash
//#define FLASH_MEM

typedef struct LedConfigSet {
uint8_t min;
uint8_t max;
uint32_t fadeInTicks;
uint32_t onTicks;
uint32_t fadeOutTicks;
uint32_t offTicks;
} LedConfigSet;

struct Led;
typedef void Led_state(struct Led * const me);

typedef struct Led {
Pwmsuper;/* superclass */
Led_state *state;
uint32_t currentCounter;
/* "protected" */
FLASH_MEM const LedConfigSet * config;
} Led;

void Led_ctor(Led * const me, volatile uint8_t * port, uint8_t pinMsk, FLASH_MEM const LedConfigSet * config);
void Led_service(Led * const me);
void Led_setConfig(Led * const me, FLASH_MEM const LedConfigSet * config);

#endif /* LED_H_ */[/syntax]

[syntax=c]/* led.c */

#include "led.h"

static void stateIdle(Led * const me);
static void stateFadeIn(Led * const me);
static void stateOn(Led * const me);
static void stateFadeOut(Led * const me);
static void stateOff(Led * const me);

void Led_ctor(Led * const me, volatile uint8_t * port, uint8_t pinMsk, FLASH_MEM const LedConfigSet * config)
{
Pwm_ctor(&me->super, port, pinMsk);

me->currentCounter = 0;
me->state = stateIdle;

Led_setConfig(me, config);

}

void Led_service(Led * const me)
{
Pwm_service(&me->super);

if(!me->currentCounter || !--me->currentCounter)
{
(*me->state)(me);
}
}

void Led_setConfig(Led * const me, FLASH_MEM const LedConfigSet * config)
{
me->config = config;
}

/***************** local functions *******************8*/

void stateIdle(Led * const me)
{
if(me->config->fadeInTicks)
{
stateOff(me);
}
}

void stateFadeIn(Led * const me)
{

if(++me->super.dutyTicks >= me->config->max)
{
me->currentCounter = me->config->onTicks;
me->state = stateOn;
}
else
{
me->currentCounter = me->config->fadeInTicks;
}

}

void stateOn(Led * const me)
{
me->state = stateFadeOut;
}

void stateFadeOut(Led * const me)
{
if(--me->super.dutyTicks <= me->config->min)
{
me->currentCounter = me->config->offTicks;
me->state = stateOff;
}
else
{
me->currentCounter = me->config->fadeOutTicks;
}

}

void stateOff(Led * const me)
{
me->state = stateFadeIn;
}[/syntax]

[syntax=c]/* pwm.h */

#ifndef PWM_H_
#define PWM_H_

#include

#define PWM_FREQUENCY100
#define PWM_RESOLUTION256//not to be changed

/*
* Transforms duty in 0-100 range into internal representation (0-255)
*/
#define DUTY_VALUE(duty) ((duty * (PWM_RESOLUTION-1)) / 100)

typedef struct Pwm {
/* "private" */
volatile uint8_t *port;
uint8_t pinMask;
uint8_t currentDutyTicks;
/* "protected" */
uint8_t dutyTicks;
} Pwm;

void Pwm_ctor(Pwm * const me, volatile uint8_t * port, uint8_t pinMsk);
void Pwm_setDuty(Pwm * const me, uint8_t duty);
uint8_t Pwm_getDuty(Pwm * const me);
void Pwm_service(Pwm * const me);
void Pwm_tick(void);

#endif /* PWM_H_ */[/syntax]

[syntax=c]/* pwm.c */

#include "pwm.h"

static uint8_t resCounter ;

void Pwm_ctor(Pwm * const me, volatile uint8_t * port, uint8_t pinMsk)
{
me->port = port;
me->pinMask = pinMsk;
me->currentDutyTicks = me->dutyTicks = 0;
}

/*
* duty range 0-255
*/
void Pwm_setDuty(Pwm * const me, uint8_t duty)
{
me->dutyTicks = duty;
}

uint8_t Pwm_getDuty(Pwm * const me)
{
return me->dutyTicks;
}

void Pwm_service(Pwm * const me)
{
if(me->currentDutyTicks && !--me->currentDutyTicks)
{
*me->port &= ~me->pinMask;
}
if(!resCounter && me->dutyTicks)
{
*me->port |= me->pinMask;
me->currentDutyTicks = me->dutyTicks;
}
}

void Pwm_tick(void)
{
resCounter++;
}[/syntax]

[syntax=c]/* timer.h */

#ifndef TIMER_H_
#define TIMER_H_

void Timer_init(void);

#endif /* TIMER_H_ */[/syntax]

[syntax=c]/* timer.c */

#include
#include "pwm.h"

#define TICKS_PER_SEC ((PWM_RESOLUTION)*(PWM_FREQUENCY))

#define PRESKALER 8

void Timer_init(void)
{
//Timer0 configuration, freq TICKS_PER_SEC Hz, COMP_A interrupt
TCCR0A = _BV(WGM01);
OCR0A = F_CPU/ PRESKALER/ TICKS_PER_SEC - 1;
TIMSK0 = _BV(OCIE0A);
TCCR0B = _BV(CS01);

}[/syntax]

[syntax=c]/* main.c */

#include "led.h"
#include "button.h"
#include "timer.h"
#include
#include

#define PIN_LED_00
#define PIN_LED_11

#define PIN_BUTTON_03
#define PIN_BUTTON_14

static void Pin_init(void);

static void onFunction0(void);
static void offFunction0(void);
static void onFunction1(void);
static void offFunction1(void);

static __flash const LedConfigSet config[] = {
{
0, 240, /* min, max */
LED_FADE_TICKS(0,240,60),/* fade in ticks */
LED_ON_OFF_TICKS(120), /* on ticks */
LED_FADE_TICKS(0,240,60),/* fade out ticks */
0 /* off ticks */
},
{
0, 240, /* min, max */
LED_FADE_TICKS(0,240,90),/* fade in ticks */
LED_ON_OFF_TICKS(120), /* on ticks */
LED_FADE_TICKS(0,240,90),/* fade out ticks */
0 /* off ticks */
},
{
0, 240, /* min, max */
LED_FADE_TICKS(0,240,60),/* fade in ticks */
0, /* on ticks */
LED_FADE_TICKS(0,240,40),/* fade out ticks */
0 /* off ticks */
},

{
0, 240, /* min, max */
LED_FADE_TICKS(0,240,90),/* fade in ticks */
0, /* on ticks */
LED_FADE_TICKS(0,240,50),/* fade out ticks */
0 /* off ticks */
}
};

static Led led0;
static Led led1;

static __flash const ButtonConfigSet buttonConfig[] = {
{
&PINB,/* volatile uint8_t *port; */
(1<onFunction0,/* void (*onFunction)(void); */
offFunction0/* void (*offFunction)(void); */
},
{
&PINB,/* volatile uint8_t *port; */
(1<onFunction1,/* void (*onFunction)(void); */
offFunction1/* void (*offFunction)(void); */
}
};

static Button button0;
static Button button1;

__attribute__((OS_main))
int main()
{
Timer_init();
Pin_init();

Led_ctor(&led0, &PORTB, (1<Button_init(&button0, &buttonConfig[0]);

Led_ctor(&led1, &PORTB, (1<Button_init(&button1, &buttonConfig[1]);

sei();

for(;;)
{
}

return 0;
}

void Pin_init(void)
{
DDRB |= (1<PORTB |= (1<}

ISR(TIM0_COMPA_vect,ISR_NAKED)
{
Led_service(&led0);
Led_service(&led1);
Pwm_tick();
Button_service(&button0);
Button_service(&button1);
reti();
}

void onFunction0(void)
{
Led_setConfig(&led0, &config[0]);
}
void offFunction0(void)
{
Led_setConfig(&led0, &config[1]);
}
void onFunction1(void)
{
Led_setConfig(&led1, &config[2]);
}
void offFunction1(void)
{
Led_setConfig(&led1, &config[3]);
}[/syntax]

[syntax=bash]Device: attiny13

Program: 898 bytes (87.7% Full)
(.text + .data + .bootloader)

Data: 37 bytes (57.8% Full)
(.data + .bss + .noinit)[/syntax]

Statystyki: Napisane przez tumu — 14 lis 2019, o 22:50

Re: Attiny13 + 2 PWM programowe + dwa zadania równoległe.

2019-11-11T22:42:56+01:00

Having both instance of class outside implementation file and fully opaque pointer requires dynamic allocation which is to be avoided. Furthermore, I think that to implement inheritance subclass has to know all about superclass.

Statystyki: Napisane przez tumu — 11 lis 2019, o 22:42

Re: Attiny13 + 2 PWM programowe + dwa zadania równoległe.

2019-11-11T13:37:16+01:00

Czy szkic programu jest obecnie poprawny?

[syntax=cpp]/*
] * main.c
*/
//ZM3 PB3 stan niski - przełącznik czasu Kanału 1 -pozycja 60s- 60s/120s/60s
//ZM3 PB3 stan wysoki - przełącznik czasu Kanału 1 -pozycja 90s- 90s/120s/90s
//ZM4 PB4 stan niski - przełącznik czasu Kanału 2 -pozycja A - 60s/40s
//ZM4 PB4 stan wysoki - przełącznik czasu Kanału 2 -pozycja B - 90s/50s
#include
#include
#include

#define ZM3 (1< #define ZM4 (1<
volatile uint8_t pwm1, pwm2;
uint16_t i;
uint16_t j;

int main(void) {
TCCR0B |= (1< TIMSK0 |= (1<
DDRB |= (1< PORTB |= ZM3|ZM4; // podciągamy linie klawiszy do VCC

sei();

while(1) //pętla główna programu
{
//kanał 1 PWM
i++;
if ( i< 240 ) //dla i<240
{
pwm1++; //rozjaśnianie
}
else if ( j<(240+480) ) //dla i<720 i i>=240
{
//nic nie rób, bez zmian
}
else if ( i<(240+480+240) )//dla i<960 i i>=720
{
pwm1--;//gaszenie
}
else //dla i>=960
{//koniec cyklu
//powracvamy do stanu początkowego
i=0;
pwm1=0;
}

//kanał 2 PWM
j++;
if ( j< (90*4) ) //dla j<360
{
pwm2++; //rozjaśnianie, tu jest potrzebny jeszcze dodatkowy warunek
}
else if ( j<(90*4+50*4) ) //dla j<560 i j>=360
{
pwm1--;//gaszenie, jw dodatkowy warunek
}
else //dla j>=560
{//koniec cyklu
//powracamy do stanu początkowego
j=0;
pwm2=0;
}

_delay_ms(240);

if((PINB & (1< {
pwm1_time1=60*4;
pwm1_time2=120*4+60*4;
pwm1_time3=60*4+120*4+60*4;
}
else
{
pwm1_time1=90*4;
pwm1_time2=120*4+90*4;
pwm1_time3=90*4+120*4+90*4;
}

}

GeSHi[/syntax]

Statystyki: Napisane przez bobuss88 — 11 lis 2019, o 13:37

Re: Attiny13 + 2 PWM programowe + dwa zadania równoległe.

2019-11-11T11:30:21+01:00

@Alef2, tak, mniej więcej o to chodzi. Wypadało by tylko uzależnić kroki rozjaśnianie/ściemnianie od czasu aby te kroki w zadanym czasie odliczyło. Można to zrobić na kilka sposobów. Timer programowy jest wygodny nawet jak przerwan do niczego innego nie wykorzystujemy

Statystyki: Napisane przez SylwekK — 11 lis 2019, o 11:30

Re: Attiny13 + 2 PWM programowe + dwa zadania równoległe.

2019-11-11T10:57:28+01:00

SylwekK napisał(a):

najprościej byłoby chyba rozwiązać z użyciem switch-case

Kolega ma na myśli coś takiego:[syntax=c]i++;
switch (krok)
{
case 1:
{
pwm1++;
if(i== 240)krok=2;
}
break;

case 2:
{
if(i== 720)krok=3;
}
break;

case 3:
{
pwm1--;
if(i== 960)krok=1;
}

default:
{
krok=1;
}
break;
}[/syntax]

SylwekK napisał(a):

bez timera programowego się raczej nie obejdzie

nie jestem przekonany czy w TYM konkretnym przypadku jest to niezbędne, choć jeżeli program ma być rozbudowywany to warto
lub też jeżeli czasy są krytyczne

bobuss88 napisał(a):

zmianę czasów poprzez przełączniki na portach PB3 i PB4:

a jaki to problem
ponieważ zmieniasz tylko czasy i tylko w zależności od stanu wejścia, to wystarczy stałe w warunkach zamienić na zmienne, których wartość będzie zależeć od stanu wejścia, np tak:
[syntax=c]if((PINB & (1<{
pwm1_time1=60*4;
pwm1_time2=120*4+60*4;
pwm1_time3=60*4+120*4+60*4;
}
else
{
pwm1_time1=90*4;
pwm1_time2=120*4+90*4;
pwm1_time3=90*4+120*4+90*4;
}[/syntax]

Statystyki: Napisane przez Alef2 — 11 lis 2019, o 10:57

Re: Attiny13 + 2 PWM programowe + dwa zadania równoległe.

2019-11-11T00:38:49+01:00

Dziękuję za zainteresowanie postem.
Potrzebowałbym jednak jeszcze zmianę czasów poprzez przełączniki na portach PB3 i PB4:

PB3 stan niski - przełącznik czasu Kanału 1 -płynne rozjaśnianie 0-240 przez czas 60 sekund, ciągłe świecenie przez czas 120 sekund, płynne wyłączenie przez czas 60 sekund.

PB3 stan wysoki - przełącznik czasu Kanału 1 -płynne rozjaśnianie 0-240 przez czas 90 sekund, ciągłe świecenie przez czas 120 sekund, płynne wyłączenie przez czas 90 sekund.

PB4 stan niski - przełącznik czasu Kanału 2 -Rozjaśnianie 0-240 przez czas 60 sekund, gaszenie przez czas 40 sekund.

PB4 stan wysoki - przełącznik czasu Kanału 2 -Rozjaśnianie 0-240 przez czas 90 sekund, gaszenie przez czas 50 sekund.

Oczywiście jak wyżej wspomniałem oba kanały pwm muszą pracować równolegle.

[syntax=cpp]/*
] * main.c
*/
//ZM3 PB3 stan niski - przełącznik czasu Kanału 1 -pozycja 60s- 60s/120s/60s
//ZM3 PB3 stan wysoki - przełącznik czasu Kanału 1 -pozycja 90s- 90s/120s/90s
//ZM4 PB4 stan niski - przełącznik czasu Kanału 2 -pozycja A - 60s/40s
//ZM4 PB4 stan wysoki - przełącznik czasu Kanału 2 -pozycja B - 90s/50s
#include
#include
#include

#define ZM3 (1< #define ZM4 (1<
volatile uint8_t pwm1, pwm2;
uint16_t i;
uint16_t j;

int main(void) {
TCCR0B |= (1< TIMSK0 |= (1<
DDRB |= (1< PORTB |= ZM3|ZM4; // podciągamy linie klawiszy do VCC

sei();

while(1) //pętla główna programu
{
//kanał 1 PWM
i++;
if ( i< 240 ) //dla i<240
{
pwm1++; //rozjaśnianie
}
else if ( j<(240+480) ) //dla i<720 i i>=240
{
//nic nie rób, bez zmian
}
else if ( i<(240+480+240) )//dla i<960 i i>=720
{
pwm1--;//gaszenie
}
else //dla i>=960
{//koniec cyklu
//powracvamy do stanu początkowego
i=0;
pwm1=0;
}

//kanał 2 PWM
j++;
if ( j< (90*4) ) //dla j<360
{
pwm2++; //rozjaśnianie, tu jest potrzebny jeszcze dodatkowy warunek
}
else if ( j<(90*4+50*4) ) //dla j<560 i j>=360
{
pwm1--;//gaszenie, jw dodatkowy warunek
}
else //dla j>=560
{//koniec cyklu
//powracamy do stanu początkowego
j=0;
pwm2=0;
}

_delay_ms(240);
}[/syntax]

Statystyki: Napisane przez bobuss88 — 11 lis 2019, o 00:38

Re: Attiny13 + 2 PWM programowe + dwa zadania równoległe.

2019-11-10T13:38:39+01:00

[syntax=c]/* main.c */
#include "led.h"
#include "timer.h"
#include
#include

Led led0;
Led led1;

int main()
{
Timer_init();

Led_ctor(&led0, &PORTB, (1<<3));
Led_setMinMax(&led0, (0*100/255), (240*100/255));
Led_setFadeIn(&led0, 60);
Led_setFadeOut(&led0, 60);
Led_setOn(&led0, 120);

Led_ctor(&led1, &PORTB, (1<<5));
Led_setMinMax(&led1, (0*100/255), (240*100/255));
Led_setFadeIn(&led1, 90);
Led_setFadeOut(&led1, 50);

sei();

for(;;)
{
}

return 0;
}

ISR(TIMER0_OVF_vect)
{
Led_service(&led0);
Led_service(&led1);
}[/syntax]

[syntax=c]/* pwm.h */
#ifndef PWM_H_
#define PWM_H_

#include

#define PWM_RESOLUTION256//not to be changed

typedef struct Pwm {
volatile uint8_t *port;
uint8_t pinMask;
uint8_t currentDutyTicks;
uint8_t newDutyTicks;
} Pwm;

void Pwm_ctor(Pwm * const me, volatile uint8_t * port, uint8_t pinMsk);
void Pwm_setDuty(Pwm * const me, uint8_t duty);
void Pwm_service(Pwm * const me);

#endif /* PWM_H_ */[/syntax]

[syntax=c]/* pwm.c */

#include "pwm.h"

static uint8_t resCounter;

void Pwm_ctor(Pwm * const me, volatile uint8_t * port, uint8_t pinMsk)
{
me->port = port;
me->pinMask = pinMsk;
me->currentDutyTicks = me->newDutyTicks = 0;
}

void Pwm_setDuty(Pwm * const me, uint8_t duty)
{
me->newDutyTicks = (duty * PWM_RESOLUTION) / 100;
}

void Pwm_service(Pwm * const me)
{
if(!++resCounter)
{
*me->port |= me->pinMask;
me->currentDutyTicks = me->newDutyTicks;
}
else if(me->currentDutyTicks && !--me->currentDutyTicks)
{
*me->port &= ~me->pinMask;
}
}[/syntax]

[syntax=c]/* led.h */

#ifndef LED_H_
#define LED_H_

#include
#include "pwm.h"

#define TICKS_PER_SEC (255*100)

struct Led;
typedef void Led_state(struct Led * const me);

typedef struct Led {
Pwmsuper;/* superclass */
uint8_t min;
uint8_t max;
uint8_t currentBrightness;
uint16_t fadeInTicks;
uint32_t onTicks;
uint16_t fadeOutTicks;
uint32_t offTicks;
uint32_t currentCounter;
Led_state *state;
} Led;

void Led_ctor(Led * const me, volatile uint8_t * port, uint8_t pinMsk);
void Led_service(Led * const me);
void Led_setMinMax(Led * const me, uint8_t min, uint8_t max);
void Led_setFadeIn(Led * const me, uint8_t seconds);
void Led_setOn(Led * const me, uint8_t seconds);
void Led_setFadeOut(Led * const me, uint8_t seconds);
void Led_setOff(Led * const me, uint8_t seconds);

#endif /* LED_H_ */[/syntax]

[syntax=c]/* led.c */

#include "led.h"

static void stateInitial(Led * const me);
static void stateFadeIn(Led * const me);
static void stateOn(Led * const me);
static void stateFadeOut(Led * const me);
static void stateOff(Led * const me);

void Led_ctor(Led * const me, volatile uint8_t * port, uint8_t pinMsk)
{
Pwm_ctor(&me->super, port, pinMsk);

me->fadeInTicks =
me->fadeOutTicks =
me->onTicks =
me->offTicks =
me->max =
me->min =
me->currentBrightness = 0;
me->state = stateInitial;

}

void Led_service(Led * const me)
{
Pwm_service(&me->super);

if(!--me->currentCounter)
{
(*me->state)(me);
}
}

void Led_setMinMax(Led * const me, uint8_t min, uint8_t max)
{
me->min = min;
me->max = max;
}

void Led_setFadeIn(Led * const me, uint8_t seconds)
{
me->fadeInTicks = seconds * TICKS_PER_SEC / (me->max - me->min);
}
void Led_setOn(Led * const me, uint8_t seconds)
{
me->onTicks = seconds * TICKS_PER_SEC;
}
void Led_setFadeOut(Led * const me, uint8_t seconds)
{
me->fadeOutTicks = seconds * TICKS_PER_SEC / (me->max - me->min);
}
void Led_setOff(Led * const me, uint8_t seconds)
{
me->offTicks = seconds * TICKS_PER_SEC;
}

/***************** local functions *******************8*/

void stateInitial(Led * const me)
{
if(me->fadeInTicks)
{
stateOff(me);
}
}

void stateFadeIn(Led * const me)
{
Pwm_setDuty(&me->super, ++me->currentBrightness);
if(me->currentBrightness>=me->max)
{
me->currentCounter = me->onTicks;
me->state = stateOn;
}

}

void stateOn(Led * const me)
{
me->currentCounter = me->fadeOutTicks;
me->state = stateFadeOut;
}

void stateFadeOut(Led * const me)
{
Pwm_setDuty(&me->super, --me->currentBrightness);
if(me->currentBrightness<=me->min)
{
me->currentCounter = me->offTicks;
me->state = stateOff;
}

}

void stateOff(Led * const me)
{
me->currentCounter = me->fadeInTicks;
me->state = stateFadeIn;
}[/syntax]

[syntax=c]/* timer.h */

#ifndef TIMER_H_
#define TIMER_H_

void Timer_init(void);

#endif /* TIMER_H_ */[/syntax]

[syntax=c]/* timer.c */

void Timer_init(void)
{
//Timer0 configuration, freq TICKS_PER_SEC Hz, OVF interrupt
}[/syntax]

Statystyki: Napisane przez tumu — 10 lis 2019, o 13:38

Re: Attiny13 + 2 PWM programowe + dwa zadania równoległe.

2019-11-10T13:09:19+01:00

Twoje zadanie najprościej byłoby chyba rozwiązać z użyciem switch-case. Prosta maszyna stanów dla każdego z led pozwoli na łatwiejsze zarządzanie czasami świecenia. Oczywiście bez timera programowego się raczej nie obejdzie.

Statystyki: Napisane przez SylwekK — 10 lis 2019, o 13:09

Re: Attiny13 + 2 PWM programowe + dwa zadania równoległe.

2019-11-10T10:33:02+01:00

Zaproponuję takie rozwiązanie
[syntax=c]while(1)//pętla główna programu
{
//kanał 1 PWM
i++;
if ( i< 240 )//dla i<240
{
pwm1++;//rozjaśnianie
}
else if ( j<(240+480) )//dla i<720 i i>=240
{
//nic nie rób, bez zmian
}
else if ( i<(240+480+240) )//dla i<960 i i>=720
{
pwm1--;//gaszenie
}
else//dla i>=960
{//koniec cyklu
//powracvamy do stanu początkowego
i=0;
pwm1=0;
}

//kanał 2 PWM
j++;
if ( j< (90*4) )//dla j<360
{
pwm2++;//rozjaśnianie, tu jest potrzebny jeszcze dodatkowy warunek
}
else if ( j<(90*4+50*4) )//dla j<560 i j>=360
{
pwm1--;//gaszenie, jw dodatkowy warunek
}
else//dla j>=560
{//koniec cyklu
//powracamy do stanu początkowego
j=0;
pwm2=0;
}

_delay_ms(240);
}[/syntax]
Oczywiście i i j muszą być typu uint16_t, a dla drugiego kanału trzeba trochę pokombinować, by dopasować ściemnianie i rozjaśnianie do ilości kroków.
Czas obiegu pętli też nie jest idealny. Jeżeli ma być idealny, to można zastosować zamiast _delay_ms(240); while(jakas_zmienna) a w obsłudze przerwania dopisać zerowanie tej zmiennej

Statystyki: Napisane przez Alef2 — 10 lis 2019, o 10:33

Re: Attiny13 + 2 PWM programowe + dwa zadania równoległe.

2019-11-09T21:28:46+01:00

bobuss88 napisał(a):

Jednak niewiem jak się za to zabrać.

Proponuję zacząć od książki https://atnel.pl/mikrokontrolery-avr-jezyk-c.html

Statystyki: Napisane przez mirekk36 — 9 lis 2019, o 21:28

Re: Attiny13 + 2 PWM programowe + dwa zadania równoległe.

2019-11-09T20:44:09+01:00

Doczytałem się o timerze programowym. Jednak niewiem jak się za to zabrać.

Statystyki: Napisane przez bobuss88 — 9 lis 2019, o 20:44

Attiny13 + 2 PWM programowe + dwa zadania równoległe.

2019-11-08T21:47:51+01:00

Witam. Poszukuje sposobu na uruchomienie dwóch led w trybie PWM o różnych czasach działania.
Led1/PWM1/PB0 - płynne rozjaśnianie 0-240 w czasie 60 sekund, ciągłe świecenie przez czas 120 sekund, płynne gaszenie 240-0 przez czas 60 sekund (w pętli)
Natomiast równolegle chcę by Led2/PWM2/PB1 się płynnie rozjaśniało 0-240 przez czas 90 sekund , płynnie wyłączało przez czas 50 sekund (pętla).
Niestety nie wiem jak się za to zabrać.

[syntax=cpp]/*
] * main.c
*
*
* Author: Marcin
*/

#include
#include
#include

volatile uint8_t PWM1, PWM2;
uint8_t i;
uint8_t j;

int main(void) {
TCCR0B |= (1< TIMSK0 |= (1<
DDRB |= (1<
sei();
while(1) {
for(i=0,j=0; i<=240,j<=240; i++,j++)
{

PWM1=i;
PWM2=j;
_delay_ms(240); //(60s) rozjasnianie (240) KANAŁ1
}

_delay_ms(120000); //(120s) swiecenie ciagle (120000) KANAŁ1

for(i=240,j=240; i>0,j>0; i--,j--)
{
PWM1=i;
PWM2=j;
_delay_ms(240); //(60s) gaszenie (240) KANAŁ1
}
PWM1=0; // zgaszenie KANAŁ1
}
}
}
//Licznik programowy do PWM
ISR(TIM0_OVF_vect){
static uint8_t licznik1;
static uint8_t licznik2;
if(licznik1 < PWM1)PORTB |= (1< if(licznik2 < PWM2)PORTB |= (1< licznik1++;
licznik2++;
}[/syntax]

Statystyki: Napisane przez bobuss88 — 8 lis 2019, o 21:47