ATNEL tech-forum

Re: Struktury + funkcje + przerwanie + stos = ?

2016-12-13T10:01:06+01:00

Nie nie nie właśnie bardzo dobrze, że pokazałeś mi inny sposób i dałeś mi zagwozdkę to jest jedyny sposób żeby nauczyć się dobrze programować muszę przed świętami zakończyć ten projekt, ale zaraz po świętach ogarnę podesłany przez Ciebie kod i przerobię swój program na wzór tego kodu
Dziękuje za podpowiedzi

Statystyki: Napisane przez amilo_pa — 13 gru 2016, o 10:01

Re: Struktury + funkcje + przerwanie + stos = ?

2016-12-13T08:38:47+01:00

Chyba niepotrzebnie Ci namieszałem z tymi wskaźnikami na funkcje , ale to bardzo typowa sytuacja, gdzie aż się prosi, żeby ich użyć, ponieważ to znacznie upraszcza kod.

Zasadniczo sprawa jest stosunkowo prosta. Zakładam, że ogólnie wiesz co to są wskaźniki. Tak samo, jak zmienną można odczytać (lub zmodyfikować) bezpośrednio za pomocą jej nazwy albo pośrednio, za pomocą wskaźnika (adresu w pamięci), tak samo funkcję można wywołać bezpośrednio, za pomocą jej nazwy albo pośrednio, za pomocą wskaźnika na tę funkcję. Funkcja przecież również znajduje się gdzieś w pamięci i musi posiadać swój adres.

Początkowo deklaracja takiego wskaźnika na funkcję może wydawać się nieco skomplikowana i niezrozumiała, ale jak już się zrozumie o co chodzi, staje się to proste. Zapewne w tym przypadku wygląda to jeszcze bardziej skomplikowanie, dlatego że wskaźnik nie jest osobną zmienną, tylko elementem struktury.

W tej chwili nie mam czasu tego opisywać, a poza tym to trochę za dużo pisania, żeby to szczegółowo wyjaśniać na forum. Jest na pewno sporo materiałów na ten temat w internecie, więc poczytaj i jak czegoś nie zrozumiesz to pytaj.

Słowa kluczowe to coś w stylu:
c wskaźnik na funkcję
lub
c function pointers

Statystyki: Napisane przez andrews — 13 gru 2016, o 08:38

Re: Struktury + funkcje + przerwanie + stos = ?

2016-12-12T21:44:03+01:00

@andrews siedzę już 2 godzinę i próbuje zrozumieć to co napisałeś i normalnie nie ogarniam totalny mindfuck Masz może jakiś zestaw ćwiczeń, który umożliwi mi zrozumienie tego kodu ?

Statystyki: Napisane przez amilo_pa — 12 gru 2016, o 21:44

Re: Struktury + funkcje + przerwanie + stos = ?

2016-12-11T19:36:28+01:00

amilo_pa napisał(a):

dodanie ATOMIC_BLOCK(ATOMIC_RESTORESTATE) nie przyniosło pożądanego efektu

Nawet jeśli, to uwierz mi, że to nie jest jakieś moje "widzimisię", tak po prostu musi być, aby program działał prawidłowo.

Rozpatrzmy sobie sytuację:

Zmienna chimney.LED_timer jest równa 0x0100.
W celu sprawdzenia warunku if(!chimney.LED_timer) zmienna musi zostać załadowana do rejestrów.
Zostaje wczytany do rejestru najpierw młodszy bajt zmiennej, czyli 0x00.
W tym momencie następuje skok do procedury obsługi przerwania i zmienna jest dekrementowana, osiągając wartość 0x00FF.
Teraz program wraca do głównego programu i do następnego rejestru jest ładowany starszy bajt zmiennej, czyli w chwili obecnej 0x00.

W efekcie do kolejnych rejestrów została wpisana dwa razy wartość 0x00, czyli kopia całej zmiennej w rejestrach jest równa 0x0000 (warunek if(!chimney.LED_timer) jest spełniony), pomimo tego że w rzeczywistości wartość zmiennej wynosi 0x00FF, czyli program nie działa zgodnie z założeniem.

Oczywiście takie sytuacje nie muszą się zdarzać często, co powoduje, że błąd nie jest od razu widoczny, ale prędzej czy później takie sytuacje się zdarzą.

amilo_pa napisał(a):

Nie za bardzo rozumiem zapis tego kodu window_left.chosen_function(&window_left); i jak ma to wywoływać odpowiednią funkcję

[syntax=c]// niezbędne, aby definicja wskaźnika do funkcji
// znała strukturę TLED_RGB
typedef struct TLED_RGB TLED_RGB;

// definicja typu wskaźnik do funkcji posiadającej jeden parametr
// w postaci wskaźnika do struktury TLED_RGB
typedef void (*led_drv_fn)(TLED_RGB*);

//deklaracja struktury typu TLED_RGB
struct TLED_RGB {
uint8_t color[6]; //wartość PWM diod RGB: R=0, G=1, B=2, H=3, S=4, V=5
volatile uint16_t timer_set; //zapamiętany czas rozświetlania i ściemniania diody RGB, ładowany do licznika LED_timer
volatile uint16_t LED_timer; //czas odliczany w przerwaniu
volatile uint32_t period_time; //zmienna za pomocą której ustawiamy nowy czas szybkości rozświetlania i ściemniania diody
led_drv_fn chosen_function; // wskaźnik do funkcji sterującej ledem
volatile uint8_t value_max; //zmienna odpowiedzialna za maksymalny strumień świetlny
volatile uint8_t saturation_max; //zmienna odpowiadająca za maksymalne nasycenie kolorów
};

// funkcje sterujące
void select_set_colors_rgb(TLED_RGB *sel_rgb);
void flow_colors_rgb(TLED_RGB *sel_rgb);

// deklaracja zmiennej 'test' typu TLED_RGB
// w miejscu elementu struktury 'chosen_function' wpisujemy
// nazwę funkcji, którą chcemy zainicjować wstępnie
TLED_RGB test = {
{ 255, 255, 255, 255, 255, 255 },
0, 0, 0, select_set_colors_rgb, 0, 0
};

// teraz w programie możemy wywołać funkcję
// tym razem będzie to funkcja 'select_set_colors_rgb'
test.chosen_function(&test);

// można do zmiennej przypisać inną funkcję
test.chosen_function = flow_colors_rgb;

// teraz zostanie wywołana funkcja 'flow_colors_rgb'
test.chosen_function(&test);

// czyli w Twoim kodzie zamiast pisać
diode_rgb->chosen_function = 2;
// przypisujesz zamiast wartości 2 nazwę fukcji, którą planujesz wywołać
diode_rgb->chosen_function = flow_colors_rgb;[/syntax]

Jeśli w tej chwili masz odrębne funkcje dla poszczególnych struktur, to być może przekazywanie argumentu w postaci wskaźnika do struktury będzie zbędne. Trzeba by było w takim przypadku odpowiednio zmodyfikować mój przykład.

Statystyki: Napisane przez andrews — 11 gru 2016, o 19:36

Re: Struktury + funkcje + przerwanie + stos = ?

2016-12-11T17:33:31+01:00

ok, teraz rozumiem i dziękuję za informacje:)

Program działa poprawnie, ale ze zdublowanymi funkcjami (do każdej struktury TLED_RGB utworzyłem osobną funkcje która wykonuje to samo więc nie jest to optymalny sposób) :/ a dodanie ATOMIC_BLOCK(ATOMIC_RESTORESTATE) nie przyniosło pożądanego efektu :/

Nie za bardzo rozumiem zapis tego kodu window_left.chosen_function(&window_left); i jak ma to wywoływać odpowiednią funkcję :/ możesz coś rozjaśnić? Z góry dziękuję

