ATNEL tech-forum 2013-08-29T15:40:40+01:00 https://forum.atnel.pl/feed.php?f=23&t=4002&mode 2013-08-28T14:34:28+01:00 2013-08-28T14:34:28+01:00 https://forum.atnel.pl/viewtopic.php?t=4002&p=47312#p47312 <![CDATA[Re: Wyświetlacz LED7 - sterowanie z dowolnych pinów]]> Statystyki: Napisane przez perlon — 28 sie 2013, o 14:34

]]> 2013-08-28T12:23:34+01:00 2013-08-28T12:23:34+01:00 https://forum.atnel.pl/viewtopic.php?t=4002&p=47290#p47290 <![CDATA[Re: Wyświetlacz LED7 - sterowanie z dowolnych pinów]]> perlon napisał(a):

Mamy demokrację i jest wybór


Oczywiście, że tak :lol: i to się wpisuje w główną zasadę, którą ja zawsze wyznaję, że nie ma NAJLEPSZEGO rozwiązania. Rozwiązań jest tyle ilu programistów jest na świecie ;)

Statystyki: Napisane przez mirekk36 — 28 sie 2013, o 12:23

]]> 2013-08-28T12:17:01+01:00 2013-08-28T12:17:01+01:00 https://forum.atnel.pl/viewtopic.php?t=4002&p=47287#p47287 <![CDATA[Re: Wyświetlacz LED7 - sterowanie z dowolnych pinów]]> . Poprawiłem jeszcze kod bo zabrakło w przerwaniu ustawienia flagi do multipleksu. Faktycznie przedstawione rozwiązanie jest zasobożerne i to jest koszt swobody pinologicznej. Być może w projektach bez krytycznych zależności czasowych pozwoli na uproszczenie płytki PCB, ale głównie służyło celom edukacyjnym (tablicowanie wskaźników etc). Chciałbym do tego kodu dołożyć jeszcze "ściemniacz" - czyli możliwość wprowadzenia wcześniejszego zgaszenia wyświetlacza jeszcze przed przeskokiem na kolejny wynikający z multipleksu ( taki programowy PWM ). Może ktoś podrzuci jakiś pomysł.

Statystyki: Napisane przez perlon — 28 sie 2013, o 12:17

]]> 2013-08-28T11:47:11+01:00 2013-08-28T11:47:11+01:00 https://forum.atnel.pl/viewtopic.php?t=4002&p=47284#p47284 <![CDATA[Re: Wyświetlacz LED7 - sterowanie z dowolnych pinów]]> Antystatyczny napisał(a):

tak na szybko podpowiedzieć, by raczej nie stosować skoku do funkcji wprost z przerwania. Unikamy w ten sposób niepotrzebnych rozkazow push i pop,


A tu są aż trzy skoki z przerwania do funkcji, z tej funkcji jeszcze do funkcji i chyba jeszcze raz. Niestety kod jest MEGA zagmatwany ... oczywiście jak działa to dobrze ;)

ale tak raczej nie należy podchodzić do pisania kodu. Tzn tak też na prawdę to warto się zastanowić w ogóle czy jest sens obsługi Wyświetlacza LED na różnych pinach ... ??? Tak sobie myślę tylko - że jak już ktoś niby usilnie potrzebuje rozbić to na różne piny - to zwykle chyba ma do czynienia z jakimś małym prockiem np ATtiny. No ok ... uda się ... ale z kolei KOSZT związany z

1. stratą pamięci FLASH
2. stratą szybkości

może być a dla mnie byłby wręcz nie do przyjęcia ;) to już bym wolał dać ciut większy procek ... ALBO ....

albo zrobić to tak jak się należy czyli np na REJESTRACH przesuwnych. Wtedy wystarczą (uwaga!) ramptem TRZY PINY a do tego na prawdę banalny i bardzo szybko działający kod do wsuwania w te rejestry danych i po zawodach.

To co tutaj piszę nie ma na celu "skrytykowania" tego projektu - raczej tylko zwrócenie uwagi jak się poruszać przy tworzeniu takich projektów na przyszłość.... Ale też to co piszę to moje subiektywne zdanie i oczywiście każdy może zrobić i robi po swojemu.