Statystyki: Napisane przez amilo_pa — 11 gru 2016, o 17:33

Re: Struktury + funkcje + przerwanie + stos = ?

2016-12-11T16:15:46+01:00

amilo_pa napisał(a):

Czyli polega to na tym, że w momencie porównania if(!chimney.LED_timer) nie może wystąpić przerwanie od Timera2

Dokładnie o to chodzi, jednak nie tylko w momencie porównania, ale także w trakcie przypisania wartości chimney.LED_timer=chimney.timer_set;.

Oczywiście ta zasada nie dotyczy tylko tego konkretnego przypadku. Zawsze kiedy zmienna składająca się z więcej niż jednego bajtu (w mikrokontrolerach 8-bitowych) jest używana zarówno w przerwaniu, jak i w głównej pętli programu należy zapewnić do niej atomowy dostęp. Nie trzeba tego robić wewnątrz procedury obsługi przerwania, ponieważ wtedy globalna flaga zezwalająca na przerwania jest wyłączona, chyba że programista ją sam świadomie włączy, ale to już inna historia

Niestety nie mam czasu na szczegółową analizę całego kodu. Zakładam, że skoro działa poprawnie to znaczy, że jest OK. Wydaje mi się, że czasami może niepotrzebnie komplikujesz pewne sprawy, ale to się na pewno zmieni, jak zdobędziesz praktykę

Podam jeden przykład. Nie chodzi o to, że to błąd, chodzi tylko o poprawę czytelności (i być może szybkości wykonania).
Mógłbyś w strukturze TLED_RGB zamiast indeksu funkcji użyć wskaźnika do niej. Wprawdzie spowodowałoby to zwiększenie rozmiaru struktury o 1 bajt (nie masz przecież tych zmiennych dużo), jednak wywołanie odpowiedniej funkcji:
[syntax=c]// zamiast wyglądać tak
if(window_left.chosen_function == 1){//wybór funkcji wyświetlania led
select_set_colors_rgb(&window_left);//rozświetlanie i ściemnianie wybranych kolorów
}
else if(window_left.chosen_function == 2){
flow_colors_rgb (&window_left);//cykliczna zmiana pomiędzy kolorami
}

// mogłoby wyglądać tak (niezależnie od ilości funkcji do wyboru)
window_left.chosen_function(&window_left);[/syntax]
W tej chwili masz tylko dwie funkcje do wyboru, ale jak wyglądałoby Twoje wywołanie, gdyby ich było np. 10?

No ale tak jak napisałem, z czasem na pewno do tego dojdziesz

Statystyki: Napisane przez andrews — 11 gru 2016, o 16:15

Re: Struktury + funkcje + przerwanie + stos = ?

2016-12-11T12:38:09+01:00

@andrews Czyli polega to na tym, że w momencie porównania if(!chimney.LED_timer) nie może wystąpić przerwanie od Timera2, dobrze rozumiem zastosowanie flagi atomowej?

Nie wiem czy dobrze to zrobiłem, mógłbyś rzucić okiem?

main.c
[syntax=c]/*
* main.c
*
* Created on: 9 lis 2016
* Autor: Piotr Łączny
*/

#include
#include
#include
#include
#include

#include "LCD/lcd44780.h"
#include "IR_DECODE/ir_decode.h"
#include "GAMMA_CORRECTION/gamma.h"
#include "D_LED/d_led.h"

#define PERIOD_Tim3 117

#define SATURATION 2

uint8_t chose_led [3];//zmienna umożliwiająca wybór diody oraz przypisanie do niej funkcji sterującej diodą

//uint8_t select_color_chimney = 0, flaga_rgb_chimney = 0, i_chimney = 0;
//uint8_t select_color_window_left = 0, flaga_rgb_window_left = 0, i_window_left = 0;

uint16_t temp; //zmienna wykorzystywana do flagi atomowej