WAŻNE! że autorowi działa ;) i to się liczy.

Statystyki: Napisane przez mirekk36 — 28 sie 2013, o 11:47

]]> 2013-08-29T15:40:40+01:00 2013-08-27T23:41:25+01:00 https://forum.atnel.pl/viewtopic.php?t=4002&p=47273#p47273 <![CDATA[Wyświetlacz LED7 - sterowanie z dowolnych pinów]]> Klu tematu do zmienne tablicowe przechowujące przypisania segmentów do portów. Konfiguracja odbywa się przez odpowiednie wpisy w pliku nagłówkowym. Multipleksowanie odbywa się poprzez cykliczne wywołanie funkcji LED7_TIMER0_OVF_vect() wstrzykniętej w procedurę obsługi przerwania. Nazwa mówi sama za siebie. Być może nie najszczęśliwiej dobrana, bo może ktoś użyć innego timera do obsługi multipleksu. Miałem wersję multipleksowania na zasadzie flagi podnoszonej w przerwaniu i eventu wołanego w pętli głównej, ale doszedłem do wniosku, że wołanie bezpośrednio z przerwania pozwoli wyczyścić pętlę główną z kodu który de facto ukryłem w biblioteczce. Należy zaznaczyć, że kod zabiera sporo zasobów ale pozwala dowolnie żonglować podpięciem segmentów. Czas na kod.
Plik nagłówkowy .h:
[syntax=c]/*
* led7.h
*
* Created on: 03-11-2012
* Author: perlon
*/

#ifndef LED7_H_
#define LED7_H_

//------------ ustawienia konfiguracyjne ---------------

#define COUNT_DISPLAY4 // ilosc wyswietlaczy do multipleksu max 4
// jeżeli więcej to trzeba poprawic w "led7.c" deklaracje zmiennych aLED7TablicaCommon...
#define LIGHT_SEG_HISTATE0 // wysterowanie wspolną anodą/katodą stanem portu 1-wysokim 0-niskim
#define LIGHT_COMMON_HISTATE0 // wysterowanie segmentow stanem portu 1-wysokim 0-niskim
#define LED7_MULTIPLEX_TIMER50 // dzielnik przerwania TimerX do flagi zmiany wyswietlacza
#define LED7_PWM_TIMER1 // wypelnienie czasu swiecenia wyswietlacza od 0 do LED7_MULTIPLEX_TIMER
#define LED7_MULTIPLEX_EVENT1// obsluga multipleksu 0-w przerwaniu, 1-w pętli głównej

// zestaw flag ktore nalezy obsluzyc w przerwaniu multipleksera ( zmienna nLED7Flagi )
#define LED7_CHANGE_FLAG 0x01 // flaga wskazujaca na zmiane wyswietlacza w multipleksie
#define LED7_PWM_FLAG 0x02 // flaga wskazujaca na zgaszenie wyswietlacza przed multipleksem

// tu konfigurujemy port i piny do jakich podłączymy wspolne anody/katody wyswietlaczy LED
// dane te zostaną stablicowane ale w programie zostaną użyte w kolejnoci wg liczby COUNT_SEGMENTS
// wyswietlacz nr 1
#define LED7COMMON0_PORT D
#define LED7COMMON0 0
#define LED7COMMON1_PORT C
#define LED7COMMON1 5
#define LED7COMMON2_PORT C
#define LED7COMMON2 4
#define LED7COMMON3_PORT C
#define LED7COMMON3 3

// tu konfigurujemy port i piny do jakich podłączymy segmenty wyswietlacza LED
#define LED7A_PORT B
#define LED7A 6
#define LED7B_PORT B
#define LED7B 7
#define LED7C_PORT C
#define LED7C 0
#define LED7D_PORT C
#define LED7D 1
#define LED7E_PORT C
#define LED7E 2
#define LED7F_PORT D
#define LED7F 3
#define LED7G_PORT D
#define LED7G 7
#define LED7DP_PORT B
#define LED7DP 1

// Definicje znakow w kolejnosci uzycia w tabeli nZnaki z pliku led7.c
#define CHAR_SPACE0x00 // znak pusty
#define CHAR_00x3F
#define CHAR_10x06
#define CHAR_20x5B
#define CHAR_30x4F
#define CHAR_40x66
#define CHAR_50x6D
#define CHAR_60x7D
#define CHAR_70x07
#define CHAR_80x7F
#define CHAR_90x6F
#define CHAR_b0x7C
#define CHAR_o0x5C
#define CHAR_t0x78

// Definicja kropki jest poza tabela
#define CHAR_DP 0x80


//------------ koniec ustawień konfiguracyjnych ---------------

// Makra do obslugi flag
#define FLAGA_CHANGE_LED7 (nLED7Flagi & LED7_CHANGE_FLAG)
#define FLAGA_CHANGE_LED7_SET nLED7Flagi |= LED7_CHANGE_FLAG
#define FLAGA_CHANGE_LED7_CLR nLED7Flagi &= ~LED7_CHANGE_FLAG

#define FLAGA_PWM_LED7 (nLED7Flagi & LED7_PWM_FLAG)
#define FLAGA_PWM_LED7_SET nLED7Flagi |= LED7_PWM_FLAG
#define FLAGA_PWM_LED7_CLR nLED7Flagi &= ~LED7_PWM_FLAG

// Makro stan common
#if LIGHT_COMMON_HISTATE==0
#define LED7COM_ISL(x) (~(*aLED7TablicaCommonPORT[x]) & BIT_MASK(aLED7TablicaCommonPIN[x]))
#define LED7COM_SET(x) *aLED7TablicaCommonPORT[x] &= ~BIT_MASK(aLED7TablicaCommonPIN[x])
#define LED7COM_CLR(x) *aLED7TablicaCommonPORT[x] |= BIT_MASK(aLED7TablicaCommonPIN[x])
#define LED7COM_FLP(x) *aLED7TablicaCommonPORT[x] ^= BIT_MASK(aLED7TablicaCommonPIN[x])
#else
#define LED7COM_ISL(x) (*aLED7TablicaCommonPORT[x] & BIT_MASK(aLED7TablicaCommonPIN[x]))
#define LED7COM_SET(x) *aLED7TablicaCommonPORT[x] |= BIT_MASK(aLED7TablicaCommonPIN[x])
#define LED7COM_CLR(x) *aLED7TablicaCommonPORT[x] &= ~BIT_MASK(aLED7TablicaCommonPIN[x])
#define LED7COM_FLP(x) *aLED7TablicaCommonPORT[x] ^= BIT_MASK(aLED7TablicaCommonPIN[x])
#endif
// Makro stan segmentu
#if LIGHT_SEG_HISTATE==0
#define LED7SEG_ISL(x) (~(*aLED7TablicaSegmentPORT[x]) & BIT_MASK(aLED7TablicaSegmentPIN[x]))
#define LED7SEG_SET(x) *aLED7TablicaSegmentPORT[x] &= ~BIT_MASK(aLED7TablicaSegmentPIN[x])
#define LED7SEG_CLR(x) *aLED7TablicaSegmentPORT[x] |= BIT_MASK(aLED7TablicaSegmentPIN[x])
#define LED7SEG_FLP(x) *aLED7TablicaSegmentPORT[x] ^= BIT_MASK(aLED7TablicaSegmentPIN[x])
#else
#define LED7SEG_ISL(x) (*aLED7TablicaSegmentPORT[x] & BIT_MASK(aLED7TablicaSegmentPIN[x]))
#define LED7SEG_SET(x) *aLED7TablicaSegmentPORT[x] |= BIT_MASK(aLED7TablicaSegmentPIN[x])
#define LED7SEG_CLR(x) *aLED7TablicaSegmentPORT[x] &= ~BIT_MASK(aLED7TablicaSegmentPIN[x])
#define LED7SEG_FLP(x) *aLED7TablicaSegmentPORT[x] ^= BIT_MASK(aLED7TablicaSegmentPIN[x])
#endif