int main(void) {

//ustawienia startowe diody komina
chimney.color[H]=RED;
chimney.color[S]=255;
chimney.color[V]=255;
chimney.value_max=255;
chimney.saturation_max = 255;
chimney.chosen_function = 1;
chimney.timer_set=80;//PERIOD_Tim3; //co 20 ms przerwanie
chimney.LED_timer=PERIOD_Tim3; //co 20 ms przerwanie
chimney.period_time = PERIOD_TIME_LED;

//ustawienia startowe diody w lewym oknie
window_left.color[H]=BLUE;
window_left.color[S]=255;
window_left.color[V]=255;
window_left.value_max=255;
window_left.saturation_max = 255;
window_left.chosen_function = 2;
window_left.timer_set=10;//PERIOD_Tim3;
window_left.LED_timer=50;//PERIOD_Tim3;
window_left.period_time = PERIOD_TIME_LED;

//ustawienia startowe diody w prawym oknie
window_right.color[H]=RED;
window_right.color[S]=255;
window_right.color[V]=255;
window_right.value_max=255;
window_right.saturation_max = 255;
window_right.chosen_function = 2;
window_right.timer_set=PERIOD_Tim3;
window_right.LED_timer=PERIOD_Tim3;
window_right.period_time = PERIOD_TIME_LED;

ground1.pwm_max = 200;
ground1.timer_set = 750;
ground1.flag = TRUE;

ground2.pwm_max = 255;
ground2.timer_set = 117;
ground2.flag = TRUE;

DDRA |= (1<PORTA |= (1<
d_led_init();//ustawienie portów z podłączonymi LEDami
timer2_init();//ustawienie Timera2
lcd_init();/* inicjalizacja LCD */
ir_init();/* inicjalizacja dekodowania IR */

sei();/* włączamy globalne przerwania */

lcd_locate(0,0);
lcd_str(" ");
lcd_locate(0,0);
lcd_int(window_left.timer_set);

lcd_locate(0,4);
lcd_str(" ");
lcd_locate(0,4);
lcd_long(window_left.period_time);

selected_led = ground1;

/* pętla nieskończona */
while(1)
{

control_leds(&ground1,gamma_correctionR);
control_leds(&ground2, gamma_correctionR);

//**************************************************************//
////
//****Fragment kodu wywołujący funkcję sterujące diodami RGB****//
////
//**************************************************************//
//**Dioda w kominie**//
ATOMIC_BLOCK(ATOMIC_RESTORESTATE) { temp = chimney.LED_timer; }
if(!temp){
if(chimney.chosen_function == 1){//wybór funkcji wyświetlania led
select_set_colors_rgb(&chimney);//rozświetlanie i ściemnianie wybranych kolorów
}
else if(chimney.chosen_function == 2){
flow_colors_rgb (&chimney);//cykliczna zmiana pomiędzy kolorami
}
ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
chimney.LED_timer=chimney.timer_set;
}
}
//**Dioda w lewym oknie**//
ATOMIC_BLOCK(ATOMIC_RESTORESTATE) { temp = window_left.LED_timer; }
if(!temp){
if(window_left.chosen_function == 1){//wybór funkcji wyświetlania led
select_set_colors_rgb(&window_left);//rozświetlanie i ściemnianie wybranych kolorów
}
else if(window_left.chosen_function == 2){
flow_colors_rgb (&window_left);//cykliczna zmiana pomiędzy kolorami
}
ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
window_left.LED_timer=window_left.timer_set;
}
}
//**Dioda w prawym oknie**//
ATOMIC_BLOCK(ATOMIC_RESTORESTATE) { temp = window_right.LED_timer; }
if(!temp){
if(window_right.chosen_function == 1){//wybór funkcji wyświetlania led
select_set_colors_rgb(&window_right);//rozświetlanie i ściemnianie wybranych kolorów
}
else if(window_right.chosen_function == 2){
flow_colors_rgb (&window_right);//cykliczna zmiana pomiędzy kolorami
}
ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
window_right.LED_timer=window_right.timer_set;
}
}

//
//if(!Timer4){
//PORT(LED4_3PORT) ^= (1<//selected_rgb.pwm_max += 10;
//lcd_locate(1,5);
//lcd_str(" ");
//lcd_locate(1,5);
//lcd_int(selected_rgb.pwm_max);
//Timer4 = 10000;
//}

/* ****** ZDARZENIE Z ODBIORNIKA PODCZERWIENI ********** */
if(Ir_key_press_flag) {/* jeśli odebrano prawidłowe kody z pilota */

lcd_locate(0,12);
lcd_str(" ");
lcd_locate(0,12);
lcd_int(command);

lcd_locate(0,0);
lcd_str(" ");
lcd_locate(0,0);
lcd_int(chimney.timer_set);

lcd_locate(0,4);
lcd_str(" ");
lcd_locate(0,4);
lcd_long(chimney.period_time);

lcd_locate(1,0);
lcd_str(" ");
lcd_locate(1,0);
lcd_int(window_left.timer_set);

lcd_locate(1,4);
lcd_str(" ");
lcd_locate(1,4);
lcd_long(window_left.period_time);

if(chose_led[set_chosen_led] != 1)//wybranie diody do obróbki
{
switch (command)//na podstawie kodu klawisza wybierana jest dioda do obróbki
{
case 0:
;
break;
case 1://wybór diody RGB umieszczonej w kominie
chose_led[chosen_led] = 1;//do obróbki została wybrana dioda w kominie
blink_selected_led (&chimney);
break;
case 2:
chose_led[chosen_led] = 2;//do obróbki została wybrana dioda w lewym oknie
blink_selected_led (&window_left);
break;
case 3:
chose_led[chosen_led] = 3;//do obróbki została wybrana dioda w prawym oknie
blink_selected_led (&window_right);
break;
case 4:
;
break;
case 5:
;
break;
case 6:
;
break;
case 7:
;
break;
case 8:
;
break;
case 9:
;
break;

case SUBMIT://wciśnięty został klawisz OK zatwierdzający wybór
chose_led[set_chosen_led] = 1;//zapobiegnięcie ponownemu wejściu instrujcję wyboru diody do obróbki

//Zatwierdzenie wyboru diody sygnalizowane jest jej mrógnięciem//
switch(chose_led[chosen_led]){
case 1:
blink_selected_led (&chimney);
break;

case 2:
blink_selected_led (&window_left);
break;

case 3:
blink_selected_led (&window_right);
break;

}
break;
default: /* instrukcje, jeśli żaden z wcześniejszych warunków nie został spełniony */
;
break;
}//switch (command)
}//chose_led[1] != 1)

/*kasowanie zatwierdzenia wybrania diody*/
if(chose_led [set_chosen_led] == 1 && command == RESET){ //RESET - klawisz "help"

switch(chose_led[chosen_led]){//Zatwierdzenie skasowania wyboru diody sygnalizowane jest jej mrugnięciem
case 1:
blink_selected_led (&chimney);
break;

case 2:
blink_selected_led (&window_left);
break;

case 3:
blink_selected_led (&window_right);
break;

}
chose_led[set_chosen_led] = 0; // skosowanie zatwierdzenia wybrania diody do obróbki
}

/*Dla wybranej diody;
* - przypisujemy funkcję, która nią steruje
* - sterujemy jej: jasnością, nasycenem barw i szybkością zmian kolorów
* - zapisujemy całą strukture diody na stosie */
if(chose_led[set_chosen_led] == 1 ){
if(chose_led[chosen_led] == 1) {//Jeżeli zostałą wybrana dioda w kominie (dioda 1). command == <1,2> mówi nam o ilości funkcji do wyboru

//lcd_locate(0,0);
//lcd_str(" ");
//lcd_locate(0,0);
//lcd_int(window_left.timer_set);
//
//lcd_locate(0,4);
//lcd_str(" ");
//lcd_locate(0,4);
//lcd_long(window_left.period_time);

//lcd_locate(0,0);
//lcd_str(" ");
//lcd_locate(0,0);
//lcd_int(chimney.timer_set);
//
//lcd_locate(0,4);
//lcd_str(" ");
//lcd_locate(0,4);
//lcd_long(chimney.period_time);

//lcd_locate(0,8);
//lcd_str(" ");
//lcd_locate(0,8);
//lcd_int(chimney.saturation_max);

lcd_locate(1,12);
lcd_str(" ");
lcd_locate(1,12);
lcd_int(chose_led[chosen_led]);

//
//lcd_locate(0,4);
//lcd_str(" ");
//lcd_locate(0,4);
//lcd_int(chimney.LED_timer);

//lcd_locate(0,8);
//lcd_str(" ");
//lcd_locate(0,8);
//lcd_int(*new_value_max);

//lcd_locate(0,12);
//lcd_str(" ");
//lcd_locate(0,12);
//lcd_int(chimney.saturation_max);

//lcd_locate(1,0);
//lcd_str(" ");
//lcd_locate(1,0);
//lcd_int(chose_led[set_chosen_led]);

change_paramiters_diode_rgb(&chimney, command, chose_led[chosen_led]);
selected_rgb = chimney;//na potrzeby testów
}
if(chose_led[chosen_led] == 2){//Jeżeli zostałą wybrana dioda w lewym oknie (dioda 2)
change_paramiters_diode_rgb(&window_left, command, chose_led[chosen_led]);
//selected_rgb = window_left;//na potrzeby testów
}
if(chose_led[chosen_led] == 3){//Jeżeli zostałą wybrana dioda w lewym oknie (dioda 2)
change_paramiters_diode_rgb(&window_right, command, chose_led[chosen_led]);
//selected_rgb = window_right;//na potrzeby testów
}
}

//lcd_locate(1,0);
//lcd_str(" ");
//lcd_locate(1,0);
//lcd_int(chose_led[set_chosen_led]);
//
//lcd_locate(0,4);
//lcd_str(" ");
//lcd_locate(0,4);
//lcd_int(selected_rgb.LED_timer);
//
//
//lcd_locate(0,0);
//lcd_str(" ");
//lcd_locate(0,0);
//lcd_int(selected_rgb.timer_set);
//
//lcd_locate(0,12);
//lcd_str(" ");
//lcd_locate(0,12);
//lcd_int(selected_rgb.saturation_max);
//
//lcd_locate(1,5);
//lcd_str(" ");
//lcd_locate(1,5);
//lcd_int(selected_rgb.value_max);

/* wyzerowanie flagi odbioru oraz wartości odebranych kodów */
Ir_key_press_flag=0;
command=0xff;
address=0xff;

}

hsv_to_rgb(&chimney, gamma_correctionR, gamma_correctionR, gamma_correctionR);
hsv_to_rgb(&window_left, gamma_correctionR, gamma_correctionR, gamma_correctionR);
hsv_to_rgb(&window_right, gamma_correctionR, gamma_correctionR, gamma_correctionR);

}
}[/syntax]

d_led.h
[syntax=c]/*
* d_led.h
*
* Created on: 9 lis 2016
* Author: Piotr
*/

#ifndef D_LED_D_LED_H_
#define D_LED_D_LED_H_

#include "../MAKRAU/makrau.h"

//----------------------------------------------------------------------------------------
//
//Ustawienia sprzętowe połączeń LEDów z mikrokontrolerem
//
//----------------------------------------------------------------------------------------
// tu konfigurujemy port i piny do jakich podłączymy diody
//**** dioda RGB w koninie ****//
#define LED1_RPORT C
#define LED1_R 0
#define LED1_GPORT C
#define LED1_G 1
#define LED1_BPORT C
#define LED1_B 2