extern volatile uint8_t aLED7TablicaCyfr[COUNT_DISPLAY];// tablica z indeksami do znaków zdefiniowanych w tablicy aZnaki[] do wyswietlenia na poszczegolnych wyswietlaczach
extern volatile uint8_t nLED7TablicaKropek; // zmienna bitowa wyswietlania kropek

extern void LED7_INIT(void);
extern void LED7_TIMER_INTERRUPT(void);
#if LED7_MULTIPLEX_EVENT == 1
extern void LED7_EVENT(void);
#endif

#endif /* LED7_H_ */[/syntax]
plik .c
[syntax=c]/*
* led7.c
*
* Created on: 03-11-2012
* Author: perlon
*/
#include <avr/io.h>
#include <avr/pgmspace.h>

const uint8_t __bit_mask[] PROGMEM = {1,2,4,8,16,32,64,128}; // tablica maskowania bitow
#define BIT_MASK(x) pgm_read_byte(&__bit_mask[x])// makro do maskowania bitu

// Makra dostepu do portów
#define PORT(x) SPORT(x)
#define SPORT(x) (PORT##x)

// Makra dostępu do pinów
#define PIN(x) SPIN(x)
#define SPIN(x) (PIN##x)

// Makra dostępu do typu portu
#define DDR(x) SDDR(x)
#define SDDR(x) (DDR##x)

#include "led7.h"

// deklaracje zmiennych
volatile uint8_t *aLED7TablicaCommonDDR[] = {&DDR(LED7COMMON0_PORT),&DDR(LED7COMMON1_PORT),&DDR(LED7COMMON2_PORT),&DDR(LED7COMMON3_PORT)};
volatile uint8_t *aLED7TablicaCommonPORT[] = {&PORT(LED7COMMON0_PORT),&PORT(LED7COMMON1_PORT),&PORT(LED7COMMON2_PORT),&PORT(LED7COMMON3_PORT)};
volatile uint8_t aLED7TablicaCommonPIN[] = {LED7COMMON0,LED7COMMON1,LED7COMMON2,LED7COMMON3};
volatile uint8_t *aLED7TablicaSegmentDDR[] = {&DDR(LED7A_PORT),&DDR(LED7B_PORT),&DDR(LED7C_PORT),&DDR(LED7D_PORT),&DDR(LED7E_PORT),&DDR(LED7F_PORT),&DDR(LED7G_PORT),&DDR(LED7DP_PORT)};
volatile uint8_t *aLED7TablicaSegmentPORT[] = {&PORT(LED7A_PORT),&PORT(LED7B_PORT),&PORT(LED7C_PORT),&PORT(LED7D_PORT),&PORT(LED7E_PORT),&PORT(LED7F_PORT),&PORT(LED7G_PORT),&PORT(LED7DP_PORT)};
volatile uint8_t aLED7TablicaSegmentPIN[] = {LED7A,LED7B,LED7C,LED7D,LED7E,LED7F,LED7G,LED7DP};
volatile uint8_t aLED7TablicaCyfr[COUNT_DISPLAY];// tablica z indeksami do znaków zdefiniowanych w tablicy aZnaki[]
//do wyswietlenia na poszczegolnych wyswietlaczach
volatile uint8_t nLED7TablicaKropek;// zmienna bitowa wyswietlania kropek
volatile uint8_t nBiezacyWyswietlacz = 0;// biezacy wyswietlacz
volatile uint8_t nLED7Flagi = 0;// flagi obslugi wyswietlacza
// bit 0 - zmiana wyswietlacza w multipleksie
// bit 1 - dla sterowania PWM flaga swiecenia wyświetlacza

const uint8_t aLED7Znaki[] PROGMEM = { CHAR_SPACE,
CHAR_0,
CHAR_1,
CHAR_2,
CHAR_3,
CHAR_4,
CHAR_5,
CHAR_6,
CHAR_7,
CHAR_8,
CHAR_9,
CHAR_b,
CHAR_o,
CHAR_t
};

// definicje funkcji
void LED7_multiplex(void)
{
uint8_t i;

// przeskok na nastepny wyswietlacz
LED7COM_CLR(nBiezacyWyswietlacz);// zgas biezacy wyswietlacz
if(nBiezacyWyswietlacz)
nBiezacyWyswietlacz--;// przeskok wyswietlacza
else
nBiezacyWyswietlacz = COUNT_DISPLAY - 1;
for(i=0;i<7;i++)// zaladowanie nowego znaku do wyswietlacza
{
if(BIT_MASK(i) & pgm_read_byte(&aLED7Znaki[aLED7TablicaCyfr[nBiezacyWyswietlacz]]))
LED7SEG_SET(i);
else
LED7SEG_CLR(i);
}
if(nLED7TablicaKropek & BIT_MASK(nBiezacyWyswietlacz)) // obsluga kropki
LED7SEG_SET(7);
else
LED7SEG_CLR(7);
LED7COM_SET(nBiezacyWyswietlacz);// zapal biezacy wyswietlacz
#if LED7_PWM_TIMER < LED7_MULTIPLEX_TIMER
FLAGA_PWM_LED7_SET;// dla PWM ustawiamy stan zapalony
#endif
}

// procedura do umieszczenia w petli glownej
#if LED7_MULTIPLEX_EVENT == 1
void LED7_EVENT( void ){
if(FLAGA_CHANGE_LED7){
FLAGA_CHANGE_LED7_CLR;
LED7_multiplex();
}
#if LED7_PWM_TIMER < LED7_MULTIPLEX_TIMER
else if(FLAGA_PWM_LED7==0){
LED7COM_CLR(nBiezacyWyswietlacz);
}
#endif
}
#endif

// procedura do wstrzykniecia w procedure przerwania obslugujacego multipleksowanie np. do TIMER0_OVF_vect
// lub zastosowac inny sposob wywolania funkcji LED7_multiplex()
void LED7_TIMER_INTERRUPT(void)
{
static uint8_t nLED7Licznik=LED7_MULTIPLEX_TIMER;// licznik multiplexu LED7

// obsluga flag wyswietlacza LED7
if(nLED7Licznik){
nLED7Licznik--;
#if LED7_PWM_TIMER < LED7_MULTIPLEX_TIMER
if(nLED7Licznik < (LED7_MULTIPLEX_TIMER - LED7_PWM_TIMER)){
#if LED7_MULTIPLEX_EVENT == 0
LED7COM_CLR(nBiezacyWyswietlacz);
#elif LED7_MULTIPLEX_EVENT == 1
FLAGA_PWM_LED7_CLR;
#endif
}
#endif
}
else
{
nLED7Licznik = LED7_MULTIPLEX_TIMER;
#if LED7_MULTIPLEX_EVENT == 0
LED7_multiplex();
#elif LED7_MULTIPLEX_EVENT == 1
FLAGA_CHANGE_LED7_SET;
#endif
}

}

void LED7_INIT(void)
{
uint8_t i;

// ustawienie portow jako wyjscia dla wspolnych anod/katod cos w stylu
// DDR(LED7COMMON1_PORT) |= (1<<LED7COMMON1);
for(i=0;i<COUNT_DISPLAY;i++) *aLED7TablicaCommonDDR[i] |= BIT_MASK(aLED7TablicaCommonPIN[i]);
// i zgaszenie wszystkich wyswietlaczy
for(i=0;i<COUNT_DISPLAY;i++) LED7COM_CLR(i);
// ustawienie portow jako wyjscia dla segmentow cos w stylu
// DDR(LED7A_PORT)|= (1<<LED7A);
for(i=0;i<8;i++) *aLED7TablicaSegmentDDR[i] |= BIT_MASK(aLED7TablicaSegmentPIN[i]);
// Zgaszenie wszystkich segmentow wyswietlacza
for(i=0;i<8;i++) LED7SEG_CLR(i);
// i wszystkich kropek
nLED7TablicaKropek = 0;
}[/syntax]
przykład zastosowania:
[syntax=c]/*
* main.c
*
* Created on: 16-11-2012
* Author: perlon
*/