//**** dioda RGB w lewym oknie ****//
#define LED2_RPORT B
#define LED2_R 0
#define LED2_GPORT B
#define LED2_G 1
#define LED2_BPORT B
#define LED2_B 2
//
//**** dioda RGB w prawym oknie ****//
#define LED3_RPORT C
#define LED3_R 3
#define LED3_GPORT C
#define LED3_G 4
#define LED3_BPORT C
#define LED3_B 5

//**** diody przed domkiem ****//
#define LED4_1PORT C
#define LED4_1 6
#define LED4_2PORT C
#define LED4_2 7
#define LED4_3PORT D
#define LED4_3 0
#define LED4_4PORT D
#define LED4_4 1
#define LED4_5PORT D
#define LED4_5 2

#define TRUE 1
#define FALSE 0

#define PERIOD_TIME_LED 1500000//czas rozjaśniania i ściemniania diody w us
#define MAX_GAMMA255//maksymalny rozmiar tablicy korekcji gamma
#define TIMER_PWM_SET 50//podstawa czasowa timera sprzętowego w us

//****Wartości dla poszczególnych kolorów w przesrzeni HSV****//
#define RED 0
#define ORANGE 17
#define YELLOW 32
#define GREEN 85
#define AQUA 128
#define BLUE 171
#define MAGENTA 214

#define ON_OFF 12
#define BRIGHTNES_UP 16
#define BRIGHTNES_DOWN 17
#define TIMER_SLOW 21
#defineTIMER_FAST 22
#define COLORS_UP 19
#define COLORS_DOWN 56
#define SUBMIT 23
#defineSATURATION_UP 32
#define SATURATION_DOWN 33
#define RESET 19
#define COPY_SETINGS_RGB 43

uint8_t *new_value_max; //wskaźnik umożliwiający przekaznie nowej maksymalnej wartości pwm (maksymalnego rozświetlania) wybranej diody; zwraca go funkcja set_flashing_time
//uint16_t *new_time_set;
//uint32_t *new_period_time;// wskaźnik umożliwiający przekazanie nowej wartości długości czasu rozświetlania i ściemniania diody

//Makrodefinicja wyliczające rozmiar dowolnej tablicy
#define SIZE_TAB(x) ((sizeof(x)/sizeof(uint8_t))-2)

enum {R,G,B,H,S,V}; //Tablica typu enum z nazwwami i numerami poszczególnych zmiennych R=0, G=1, B=2, H=3, S=4, V=5

enum{KEY_0 = 0, KEY_1 = 1, KEY_2 = 2, KEY_3 = 3, KEY_4 = 4, KEY_5 = 5, KEY_6 = 6, KEY_7 = 7, KEY_8 = 8, KEY_9 = 9};
enum {chosen_led, set_chosen_led, chosen_function};
enum {chimney_rgb = 1, window_left_rgb, window_right_rgb};

//deklaracja struktury typu TLED_RGB
typedef struct {
uint8_t color[6];//wartość PWM diod RGB: R=0, G=1, B=2, H=3, S=4, V=5
volatile uint16_t timer_set;//zapamiętany czas rozświetlania i ściemniania diody RGB, ładowany do licznika LED_timer
volatile uint16_t LED_timer;//czas odliczany w przerwaniu
volatile uint32_t period_time;//zmienna za pomocą której ustawiamy nowy czas szybkości rozświetlania i ściemniania diody
uint8_t chosen_function;//zmienna informująca o wybranej funkcji do sterowania ledem
volatile uint8_t value_max;//zmienna odpowiedzialna za maksymalny strumień świetlny
volatile uint8_t saturation_max;//zmienna odpowiadajaca za maksymalne nasycenie kolorów
} TLED_RGB;

TLED_RGB chimney, window_left, window_right, selected_rgb;// deklaracja DIOD RGB typu TLED_RGB

//deklaracja struktury typu TLED
typedef struct {
volatile uint8_t pwm_max; // maksymalna wartość sygnału PWM (0-255)
volatile uint8_t LED_pwm;//wartość PWM diody
volatile uint16_t timer_set;//zapamiętany czas rozświetlania i ściemniania diody
volatile uint16_t LED_timer;//czas rozświetlania i ściemniania diody
uint8_t flag;//flaga informująca o narastaniu strumienia świetlnego
uint8_t i;//zmienna odpowiedzialna za wybór elementu tablicy korekty gamma
} TLED;

TLED ground1, ground2, tree1, selected_led;// deklaracja DIODY TLED

// definicje zmiennych do sterowania 8 kanałami programowych PWM
// zmienne typu uint8_t, rozdzielczość 8-bitowa

volatile uint16_t Timer1, Timer2, Timer3,Timer4, Timer5;// timery programowe

//------------------------------------------------ koniec ustawień sprzętowych ---------------

void d_led_init (void); //ustawienia pinów uP i LEDow
void timer2_init(void);// ustawienie Timera2
void control_leds (TLED *SLED, const uint8_t *gamma ); // funkcja obsługi pojedynczego LEDa
void set_flashing_led (uint8_t command, TLED *SLED);//****funkcja usttawiająca parametry świecenia pojedynczego LEDa****//
void hsv_to_rgb (TLED_RGB *myrgb, const uint8_t *gamma_r, const uint8_t *gamma_g, const uint8_t *gamma_b);//funkxja skalująca kolory HSV na RGB
void select_set_colors_rgb (TLED_RGB *sel_rgb);//funkcja zmieniająca kolory zgodnie z zadeklarowaną tablicą

uint8_t set_max_brightness (uint8_t command, uint8_t value_max, uint32_t period_time_led);//****funkcja ustawiająca maksymalne natężenie jasności diody oraz rozświetlania i ściemniania****//
uint16_t time_change (uint8_t command, uint8_t value_max, uint32_t period_time );// funkcja umożliwiająca zmianę czasu rozjaśniania i ściemniania diody
uint8_t set_max_saturation (uint8_t command, uint8_t saturation);//funkcja zwracająca maksymalne nasycenie kolorów
void flow_colors_rgb (TLED_RGB *sel_rgb);//Funkcja cyklicznie zmieniająca kolory
void blink_selected_led (TLED_RGB *led_rgb); //funkcja mrugnąca wybraną diodą

void change_paramiters_diode_rgb(TLED_RGB *diode_rgb, uint8_t command, uint8_t chose_led);//funkcja zmieniająca parametry wybranej diody rgb
uint16_t set_new_time_set(uint8_t max_value, uint32_t period_time);//funkcja wyznaczająca nowy czas czas do odliczania w przerwaniu dla dowolnej diody

#endif /* D_LED_D_LED_H_ */[/syntax]

d_led.c
[syntax=c]/*
* main.c
*
* Created on: 9 lis 2016
* Autor: Piotr Łączny
*/
#include //dołączenie głównego systemowego pliku nagłówkowego
#include //dołączenie pliku nagłówkowego do obsługi przerwań
#include //dołączenie pliku nagłówkowego do obsługi pamięci FLASH??

#include "d_led.h"
#include "../MAKRAU/makrau.h"
#include "../gamma_CORRECTION/gamma.h"
#include "../LCD/lcd44780.h"

// definicje zmiennych do sterowania 6 kanałami programowych PWM
// zmienne typu uint8_t, rozdzielczość 8-bitowa
//volatile uint8_t LED1_color[R], LED1_color[G], LED1_color[B], LED2_color[R], LED2_color[G], LED2_color[B], LED3_color[R], LED3_color[G], LED3_color[B];//programowe wyjścia PWM diod RGB
//volatile uint8_t pwm4, pwm5, pwm6, pwm7, pwm8;//programowe wyjścia PWM

//----------------------------------------------------------------------------------------
//
// ******* INICJALIZACJA LEDÓW ********
//
//----------------------------------------------------------------------------------------
void d_led_init(void)
{

// **** ustawienie pinów kanałów programowych PWM jako WYJŚCIA **** //
//** dioda RGB w kominie **//
DDR(LED1_RPORT) |= (1<DDR(LED1_GPORT) |= (1<DDR(LED1_BPORT) |= (1<
////** dioda RGB w lewym oknie **//
DDR(LED2_RPORT) |= (1<DDR(LED2_GPORT) |= (1<DDR(LED2_BPORT) |= (1<//
////** dioda RGB w prawym oknie **//
DDR(LED3_RPORT) |= (1<DDR(LED3_GPORT) |= (1<DDR(LED3_BPORT) |= (1<
//** diody przed domkiem **//
DDR(LED4_1PORT) |= (1<DDR(LED4_2PORT) |= (1<DDR(LED4_3PORT) |= (1<DDR(LED4_4PORT) |= (1<DDR(LED4_5PORT) |= (1<
// **** wyłączenie diod LED podłączonych katodami do wyjść **** //
//** dioda RGB w kominie **//
PORT(LED1_RPORT) |= (1<PORT(LED1_GPORT) |= (1<PORT(LED1_BPORT) |= (1<
//// ** dioda RGB w lewym oknie ** //
PORT(LED2_RPORT) |= (1<PORT(LED2_GPORT) |= (1<PORT(LED2_BPORT) |= (1<//
//// ** dioda RGB w lprawym oknie ** //
PORT(LED3_RPORT) |= (1<PORT(LED3_GPORT) |= (1<PORT(LED3_BPORT) |= (1<
// ** diody przed domkiem ** //
PORT(LED4_1PORT) |= (1<PORT(LED4_2PORT) |= (1<PORT(LED4_3PORT) |= (1<PORT(LED4_4PORT) |= (1<PORT(LED4_5PORT) |= (1<

}

//----------------------------------------------------------------------------------------
//
// ******* INICJALIZACJA TIMERA2 ********
//
//----------------------------------------------------------------------------------------
void timer2_init(void)
{

// ustawienia TIMER2 w tryb CTC
TCCR2 |= (1<TCCR2 |=(1<OCR2 = 12;// dodatkowy podział częsttotliwości przez 50 (przerwanie co 50us) //// dodatkowy podział częsttotliwości przez 50 (przerwanie co 50us)
TIMSK |= (1<}

//----------------------------------------------------------------------------------------
//
// *******FUNKCJE DIOD RGB********
//
//----------------------------------------------------------------------------------------

//----------------------------------------------------------------------------------------
//
// ******* SKALOWANIE HSV NA RGB ********
//
//H:0-255, 0=R, 42=Yellow, 85= GREEN, 128=Aqua, 171=Blue, 214=Magenta
//S:0-255, 0 = tylko biała barwa, 255 = pełne kolory
//V: 0-255, 0 = brak światła, 255 = maksymalna jasność
//
//----------------------------------------------------------------------------------------
void hsv_to_rgb (TLED_RGB *myrgb, const uint8_t *gamma_r, const uint8_t *gamma_g, const uint8_t *gamma_b){//funkxja skalująca kolory HSV na RGB
uint16_t region, remainder, p, q, t;
if (myrgb->color[S]==0){
myrgb->color[R] = pgm_read_byte(&gamma_r[(myrgb->color[V])]);
myrgb->color[G] = pgm_read_byte(&gamma_g[(myrgb->color[V])]);
myrgb->color[B] = pgm_read_byte(&gamma_b[(myrgb->color[V])]);
}//(myrgb->color[S]==0)
else {
region =myrgb->color[H]*6/256;
remainder =(myrgb->color[H]*6)%256;

p = (myrgb->color[V] *(255 - myrgb->color[S]))/256;
q = (myrgb->color[V] *(255 - (myrgb->color[S] * remainder) / 256)) / 256;
t = (myrgb->color[V] *(255 - (myrgb->color[S] * (255 - remainder)) / 256)) / 256;

switch (region) {
case 0:
myrgb->color[R] = pgm_read_byte(&gamma_r[(myrgb->color[V])]);myrgb->color[G] = pgm_read_byte(&gamma_g[t]);myrgb->color[B] = pgm_read_byte(&gamma_b[p]);
break;
case 1:
myrgb->color[R] = pgm_read_byte(&gamma_r[q]); myrgb->color[G] = pgm_read_byte(&gamma_g[(myrgb->color[V])]); myrgb->color[B] = pgm_read_byte(&gamma_b[p]);
break;
case 2:
myrgb->color[R] = pgm_read_byte(&gamma_r[p]);myrgb->color[G] = pgm_read_byte(&gamma_g[(myrgb->color[V])]); myrgb->color[B] = pgm_read_byte(&gamma_b[t]);
break;
case 3:
myrgb->color[R] = pgm_read_byte(&gamma_r[p]); myrgb->color[G] = pgm_read_byte(&gamma_g[q]); myrgb->color[B] = pgm_read_byte(&gamma_b[(myrgb->color[V])]);
break;
case 4:
myrgb->color[R] = pgm_read_byte(&gamma_r[t]); myrgb->color[G] = pgm_read_byte(&gamma_g[p]); myrgb->color[B] = pgm_read_byte(&gamma_b[(myrgb->color[V])]);
break;
case 5:
myrgb->color[R] = pgm_read_byte(&gamma_r[(myrgb->color[V])]);myrgb->color[G] = pgm_read_byte(&gamma_g[p]); myrgb->color[B] = pgm_read_byte(&gamma_b[q]);
break;
}// (region)
}//else
}

//****Funkcja mrugająca wybraną diodą RGB****//
void blink_selected_led(TLED_RGB *led_rgb){
led_rgb->color[S]= 0;
led_rgb->color[V]= 255;
led_rgb->LED_timer = 200;
}

//****Funkcja zmieniająca kolory diody RGB zgodnie z zadeklarowaną tablicą COLOR****//
void select_set_colors_rgb (TLED_RGB *sel_rgb){

uint8_t COLORS[]={RED, ORANGE, YELLOW ,GREEN, AQUA, BLUE, MAGENTA };//
static uint8_t select_color = 0, flaga_rgb = 0, i = 0;

if (!flaga_rgb){
if(i>=sel_rgb->value_max)
{
flaga_rgb = 1;
i = sel_rgb->value_max;
sel_rgb->color[V]=i;
sel_rgb->color[S] = sel_rgb->saturation_max;
}//(i>=sel_rgb->pwm_max)
else
{
sel_rgb->color[H]=COLORS[select_color];
sel_rgb->color[V]=i;
sel_rgb->color[S] = sel_rgb->saturation_max;
i ++;
}//else

}//(!flaga_rgb)
else{
if(i==0){
flaga_rgb = 0;
if (select_color <= SIZE_TAB(COLORS))select_color ++;
else select_color =0 ;
}//if(i==0)
else
{
sel_rgb->color[V]=i;
i--;
}//else
}//else
}

//****Funkcja cyklicznie zmieniająca kolory****//
void flow_colors_rgb (TLED_RGB *sel_rgb){

static uint8_t i_h = 0;
sel_rgb->color[H] = i_h;
sel_rgb->color[S] = sel_rgb->saturation_max;
sel_rgb->color[V] = sel_rgb->value_max;
i_h += 1;
}

//****funkcja zmieniająca parametry wybranej diody rgb****//
void change_paramiters_diode_rgb(TLED_RGB *diode_rgb, uint8_t command, uint8_t chose_led ){
switch(command){
case KEY_1:
diode_rgb->chosen_function = 1;
break;

case KEY_2:
diode_rgb->chosen_function = 2;
break;

case BRIGHTNES_UP:
if(diode_rgb->value_max > 245) diode_rgb->value_max = 255;
else diode_rgb->value_max += 10;
diode_rgb->timer_set = set_new_time_set(diode_rgb->value_max,diode_rgb->period_time);
break;

case BRIGHTNES_DOWN:
if(diode_rgb->value_max <10 ) diode_rgb->value_max = 0;
else diode_rgb->value_max -= 10;
diode_rgb->timer_set = set_new_time_set(diode_rgb->value_max,diode_rgb->period_time);
break;

case TIMER_FAST:
if(diode_rgb->period_time>= PERIOD_TIME_LED) diode_rgb->period_time = PERIOD_TIME_LED; //sprawdzenie czy nasze wypełnienie jest więsze od 245 i czy został ponownie wciśnięty klawisz zwiększania
else diode_rgb->period_time +=15000;
diode_rgb->timer_set = set_new_time_set(diode_rgb->value_max,diode_rgb->period_time);
break;

case TIMER_SLOW:
if(diode_rgb->period_time <= 15000) diode_rgb->period_time = 1;
else diode_rgb->period_time -= 15000;
diode_rgb->timer_set = set_new_time_set(diode_rgb->value_max,diode_rgb->period_time);
break;

case SATURATION_UP:
if(diode_rgb->saturation_max != 255)diode_rgb->saturation_max += 5;
break;

case SATURATION_DOWN:
if(diode_rgb->saturation_max)diode_rgb->saturation_max -= 5;
break;

//case COPY_SETINGS_RGB://kopiowanie ustawiń wybranej diody do pozostałych diod RGB
//PORT(LED4_3PORT) ^= (1<//
//switch(chose_led){
//
//case chimney_rgb:
//
////lcd_locate(0,0);
////lcd_str(" ");
////lcd_locate(0,0);
////lcd_int(window_left.timer_set);
////
////lcd_locate(0,4);
////lcd_str(" ");
////lcd_locate(0,4);
////lcd_long(window_left.period_time);
//
//
////
////window_left.chosen_function = chimney.chosen_function;
////window_left.color[H] = chimney.color[H];
////window_left.color[S] = chimney.color[S];
////window_left.color[V] = chimney.color[V];
////window_left.saturation_max = chimney.saturation_max;
////window_left.value_max = chimney.value_max;
////window_left.timer_set = chimney.timer_set;
//
//
//window_left = chimney;//*diode_rgb;
////window_left = chimney;
//
//
////PORT(LED4_3PORT) ^= (1<//
////lcd_locate(1,0);
////lcd_str(" ");
////lcd_locate(1,0);
////lcd_int(window_left.timer_set);
////
////lcd_locate(1,4);
////lcd_str(" ");
////lcd_locate(1,4);
////lcd_long(window_left.period_time);
//
////lcd_locate(1,8);
////lcd_str(" ");
////lcd_locate(1,8);
////lcd_int(window_right.saturation_max);
//
//
////lcd_locate(0,0);
////lcd_str(" ");
////lcd_locate(0,0);
////lcd_int(window_right.timer_set);
////
////lcd_locate(0,4);
////lcd_str(" ");
////lcd_locate(0,4);
////lcd_int(window_right.LED_timer);
////
////lcd_locate(0,8);
////lcd_str(" ");
////lcd_locate(0,8);
////lcd_int(*new_value_max);
////
////lcd_locate(0,12);
////lcd_str(" ");
////lcd_locate(0,12);
////lcd_int(window_right.saturation_max);
////
////if (!*new_value_max){
////lcd_locate(1,0);
////lcd_str(" ");
////lcd_locate(1,0);
////lcd_int(chose_led);
////
////lcd_locate(1,5);
////lcd_str(" ");
////lcd_locate(1,5);
////lcd_int(window_right.value_max);
////}
//
//break;
//
//case window_left_rgb:
//chimney = window_left ;
//window_right = window_left ;
//break;
//
//case window_right_rgb:
//chimney = window_right ;
//window_left = window_right ;
//break;
//
//}
//break;

}

}

//----------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------

//----------------------------------------------------------------------------------------
//
// *******FUNKCJE POJEDYNCZEJ DIODY********
//
//----------------------------------------------------------------------------------------

//****funkcja automatycznie rozjaśniająca i ściemniająca diodę z uwzględnieniem ograniczenia maksymalnego rozświetlenia****//
void control_leds (TLED *SLED, const uint8_t *gamma)// funkcja obsługi pojedynczego LEDa
{
//pętla rozjaśniająca
if (!SLED->LED_timer && SLED->flag)
{
if(SLED->i < SLED->pwm_max){//sprawdzenie czy został osiągnięty maksymelny strumień świetlny
SLED->i++;//zwiększenie wartości współczynnika PWM
SLED->LED_pwm=(pgm_read_byte(&gamma[(SLED->i)]));//zapisanie wartości korekcji gamma do sygnału PWM
}
else SLED->flag = FALSE;// jeżeli osiągną to zeruj flagę}
SLED->LED_timer = SLED->timer_set;//ponowne ustawienie okresu sygnału PWM
}

// pętla stopniowo ściemniająca
if(!SLED->LED_timer && !SLED->flag)
{
if (!SLED->i)SLED->flag = TRUE;//sprawdzenie czy "i=0" jeśli tak, to przejdź do rozjaśniania pętli
else{
SLED->i--;//zmniejszanie wartości współczynnika PWM
SLED->LED_pwm=(pgm_read_byte(&gamma[(SLED->i)]));//zapisanie wartości korekcji gamma do sygnału PWM
}
SLED->LED_timer = SLED->timer_set;//ponowne ustawienie okresu sygnału PWM
}
}

//----------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------

//----------------------------------------------------------------------------------------
//
// *******FUNKCJE WSPÓLNE********
//
//----------------------------------------------------------------------------------------

////****funkcja ustawiająca maksymalne natężenie jasności diody
////uwzględniajać założony czas rozświetlania i ścieminiania diody
////wynoszący PERIOD_TIME_LED****//
//uint8_t set_max_brightness (uint8_t command, uint8_t value_max, uint32_t period_time_led)
//{
//uint16_t temp = 0;
//
//if(command == BRIGHTNES_UP)
//{
////zwiększenie jasności świecenia diody diody
//if(value_max > 245) value_max =255; //sprawdzenie czy nasze wypełnienie jest więsze od 245 i czy został ponownie wciśnięty klawisz zwiększania
//else value_max +=10;
//}
//
//if(command == BRIGHTNES_DOWN)//zmniejszenie jesności świecenia diody diody
//{
//if(value_max < 10) value_max = 0;
//else value_max -= 10;
//}
//
//if(value_max) temp = TIMER_PWM_SET * value_max;//zapobiegnięcie dzielenia przez 0
//else temp =600 * TIMER_PWM_SET;//mnożenie przez 600 powoduje szybsze zgaśnięcie diody dla PWM =0
//temp = period_time_led / temp;
//
//*new_time_set = temp;
//return value_max;
//}

////****funkcja ustawiająca zmianę czasu rozjaśniania i ściemniania diody****//
//uint16_t time_change (uint8_t command, uint8_t value_max, uint32_t period_time )
//{
//uint16_t temp = 0;
//
//if(command == TIMER_FAST)//zwiększenie jasności świecenia diody diody
//{
//if(period_time >= PERIOD_TIME_LED) period_time = PERIOD_TIME_LED; //sprawdzenie czy nasze wypełnienie jest więsze od 245 i czy został ponownie wciśnięty klawisz zwiększania
//else period_time +=15000;
//}
//
//if(command == TIMER_SLOW)//zmniejszenie jesności świecenia diody diody
//{
//if(period_time <= 15000) period_time = 1;
//else period_time -= 15000;
//}
//
//if(value_max) temp = TIMER_PWM_SET * value_max;//zapobiegnięcie dzielenia przez 0
//else temp =600 * TIMER_PWM_SET;//mnożenie przez 600 powoduje szybsze zgaśnięcie diody dla PWM =0
//temp = period_time/ temp;
//
//*new_period_time = period_time;
//return temp;
//}

//****funkcja zwracająca maksymalne nasycenie kolorów****//
uint8_t set_max_saturation (uint8_t command, uint8_t saturation){

if(command == SATURATION_UP && saturation != 255){
saturation += 5;
}
if(command == SATURATION_DOWN && saturation){
saturation -= 5;
}

return saturation;
}

//****funkcja wyznaczająca nowy czas czas do odliczania w przerwaniu dla dowolnej diody****//
uint16_t set_new_time_set(uint8_t max_value, uint32_t period_time)
{
uint16_t temp =0;
if(max_value) temp = TIMER_PWM_SET * max_value;//zapobiegnięcie dzielenia przez 0
else temp =600 * TIMER_PWM_SET;//mnożenie przez 600 powoduje szybsze zgaśnięcie diody dla PWM =0
return period_time / temp;
}

// ciało procedury obsługi przerwania Compare Match Timera2, wywoływane co 50us
ISR( TIMER2_COMP_vect )
{

uint16_t n;// zmienna na potrzeby przerwania
static uint8_t cnt; // definicja naszego licznika PWM

n = ground1.LED_timer;/* 20 kHz ground1.LED_timer - 50us*/
if (n) ground1.LED_timer = --n;

n = ground2.LED_timer; /* 1000Hz ground2.LED_timer 50us*/
if (n) ground2.LED_timer = --n;

n = chimney.LED_timer;/* */
if(n) chimney.LED_timer = --n;

n = window_left.LED_timer;/* */
if(n) window_left.LED_timer = --n;

n = window_right.LED_timer;/* */
if(n) window_right.LED_timer = --n;

n = Timer3;/*Timer3 */
if(n) Timer3 = --n;
//n = Timer4;/*Timer3 */
//if(n) Timer4 = --n;
//n = Timer5;/*Timer3 */
//if(n) Timer5 = --n;

// **** BEZPOŚREDNIE STEROWANIE WYJŚCIAMI KANAŁÓW PWM **** //

//**** dioda RGB w kominie ****//
if(cnt >= chimney.color[G]) PORT(LED1_GPORT) |= (1<if(cnt >= chimney.color[R]) PORT(LED1_RPORT) |= (1<if(cnt >= chimney.color[B]) PORT(LED1_BPORT) |= (1<
////**** dioda RGB w lewym oknie ****//
if(cnt >= window_left.color[G]) PORT(LED2_GPORT) |= (1<if(cnt >= window_left.color[R]) PORT(LED2_RPORT) |= (1<if(cnt >= window_left.color[B]) PORT(LED2_BPORT) |= (1<
////**** dioda RGB w prawym oknie ****//
if(cnt >= window_right.color[G]) PORT(LED3_GPORT) |= (1<if(cnt >= window_right.color[R]) PORT(LED3_RPORT) |= (1<if(cnt >= window_right.color[B]) PORT(LED3_BPORT) |= (1<
//**** diody przed domkiem ****//
if(cnt >= ground1.LED_pwm) PORT(LED4_1PORT) |= (1<if(cnt >= ground2.LED_pwm) PORT(LED4_2PORT) |= (1<

//if(cnt >= ground5.LED_pwm) PORT(LED4_5PORT) |= (1<
//LED_DATA = data;
//SendSPI(data);

cnt++;// zwiększanie licznika o 1
}[/syntax]

Wczoraj pobawiłem się trochę programem i zrobiłem po trzy kopie funkcji select_set_colors_rgb oraz flow_colors_rgb (oczywiście lekko zmodyfikowałem ich nazwy) i każdą z kopi wywołuję w main.c
[syntax=c]//**************************************************************//
////
//****Fragment kodu wywołujący funkcję sterujące diodami RGB****//
////
//**************************************************************//
//**Dioda w kominie**//
if(!chimney.LED_timer){
if(chimney.chosen_function == 1){//wybór funkcji wyświetlania led
select_set_colors_rgb_ch(&chimney);//rozświetlanie i ściemnianie wybranych kolorów
}
else if(chimney.chosen_function == 2){
flow_colors_rgb_ch (&chimney);//cykliczna zmiana pomiędzy kolorami
}
chimney.LED_timer=chimney.timer_set;
}
//**Dioda w lewym oknie**//
if(!window_left.LED_timer){
if(window_left.chosen_function == 1){//wybór funkcji wyświetlania led
select_set_colors_rgb_w_l(&window_left);//rozświetlanie i ściemnianie wybranych kolorów
}
else if(window_left.chosen_function == 2){
flow_colors_rgb_w_l (&window_left);//cykliczna zmiana pomiędzy kolorami
}
window_left.LED_timer=window_left.timer_set;
}
//**Dioda w prawym oknie**//
if(!window_right.LED_timer){
if(window_right.chosen_function == 1){//wybór funkcji wyświetlania led
select_set_colors_rgb_w_r(&window_right);//rozświetlanie i ściemnianie wybranych kolorów
}
else if(window_right.chosen_function == 2){
flow_colors_rgb_w_r (&window_right);//cykliczna zmiana pomiędzy kolorami
}
window_right.LED_timer=window_right.timer_set;
}[/syntax]
Efektem tego jest poprawne działanie programu (tzn. działanie programu wg moich założeń)

Statystyki: Napisane przez amilo_pa — 11 gru 2016, o 12:38

Re: Struktury + funkcje + przerwanie + stos = ?

2016-12-11T10:07:12+01:00

amilo_pa napisał(a):

Powyższe funkcje wykonywane są w programie głównym
[syntax=c]//**Dioda w kominie**//
if(!chimney.LED_timer){
if(chimney.chosen_function == 1){//wybór funkcji wyświetlania led
select_set_colors_rgb(&chimney);//rozświetlanie i ściemnianie wybranych kolorów
}
else if(chimney.chosen_function == 2){
flow_colors_rgb (&chimney);//cykliczna zmiana pomiędzy kolorami
}
chimney.LED_timer=chimney.timer_set;
}[/syntax]

Na podstawie pokazanych fragmentów nie widać dokładnie, jak to masz zrobione, ale zwrócę uwagę, że wszelkiego rodzaju dostęp do zmiennej wielobajtowej, współdzielonej pomiędzy przerwaniami a pętlą główną programu powinien odbywać się atomowo, czyli w pętli głównej na czas operacji porównania lub przypisania należy wyłączyć globalne zezwolenie na przerwania (np. używając makra ATOMIC_BLOCK), czyli przykładowo:
[syntax=c]//
uint16_t tmp;
ATOMIC_BLOCK(ATOMIC_RESTORESTATE) { tmp = chimney.LED_timer; }
if(!tmp){
if(chimney.chosen_function == 1){//wybór funkcji wyświetlania led
select_set_colors_rgb(&chimney);//rozświetlanie i ściemnianie wybranych kolorów
}
else if(chimney.chosen_function == 2){
flow_colors_rgb (&chimney);//cykliczna zmiana pomiędzy kolorami
}
ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
chimney.LED_timer=chimney.timer_set;
}
}
// i tak samo dla pozostałych struktur[/syntax]

Trudno ocenić na podstawie tych fragmentów, czy nie ma innych błędów, ale od tego bym zaczął, ponieważ jeśli tak nie zrobiłeś, zachowanie programu może być nieprzewidywalne.

Statystyki: Napisane przez andrews — 11 gru 2016, o 10:07

Struktury + funkcje + przerwanie + stos = ?

2016-12-11T11:01:03+01:00

Witam,
Mam zadeklarowane cztery struktury :
[syntax=c]//deklaracja struktury typu TLED_RGB
typedef struct {
uint8_t color[6];//wartość PWM diod RGB: R=0, G=1, B=2, H=3, S=4, V=5
volatile uint16_t timer_set;//zapamiętany czas rozświetlania i ściemniania diody RGB, ładowany do licznika LED_timer
volatile uint16_t LED_timer;//czas odliczany w przerwaniu
volatile uint32_t period_time;//zmienna za pomocą której ustawiamy nowy czas szybkości rozświetlania i ściemniania diody
uint8_t chosen_function;//zmienna informująca o wybranej funkcji do sterowania ledem
volatile uint8_t value_max;//zmienna odpowiedzialna za maksymalny strumień świetlny
volatile uint8_t saturation_max;//zmienna odpowiadajaca za maksymalne nasycenie kolorów
} TLED_RGB;

TLED_RGB chimney, window_left, window_right, selected_rgb;// deklaracja DIOD RGB typu TLED_RGB[/syntax]

Oraz dwie funkcję. Pierwsza:
[syntax=c]void select_set_colors_rgb (TLED_RGB *sel_rgb, uint8_t COLOR[7]){

uint8_t COLORS[]={RED, ORANGE, YELLOW ,GREEN, AQUA, BLUE, MAGENTA };//
static uint8_t select_color = 0, flaga_rgb = 0, i = 0;

if (!flaga_rgb){
if(i>=sel_rgb->value_max)
{
flaga_rgb = 1;
i = sel_rgb->value_max;
sel_rgb->color[V]=i;
sel_rgb->color[S] = sel_rgb->saturation_max;
}//(i>=sel_rgb->pwm_max)
else
{
sel_rgb->color[H]=COLOR[select_color];
sel_rgb->color[V]=i;
sel_rgb->color[S] = sel_rgb->saturation_max;
i ++;
}//else

}//(!flaga_rgb)
else{
if(i==0){
flaga_rgb = 0;
if (select_color <= SIZE_TAB(COLOR))select_color ++;
else select_color =0 ;
}//if(i==0)
else
{
sel_rgb->color[V]=i;
i--;
}//else
}//else
}[/syntax]

Druga
[syntax=c]//****Funkcja cyklicznie zmieniająca kolory****//
TLED_RGB flow_colors_rgb (TLED_RGB *sel_rgb){

static uint8_t i_h = 0;
sel_rgb->color[H] = i_h;
sel_rgb->color[S] = sel_rgb->saturation_max;
sel_rgb->color[V] = sel_rgb->value_max;
i_h += 1;

return *sel_rgb;
}[/syntax]

Powyższe funkcje wykonywane są w programie głównym
[syntax=c]//**Dioda w kominie**//
if(!chimney.LED_timer){
if(chimney.chosen_function == 1){//wybór funkcji wyświetlania led
select_set_colors_rgb(&chimney);//rozświetlanie i ściemnianie wybranych kolorów
}
else if(chimney.chosen_function == 2){
flow_colors_rgb (&chimney);//cykliczna zmiana pomiędzy kolorami
}
chimney.LED_timer=chimney.timer_set;
}
//**Dioda w lewym oknie**//
if(!window_left.LED_timer){
if(window_left.chosen_function == 1){//wybór funkcji wyświetlania led
select_set_colors_rgb(&window_left);//rozświetlanie i ściemnianie wybranych kolorów
}
else if(window_left.chosen_function == 2){
flow_colors_rgb (&window_left);//cykliczna zmiana pomiędzy kolorami
}
window_left.LED_timer=window_left.timer_set;
}
//**Dioda w prawym oknie**//
if(!window_right.LED_timer){
if(window_right.chosen_function == 1){//wybór funkcji wyświetlania led
select_set_colors_rgb(&window_right);//rozświetlanie i ściemnianie wybranych kolorów
}
else if(window_right.chosen_function == 2){
flow_colors_rgb (&window_right);//cykliczna zmiana pomiędzy kolorami
}
window_right.LED_timer=window_right.timer_set;
}[/syntax]

a ich wywołanie uzależnione jest od przerwania
[syntax=c]// ciało procedury obsługi przerwania Compare Match Timera2, wywoływane co 50us
ISR( TIMER2_COMP_vect )
{

uint16_t n;// zmienna na potrzeby przerwania
static uint8_t cnt; // definicja naszego licznika PWM

n = ground1.LED_timer;/* 20 kHz ground1.LED_timer - 50us*/
if (n) ground1.LED_timer = --n;

n = ground2.LED_timer; /* 1000Hz ground2.LED_timer 50us*/
if (n) ground2.LED_timer = --n;

n = chimney.LED_timer;/* */
if(n) chimney.LED_timer = --n;

n = window_left.LED_timer;/* */
if(n) window_left.LED_timer = --n;

n = window_right.LED_timer;/* */
if(n) window_right.LED_timer = --n;

// **** BEZPOŚREDNIE STEROWANIE WYJŚCIAMI KANAŁÓW PWM **** //

//**** dioda RGB w kominie ****//
if(cnt >= chimney.color[G]) PORT(LED1_GPORT) |= (1<if(cnt >= chimney.color[R]) PORT(LED1_RPORT) |= (1<if(cnt >= chimney.color[B]) PORT(LED1_BPORT) |= (1<
////**** dioda RGB w lewym oknie ****//
if(cnt >= window_left.color[G]) PORT(LED2_GPORT) |= (1<if(cnt >= window_left.color[R]) PORT(LED2_RPORT) |= (1<if(cnt >= window_left.color[B]) PORT(LED2_BPORT) |= (1<
////**** dioda RGB w prawym oknie ****//
if(cnt >= window_right.color[G]) PORT(LED3_GPORT) |= (1<if(cnt >= window_right.color[R]) PORT(LED3_RPORT) |= (1<if(cnt >= window_right.color[B]) PORT(LED3_BPORT) |= (1<
//**** diody przed domkiem ****//
if(cnt >= ground1.LED_pwm) PORT(LED4_1PORT) |= (1<if(cnt >= ground2.LED_pwm) PORT(LED4_2PORT) |= (1<

//if(cnt >= ground5.LED_pwm) PORT(LED4_5PORT) |= (1<
//LED_DATA = data;
//SendSPI(data);

cnt++;// zwiększanie licznika o 1
}[/syntax]

I teraz clou całej sprawy:
W momencie wywołania powyższych funkcji (zmienna ze struktur LED_timer == 0) dla wszystkich struktur, zmienne tych struktur kopiują się i wszystkie diody zaczynają jednocześnie mrugać. Czym to jest spowodowane?
Czy może to być wina/przyczyna, że np dla struktury chimney wykonujemy pierwszą funkcję (select_set_colors_rgb) - czyli cała struktura oraz funkcja są na stosie - a w trakcie tej operacji zostaje spełniony warunek dla struktury window_left i zostaje wywołana ta sama funkcja, w efekcie zmienne z wywołanych funkcji nakładają się na siebie i zapisują te same wartości do różnych struktur ?

Statystyki: Napisane przez amilo_pa — 11 gru 2016, o 00:14