#include <avr/io.h>// podciągnięcie plików nagłówkowych
#include <avr/interrupt.h>

#include "LED7/led7.h"

volatile uint8_t tick_flag;

int main(void)
{
uint8_t licznik = 0;// zmienna do nastawy wyswietlanych danych

// inicjalizacja przerwania TIMER0 - obsluguje zdarzenie KBD_EVENT
TCCR0 |= (0<<CS02) | (1<<CS01)| (0<<CS00);// preskaler 8
TCNT0 = 156;// TIMER0 będzie liczył od 156 do 255 dla preskalera 8 i F_CPU=8MHz przerwanie będzie generowane co ok.100us
TIMSK = (1<<TOIE0);// odblokowanie przerwania OVERFLOW

LED7_INIT();

// ustawmy napis "boot"
aLED7TablicaCyfr[0] = 13;// indeks znaku z tablicy aLED7Znaki wpisany na pierwszy LED7
aLED7TablicaCyfr[1] = 12;// indeks znaku z tablicy aLED7Znaki wpisany na drugi LED7
aLED7TablicaCyfr[2] = 12;// indeks znaku z tablicy aLED7Znaki wpisany na trzeci LED7
aLED7TablicaCyfr[3] = 11;// indeks znaku z tablicy aLED7Znaki wpisany na czwarty LED7
nLED7TablicaKropek = 0;// na razie bez kropek

sei();// globalne odblokowanie przerwań

uint8_t i = 2;
while(i){
#if LED7_MULTIPLEX_EVENT==1
LED7_EVENT();
#endif
if(tick_flag){
tick_flag = 0;
i--;
}
}

// a teraz wyswietlamy kolejne znaki na wyswietlaczu LED7
tick_flag = 1;
licznik = 1;
while(1)
{
if(tick_flag){
tick_flag = 0;
if(nLED7TablicaKropek)
nLED7TablicaKropek = (nLED7TablicaKropek >> 1);
else
nLED7TablicaKropek = 8;
if(licznik)
licznik--;
else
licznik = 13;
switch(licznik){
case 13:
aLED7TablicaCyfr[0] = licznik;
aLED7TablicaCyfr[1] = 0;
aLED7TablicaCyfr[2] = 1;
aLED7TablicaCyfr[3] = 2;
break;
case 12:
aLED7TablicaCyfr[0] = licznik;
aLED7TablicaCyfr[1] = licznik+1;
aLED7TablicaCyfr[2] = 0;
aLED7TablicaCyfr[3] = 1;
break;
case 11:
aLED7TablicaCyfr[0] = licznik;
aLED7TablicaCyfr[1] = licznik+1;
aLED7TablicaCyfr[2] = licznik+2;
aLED7TablicaCyfr[3] = 0;
break;
default:
aLED7TablicaCyfr[0] = licznik;
aLED7TablicaCyfr[1] = licznik+1;
aLED7TablicaCyfr[2] = licznik+2;
aLED7TablicaCyfr[3] = licznik+3;
break;
}
}
#if LED7_MULTIPLEX_EVENT==1
LED7_EVENT();
#endif
}
}

ISR(TIMER0_OVF_vect)
{
static uint16_t nLicznik = 10000;

if(nLicznik)
nLicznik--;
else
{
nLicznik = 10000;
tick_flag = 1;
}
TCNT0 = 156;
LED7_TIMER_INTERRUPT();
}[/syntax]

Wszelkie krytyczne uwagi mile widziane jak również pomoc w optymalizacji kodu.

Jeszcze filmik. Sory za jakość ale nagrywałem kamerką laptopa. Do ATB włożona ATMega8 w przejściówce. Jak widać kabelki podłączone do różnych portów jak popadło.
iframe


Poprawka kodu.
Dla poprawności politycznej wprowadziłem możliwość obsługi multipleksowania w pętli głównej. Konfiguracja trybu oczywiście w pliku nagłówkowym. Zmieniłem również nazwę procedury do wstrzyknięcia w przerwanie.

Statystyki: Napisane przez perlon — 27 sie 2013, o 23:41

]]>