ATNEL tech-forum 2022-06-05T23:33:32+01:00 https://forum.atnel.pl/feed.php?f=22&t=21870&mode 2022-06-05T23:33:32+01:00 2022-06-05T23:33:32+01:00 https://forum.atnel.pl/viewtopic.php?t=21870&p=235589#p235589 <![CDATA[Re: Zegarek na bazie DVD PHILIPS DVP3042/12]]>

Statystyki: Napisane przez Elwood — 5 cze 2022, o 23:33

]]> 2019-10-24T09:53:50+01:00 2019-10-24T09:53:50+01:00 https://forum.atnel.pl/viewtopic.php?t=21870&p=222647#p222647 <![CDATA[Re: Zegarek na bazie DVD PHILIPS DVP3042/12]]>

Statystyki: Napisane przez cekin — 24 paź 2019, o 09:53

]]> 2019-10-23T22:29:28+01:00 2019-10-23T22:29:28+01:00 https://forum.atnel.pl/viewtopic.php?t=21870&p=222642#p222642 <![CDATA[Re: Zegarek na bazie DVD PHILIPS DVP3042/12]]>
Dokumentacje używałem ta :
http://www.datasheetcatalog.com/datashe ... 6512.shtml
W moim projekcie używałem programowego SPI. W przypadku sprzętowego należy chyba przewidzieć w układzie zworę na golpinach w celu zwarcia MOSI z MISO. Nie można tego połączyć na stałe gdyż nie zaprogramuje się procesora... Pamiętaj ze DO i DI(piny 5 i 6) są zwarte razem i podciągnięte do VCC za pomocą rezystora 10K

[syntax=c]uint8_t klawisz (void)// funkcja odczytu klawiszy z płytki wyświetlacza
{
uint8_t licznik=0x01,data=0;
CMD_1; // użycie lini STB
CMD_0;
SendVFDSpi(0b01000010); // wysłanie komendy odczytu rejestru patrz str 8 dokumentacji
PORT_DDR &=~(1<<SDIN); //zmiana pinu z wyjścia na wejście //Zmiana w DDR nie PORT
licznik=0x01; // ponowne ustawienie licznika

while( licznik )//odliczanie 8 bitów w pêtli do odbioru
{
SCK_1;
SCK_0;
if( PORT_PIN & (1<<SDIN)) data |=1; //iloczyn bitowy celem sprawdzenia wartości bitu
data<<=1;
licznik<<=1; //przesunięcie licznika w lewo celem maskowania odpowiedniego bitu
}
PORT_DDR |= (1<<SDIN); // ustawienie pinu z powrotem na wyjście
_delay_ms(150); //
return (data);
}


w kodzie programu używałem tego tak :
switch( klawisz() ); // rezultat z wywołania funkcji klawisz do instrukcji switch
{
case 128: // pierwszy klawisz
{
// tu kod np wejście w menu
}
break;

case 192: //dwa klawisze wciśnięte razem i wtedy np wyświetlacz on/off
{
//tu kod np liczba minus
}
break;
case 64: //drugi klawisz
{
//tu kod
}
case 32: //trzeci klawisz np liczba plus
{
// tu kod
}

}[/syntax]
możliwe są oczywiście tez inne kombinacje klawiszy np 1 z 3 itd, należy tylko policzyć sobie jaką liczbę zwróci wtedy funkcja.
Mam nadzieje ze rozjaśniłem sytuacje. W tym konkretnym przypadku wszystkie interesujące nas dane (3 bity) są zawarte w pierwszym odczytywanym bajcie choć sterownik ma dużo większe możliwości i cała matryca zajmuje aż 3 bajty. Regulacja kontrastu tez działa tutaj kulawo i mimo ze ma aż 7 stopni to najlepiej regulować ze skokiem co 2 pozycje - inaczej nie zauważysz praktycznie zmiany..
Podłączenie klawiszy :
Klawisz open/close pin 11(K1) sterownika VFD
Klawisz stop pin 12(K2)
Klawisz Play/Pause pin 13(K3)
drugi koniec jest na pinie 15 (S0/K0)

Statystyki: Napisane przez Elwood — 23 paź 2019, o 22:29

]]> 2019-10-23T11:12:44+01:00 2019-10-23T11:12:44+01:00 https://forum.atnel.pl/viewtopic.php?t=21870&p=222625#p222625 <![CDATA[Re: Zegarek na bazie DVD PHILIPS DVP3042/12]]> https://produto.mercadolivre.com.br/MLB-1025564758-placa-display-dvd-philips-dvp530bk-40-dvp520-fcb2x-_JM

Statystyki: Napisane przez cekin — 23 paź 2019, o 11:12

]]> 2019-10-22T22:15:41+01:00 2019-10-22T22:15:41+01:00 https://forum.atnel.pl/viewtopic.php?t=21870&p=222622#p222622 <![CDATA[Re: Zegarek na bazie DVD PHILIPS DVP3042/12]]> Statystyki: Napisane przez Elwood — 22 paź 2019, o 22:15

]]> 2019-10-21T12:37:22+01:00 2019-10-21T12:37:22+01:00 https://forum.atnel.pl/viewtopic.php?t=21870&p=222596#p222596 <![CDATA[Re: Zegarek na bazie DVD PHILIPS DVP3042/12]]> Posiadam podobny moduł z DVD524/04, mieści się tam sterownik CS16312EN. Nie wiem jak dokonać odczytu z klawiatury...
Elwood napisał(a):

Jeżeli ktoś jest zainteresowany to mogę też dodać funkcje odczytu klawiszy ze sterownika VFD.

Jestem zainteresowany funkcja do odczytu z klawiatury :)

Statystyki: Napisane przez cekin — 21 paź 2019, o 12:37

]]> 2019-04-09T21:57:35+01:00 2019-04-09T21:57:35+01:00 https://forum.atnel.pl/viewtopic.php?t=21870&p=218079#p218079 <![CDATA[Re: Zegarek na bazie DVD PHILIPS DVP3042/12]]> Marhef napisał(a):

Elwood napisał(a):
z powodu jakiegoś dziwnego błędu nie moglem zastosować poligonów masy
A w jaki sposób próbowałeś je dodać?
Ja już dawno nie pracuję w eagle'u, ale z tego, co pamiętam, należy narysować obrys poligonu, zmienić mu nazwę na GND i użyć przycisku do przerysowania połączeń (ratsnet?)

Jest tak jak piszesz. A ja wcześniej najpierw po kliknieciu w polygons nadawałem nazwe a potem dopiero rysowałem i uzywałem Ratsnet. Jak nadaje nazwę dopiero po narysowaniu to jest ok. Dzięki za pomoc.

Statystyki: Napisane przez Elwood — 9 kwi 2019, o 21:57

]]> 2019-04-08T07:33:13+01:00 2019-04-08T07:33:13+01:00 https://forum.atnel.pl/viewtopic.php?t=21870&p=218014#p218014 <![CDATA[Re: Zegarek na bazie DVD PHILIPS DVP3042/12]]> Elwood napisał(a):

z powodu jakiegoś dziwnego błędu nie moglem zastosować poligonów masy
A w jaki sposób próbowałeś je dodać?
Ja już dawno nie pracuję w eagle'u, ale z tego, co pamiętam, należy narysować obrys poligonu, zmienić mu nazwę na GND i użyć przycisku do przerysowania połączeń (ratsnet?)

Statystyki: Napisane przez Marhef — 8 kwi 2019, o 07:33

]]> 2019-04-07T21:45:55+01:00 2019-04-07T21:45:55+01:00 https://forum.atnel.pl/viewtopic.php?t=21870&p=218010#p218010 <![CDATA[Re: Zegarek na bazie DVD PHILIPS DVP3042/12]]> ObrazekObrazekObrazekObrazekObrazek

Przedstawiam "ulepszona" wersje w/w zegarka. Po obejrzeniu poradników pana Mirka zaprojektowałem w końcu schemat elektryczny w eaglu i swoja pierwsza w życiu płytkę drukowana która następnie wykonałem metoda termo-transferu. Jak na pierwszy raz wyszła myślę całkiem dobrze- pomijając fakt ze z powodu jakiegoś dziwnego błędu nie moglem zastosować poligonów masy oraz sprawdziłem przy okazji mazak do obwodów drukowanych który zakupiłem gdzieś tak z 5 lat temu ;) W kilku miejscach płytka została podtrawiona ale nie wiem czy to wina tego ze toner nie przylepił się do płytki(kontrast wydruku ustawiony był na max) czy tego ze leżała kilka godzin w wytrawiaczu. Pocynowałem ścieżki i przejrzałem całość pod lupa oraz sprawdziłem połączenia. Jest w porządku. W każdym razie pierwsze koty za ploty i nie będę musiał się już męczyć na płytkach uniwersalnych jak do tej pory tylko muszę dopracować technologie. Na ta chwile wiem ze trzeba na pewno na początku dawać większe pola miedzi niż zastosowałem oraz bardzo dokładnie nakładać powłokę mazakiem ochronnym. W każdym razie zdobyłem cenne doświadczenie przed kolejnym projektem.
Ze zmian elektrycznych na ta chwile jest tylko inne przypisanie poszczególnych portów które wynikło podczas projektowania PCB. Z RTC skasowałem tez diodę led gdyż nie ma sensu aby świeciła w środku obudowy. Zredukowałem tez prędkość procesora do 4MGHz. Diodę prostownicza obok układu RTC zlikwidowałem już wcześniej - te chińskie moduły maja błąd i bateria jest ładowana a nie powinna. Zapomniałem o tym napisać poprzednio. Bibliotekę do tego modułu RTC znalazłem na jakimś forum arduino. Proponuje na starcie wywalić ze schematu modułu w ogóle pady z tej strony gdzie są 4 a do pinów VCC i masy w tym miejscu wlutować dodatkowy kondensator filtrujący zasilanie jak na foto.
Teraz muszę jeszcze zebrać się w sobie i w końcu dłubnąć program gdyż po dodaniu na starcie procedury przewijającej cyfry 0-9 co 250ms zabrakło miejsca na kolejne rzeczy program zajmuje teraz 1982 bajty.
Do chwili modyfikacji jak i po niej zegarek działa bezproblemowo.
PS Pin nr 4 podstawki procesora jest wydłubany z podstawki, płytka nie ma dziury w tym miejscu wiec zwarcia pomiędzy sygnałem Reset a PB3 nie ma jakby ktoś to zauważył ;)

Statystyki: Napisane przez Elwood — 7 kwi 2019, o 21:45

]]> 2019-01-13T19:12:54+01:00 2019-01-13T19:12:54+01:00 https://forum.atnel.pl/viewtopic.php?t=21870&p=215766#p215766 <![CDATA[Zegarek na bazie DVD PHILIPS DVP3042/12]]> ObrazekObrazekObrazekObrazekObrazekObrazekObrazekObrazek

Przedstawiam zegarek VFD na bazie DVD-Playera DVP3042/12 firmy Philips

Od jakiegoś czasu w tzw dużym pokoju brakowało zonie zegarka. Dawno temu już zrobiłem zegar vfd na PCB z podobnego DVD ale problemem była obudowa a konkretnie brak pomysłu na nią. Jako ze tytułowy odtwarzacz lezy obok telewizora i zajmuje cenne miejsce to stwierdziłem ze pora aby w końcu miał okazje popracować i się przydać po kilku latach przerwy...
W projekcie użyłem kawałka płytki uniwersalnej oraz wykorzystałem ATTINY 26 który miałem oraz gotowy moduł zegara RTC kupiony na znanym serwisie aukcyjnym Dodatkowo w tylnej ściance zamontowałem gniazdko DB9 które służy do podłączenia programatora aby za każdym razem nie otwierać obudowy gdyż program jest dość prymitywny i będzie poprawiony a i może uda się dodać jakieś dodatkowe funkcje.
Program działa następująco - po podaniu zasilania odczytuje w przerwaniu co 1s czas z RTC i wysyła na wyświetlacz. Z każdym obiegiem pętli programowej na jej początku jest sprawdzane za pomocą funkcji "klawisz" czy nie został któryś naciśnięty i kontrolowana jest zmienna o nazwie global która steruje praca całego zegara i jego poszczególnymi funkcjami. Umożliwia tez poprzez proste zwiększenie jej zakresu rozszerzenie menu i dodanie innych funkcji wg potrzeb np przełączenie z trybu 24h na 12 AM/PM.
Menu jest zbudowane na bazie 3 przycisków pochodzących z panelu dekodera Echostar 616 Polsatu . Podczas normalnej pracy wciśniecie 1 (ON/OFF) powoduje wejście do menu i wyświetlenie godziny 12:00:00 na wyświetlaczu. Pozostałe przyciski tj 2 (góra) oraz 3 (dół) pracują jako przyciski +/- do ustawiania wartości godzin w zakresie 0-23. Po ustawieniu godzin wciskamy znowu przycisk 1 i ustawiamy analogicznie minuty w zakresie 0-59. Po trzecim wciśnięciu przycisku sekundy zostają ustawione na 0, analogicznie ustawiamy dni miesiące i rok a po kolejnym użyciu przycisku ON/OFF czas zostaje wpisany do RTC a zegar zaczyna normalna prace.
Podczas normalnej pracy zegara przyciski 2 i 3 maja swoje dodatkowe funkcje -przycisk 2 wyświetla date na 5s, a przycisk 3 miał regulować kontrast VFD ale o tym dalej. Wyświetlanie dwukropka na wyświetlaczu jest realizowane na podstawie tablicy zawierającej obraz segmentów do zapalenia. Pierwsze 10 cyfr jest bez dwukropka, kolejne 10 z dwukropkiem i jest używane w zależności od sekund (operacja modulo 2). W moim przypadku użyłem programowego SPI ze względu na attiny i nie mieszałem z wysyłaniem danych do sterownika VFD wiec w tym przypadku obrazy cyfr w tablicach maja zamienione starszy bajt z młodszym i najstarszy bit z najmłodszym a segmenty inna kolejność. Zajeło mi trochę czasu rozszyfrowanie tego wiec rozpisałem tylko cyfry. Kolejność jest podana na foto . Oczywiście nic nie stoi na przeszkodzie aby rozbudować tablice znaków o wszelkie inne możliwe znaki. W moim przypadku ważny był jedynie(na ta chwile) aktualny czas i to aby zegarek nie dawał w nocy po oczach. Seryjne szkło które emituje białe światło doskonale spełnia swoja role. Po ciemku i tak jest doskonale czytelny nawet z kilku metrów Program napisany na podstawie BB , poradników pana Mirka oraz własnej inwencji .Funkcje do obsługi VFD napisałem na podstawie bibliotek z forum Atnel ale w sumie wykorzystałem tylko podstawowe funkcje typu komenda/dana. Resztę opracowałem samodzielnie.
Jest to jeden z moich pierwszych programów w dodatku kleconych przez jakiś rok jak nie lepiej w dodatku na raty wiec zdaje sobie sprawę ze można(a nawet trzeba) to zoptymalizować bardziej. Na pewno do wyrzucenia są _delay_ms, poprawić można tez na pewno funkcje klawisz i funkcje dwukropka - nie za pomocą 2 zestawów tablic znakowych. Program z wersji testowej zbudowany na zestawie uruchomieniowym powstał na atmega 16. Przepisałem go na attiny z drobnymi zmianami i następnie zabrałem się za lutowanie płytki z UC, i rtc, itd.
Podczas instalacji w docelowym miejscu pojawiły się kolejne 2 problemy. Pierwszy to jak poinformować nasz UC ze chcemy właczyć odtwarzacz - w tym momencie musimy przestać przecież wysyłać nasze dane na wyświetlacz. W pierwszym momencie planowałem uzyć przycisku STANDBY-ON i przerwania mikrokontrolera do wykrycia faktu jego wciśnięcia. Niestety okazało się ze pomimo iż sygnał jest w złączu do którego wpinamy to panuje na nim napięcie 2,5V (naciskając go zwieramy do masy) wiec nie wiem czy attiny zasilany 5V wykryłby to jako stan wysoki czy w ogóle jako zmianę stanu.
Drugi problem powiązany z pierwszym to fakt ze moduł wyświetlacza korzysta (w tym akurat przypadku i w tym konkretnym modelu ) z napiec 3,3V , -24V i +12V do zasilania sterownika VFD które potem najprawdopodobniej jest obniżane za pomocą diody Zenera do 5V. Do płytki VFD na panelu przednim nie dochodzi fizycznie napięcie 5V z zasilacza a płytka nie posiada żadnego wbudowanego stabilizatora. Tak wiec w trybie STANDBY kiedy zegarek ma pracować i pokazywać czas, napięcie 12V i pośrednio 5V jest odcinane przez elektronikę sterująca. 3.3V i -24V są obecne cały czas. Sprawa na szczęście okazała się prostsza niż myślałem - obok złącza znajduje się tranzystor typu 8550 oznaczony jako Q33 który to wystarczy usunąć i zewrzeć C z E - wtedy mamy już napięcie zasilające na sterownik VFD :D. Dodatkowo skoro ten tranzystor jest sterowany w momencie włączenia odtwarzacza to sygnał z jego bazy możemy wykorzystać do naszych celów :) Wprawdzie ma wartość około 9 V ale nie jest to problem- 6 szeregowo podłączonych diod prostowniczych załatwia sprawę i zbija do około 4,8V co już bez problemu można wykryć jako stan wysoki.
Zasilanie 5V pobrałem z wejścia układu scalonego BE572L które idzie tam bezpośrednio ze złącza zasilacza. Może to mało eleganckie ale nie chciałem stosować dodatkowego stabilizatora na swojej płytce, a pcb odtwarzacza pomimo tego ze jest sporo wolnych miejsc gdzie można by się podłączyć praktycznie bezinwazyjnie to nigdzie 5 V nie występuje.
Zmuszony byłem również zastosować układ SN74HC245N - DVD jest zasilanie cały czas nawet w trybie STANDBY a ori sterownik po podpięciu AVR nie jest w stanie wysterować wyświetlacza. Dodatkowo na liniach sterujących utrzymuje stan wysoki z związku z czym musiałem dołożyć osobne przyciski z tyłu. Początkowo planowałem wykorzystać standardowe przyciski OPEN/CLOSE , PLAY/PAUSE oraz STOP. Niestety wymaga to odczytu danych ze sterownika co w w/w układzie połączeń jest niemożliwe. Można oczywiście przeanalizować PCB i odciąć zasilanie głównego układu ale po kilku dniach walki z uruchomieniem wyświetlacza z ori elektronika wolałem wywiercić kilka dziur z tyłu obudowy :]

Teraz garść info odnośnie samych modułów VFD Philipsa.
Moduły z tych DVD maja niestety dziwne rozwiązane sterowanie po SPI - DO jest zwarte z DI i podciągniete do +5V. Tak jest w 2 egzemplarzach które mam i piszą w internecie ze w innych typach DVD jest tak samo. Wymaga to specyficznej obsługi w porównaniu do zwykłego SPI.
Wyjścia do zasilania 4 szt LED są nie wykorzystane i zwarte ze sobą.
Podobnie nie wykorzystane i zwarte są porty od 3 dodatkowych przycisków. Pierwszy z nich (K1) wisi w powietrzu.
Jedyna dostępna dodatkowa funkcja to matryca klawiszy wykorzystuje tylko lub aż 3 przyciski - dokumentacja podaje ze tablica ma rozmiar 3 bajtów ale na szczęście można odczytać tylko pierwszy bajt z danymi które nas interesują i resztę pominać - sterownik nie protestuje :D
W dokumentacji podany jest sposób włączenia tzw test mode. Niestety po jego uruchomieniu nic się nie dzieje - ktoś wie cokolwiek o tej dodatkowej opcji ?
Przy programowym SPI nie jest konieczne oczekiwanie czasu 1us pomiędzy rozkazem odczytu stanu klawiszy a samym odczytem. Dokumentacja zwraca na to szczególna uwagę.
Model DVP 3042/12 jest bardziej "ubogi" niż DVP 520/02 - w pierwszym zasilacz pracuje cały czas nawet jeżeli tylko jest podłączony do zasilania, w tym drugim cały zasilacz startuje dopiero po zwarciu odpowiednich pinów - coś jak zasilacz do PC. Dodatkowo w pierwszym elektronika jest sporo mniejsza w stosunku do obudowy a zasilacz mniejszej mocy.
W moim przypadku (DVP 3042/12) zastosowany sterownik VFD ET16312N data produkcji 48 tydzień 2005 roku nie reaguje na komendę zmiany jasności świecenia pomimo kilkunastu prób - zmiana czasu impulsu strobe, dodanie opóźnień itp. Na sterowniku CS16312N (DVP 520/02) data produkcji 33 tydzień 2006 który to według not katalogowych jest kompatybilny działa bez najmniejszego problemu. Na ET16312 kontrast jest ustawiony na maximum, reszta komend również działa. Może w wolnej chwili wymienię scalak odpowiedzialny za obsługę VFD. Pomimo kilkunastu prób nie udało się uruchomić tych funkcji.

Koszty budowy trudno określić ponieważ oprócz nowego procesora kupionego parę lat temu zakupiłem tylko SN74HC245N za chyba 1,5zł, reszta elementów z demobilu a kawałek płytki został z jakiegoś wcześniejszego projektu. Płytka kosztowała cala około 5-7zł. Procesor taktowany 8MGHz. Na schemacie nie rysowałem kondensatorów filtrujących. Rezystor 45K jest potrzebny aby procesor nie głupiał przy włączaniu DVD do normalnego użytku- bez niego czasem VFD nic nie pokazywał. Data jest pokazywana z litera R na końcu
UWAGA :
Program do działania wymaga bibliotek do programowego i2c których tutaj nie publikowałem. Jeżeli ktoś jest zainteresowany to mogę też dodać funkcje odczytu klawiszy ze sterownika VFD.


[syntax=c]//* main.c

#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <util/delay.h>
#include "i2c_soft/i2c_soft.h"
#include "PT6318/VFD.h"

#define DS3231_ADDR 0xD0 //208
#define KEY1 (1<<PB0)
#define KEY2 (1<<PB2) //zamienione klawisze w stosunku do pierwotnej wersji
#define KEY3 (1<<PB1)

volatile uint8_t KEYA, KEYB, KEYC ; //ZMIENNE WCISMIECIA KLAWISZA
uint8_t key1_lock, key2_lock, key3_lock ;
volatile uint8_t global=0 ;
volatile uint8_t int0_flag ;

typedef union
{
uint8_t bytes[7];
struct
{
uint8_t ss;
uint8_t mm;
uint8_t hh;
uint8_t dof;
uint8_t day;
uint8_t month;
uint8_t year;
} ;
}TDATATIME ;

TDATATIME datatime;


void DS3231_get_datatime( TDATATIME* tmp);
void show_time_VFD(TDATATIME * dt);
void show_date_VFD(TDATATIME * dt);
void DS3231_init(void);
void ustaw12 ( TDATATIME* dt);
void godziny_set( TDATATIME* dt);
void minuty_set( TDATATIME* dt);
void dzien_set( TDATATIME* dt);
void miesiac_set( TDATATIME* dt);
void rok_set( TDATATIME* dt);
void funkcja1 (void) ;
void funkcja2 (void) ;
void funkcja3 (void) ;
void klawisz_wcisniety (uint8_t * klock, volatile uint8_t * KPIN, uint8_t key_mask, void (*kfun)(void));
uint8_t dec2bcd(uint8_t dec) ;
uint8_t bcd2dec (uint8_t bcd) ;

int main (void)
{
DDRA |=(1<<PA3); //ustawienie wyjscia i stanu niskiego do sterowania brama
DDRB &= ~(KEY1 | KEY2 | KEY3); //ustawinie wejscia na klawiszach
PORTB |=(KEY1 | KEY2 | KEY3); //podciagniecie do VCC
i2c_init();//inicjalizacja programowego i2c
DS3231_init();
InitVFD_SPI();
InitVFD();
InitVFD(); // inicjalizacja samego VFD
MCUCR |=(1<<ISC01)|(1<<ISC00);
VFD_CLS(); //czyszczenie VFD
while(1)

{
klawisz_wcisniety (&key1_lock, &PINB, KEY1, funkcja1 ); // dodaje 1 do zmiennej KEYA
klawisz_wcisniety (&key2_lock, &PINB, KEY2, funkcja2 ); //dodaje 1 do zmiennej KEYB
klawisz_wcisniety (&key3_lock, &PINB, KEY3, funkcja3 ); //dodaje 1 do zmiennej KEYC

if( !(PINA & (1<<PA2)) ) //zalaczenie dvd
{
VFD_CLS(); //wyczyszczenie VFD przed wylaczeniem
PORTA |=(1<<PA3); //aktywacja bramy sn74hc245n
}
else
{
PORTA &=~(1<<PA3);
InitVFD();//ponowna komunikacje z wyswietlaczem i zainicjalizowac VFD
}

if (!global) // global rowny 0 normalna praca zegarka odczyt
//i pokazanie daty oraz regulacja kontrastu
{

if (global==0 &&(KEYB))
{
global=100;
show_date_VFD(&datatime) ; // klawisz b pokazuje date

_delay_ms(1000);
_delay_ms(1000);
_delay_ms(1000);
_delay_ms(1000);
_delay_ms(1000);
KEYB=0;
global=0;
}

// if (global==0 &&(KEYC))
// {
//tutaj mozna dodac regulacje kontrastu lub wlacz/wylacz pomiedzy 22 a 6 rano
// }

if (GIFR &(1<<INTF0) ) //normalna praca przerwanie z rtc co 1 s
{
VFD_CLS(); //sprawdzic czy konieczne
DS3231_get_datatime(&datatime);
show_time_VFD(&datatime);
GIFR |= (1<<INTF0) ; // kasowanie flagi
}
}
//tutaj zaczyna sie menu ustawien
if ((KEYA==1) && !(global)) //pierwsze nacisniecie klawisza przy global rowny 0
{
global ++ ;
ustaw12(&datatime);
KEYA = 0 ;
}
if (global==1) // ustawiamy godziny
{
show_time_VFD(&datatime);
godziny_set( &datatime);
}
if (KEYA) // jezeli pierwszy klawisz wcisniety idziemy dalej
{
global++ ;
KEYA = 0 ;
}
if (global==2) // ustawiamy minuty
{
show_time_VFD(&datatime);
minuty_set(&datatime);
}

if (global==3)// ustawiamy dnia
{
show_date_VFD(&datatime);
dzien_set(&datatime);
}

if (global==4) // ustawiamy miesiac
{
show_date_VFD(&datatime);
miesiac_set(&datatime);
}

if (global==5)
// ustawiamy dwie ostanie cyfry roku
{
show_date_VFD(&datatime);
rok_set(&datatime);
}

if (global>5)
{
// zerujemy global i zmienne klawiszy
KEYA = global = 0 ; //dodatkowe zerowanie zajmuje 22 bajty
I2C_write_buf( DS3231_ADDR , 0x00, 7,datatime.bytes);
}
}
}//koniec while


void DS3231_init(void)
{
uint8_t ctrl = 0;
I2C_write_buf( DS3231_ADDR,0x0E, 1, &ctrl );
}

void DS3231_get_datatime( TDATATIME* dt)
{
uint8_t i ;
uint8_t buf[7] ;
I2C_read_buf( DS3231_ADDR, 0x00, 7, buf );
for (i=0; i<7; i++) dt->bytes[i] =(buf[i]);
}

void show_time_VFD(TDATATIME * dt)
{
uint8_t sekundy ;
sekundy =bcd2dec (dt->ss) ;
Segment(1);
SendCharVFD( (dt->hh)>>4);
if (sekundy %2 ==0 )
SendCharVFD( ((dt->hh)& 0x0F)+10 ); //tutaj dwukropek
else
SendCharVFD( (dt->hh)& 0x0F);
//jezeli sekundy sa parzyste to do liczby wysy³anej na wyswietlacz dodajemy 10
//i pobieramy wtdy z tablicy cyfre z wlaczonym dwukropkiem
SendCharVFD( (dt->mm)>>4);
if (sekundy %2 ==0 )
SendCharVFD( ((dt->mm)& 0x0F)+10 ); //tutaj dwukropek
else
SendCharVFD( (dt->mm)& 0x0F);
SendCharVFD( (dt->ss)>>4);
SendCharVFD( (dt->ss)& 0x0F);
}

void show_date_VFD(TDATATIME * dt)
{
Segment(0); //od segmentu 0
SendCharVFD( (dt->day)>>4);
SendCharVFD( (dt->day)& 0x0F); //dzien

SendCharVFD( (dt->month)>>4); //miesiac
SendCharVFD( (dt->month)& 0x0F);

SendCharVFD( (dt->year)>>4); //rok
SendCharVFD( (dt->year)& 0x0F);
SendCharVFD( 20);
}

void ustaw12 ( TDATATIME* dt)
{
dt->bytes[4]= dt->bytes[5] =1 ; //dni i miesiace rowne 01
dt->bytes[6]= (1<<4 |1<<3 |1<<0); //rok rowny 19 w bcd 0001 1001

dt->bytes[0]= dt->bytes[1] =0 ; //minuty i sekundy równe 0
//dt->bytes[2] =(12); //godzina 12
dt->bytes[2] =(1<<4 | 1<<1); //godzina 12 w bcd 0001 0010
show_time_VFD(&datatime);
//chwilowo operujemy tylko na buforze, na koncu zapiszemy ca³osc
}

void godziny_set( TDATATIME* dt)
{
uint8_t godziny ;
godziny =bcd2dec (dt->hh) ;
if (KEYB)godziny ++ ; // zwiekszamy o 1
if (godziny >23) godziny=0 ; //jezeli sa wieksze niz 23 zerujemy
if (KEYC)godziny -- ; // zmniejszamy o 1
if (godziny==255) godziny = 23 ;
(dt->hh)= dec2bcd(godziny) ;
KEYC=KEYB = 0 ;
}

void minuty_set( TDATATIME* dt)
{
uint8_t minuty ;
minuty =bcd2dec (dt->mm) ;
if (KEYB)minuty ++ ; // zwiekszamy o 1
if (minuty >59) minuty=0 ; //jezeli sa wieksze niz 59 zerujemy
if (KEYC)minuty -- ; // zmniejszamy o 1
if (minuty==255) minuty = 59 ;// moze zrobic ze wieksze od 59 ?
(dt->mm)= dec2bcd(minuty ) ;
KEYC=KEYB = 0 ;
}

void dzien_set( TDATATIME* dt)
{
uint8_t dzien ;
dzien =bcd2dec (dt->day) ;
if (KEYB)dzien ++ ; // zwiekszamy o 1
if (dzien >31) dzien=0 ; //jezeli sa wieksze niz 31 zerujemy
if (KEYC)dzien -- ; // zmniejszamy o 1
if (dzien==255) dzien = 31 ;//
(dt->day)= dec2bcd(dzien) ;
KEYC=KEYB = 0 ;
}

void miesiac_set( TDATATIME* dt)
{
uint8_t miesiac ;
miesiac =bcd2dec (dt->month) ;
if (KEYB)miesiac ++ ; // zwiekszamy o 1
if (miesiac >12) miesiac=0 ; //jezeli sa wieksze niz 12 zerujemy
if (KEYC)miesiac -- ; // zmniejszamy o 1
if (miesiac==255) miesiac = 12 ;//
(dt->month)= dec2bcd(miesiac) ;
KEYC=KEYB = 0 ;
}

void rok_set( TDATATIME* dt)
{
uint8_t rok ;
rok =bcd2dec (dt->year) ;
if (KEYB)rok ++ ; // zwiekszamy o 1
if (rok >100) rok=19 ; //
if (KEYC)rok -- ;
if (rok==255) rok = 19 ;//
(dt->year)= dec2bcd(rok) ;
KEYC=KEYB=0 ;
}

uint8_t dec2bcd(uint8_t dec) //dekodowanie BCD
{
return ((dec/10)<<4)|(dec%10);
}

uint8_t bcd2dec (uint8_t bcd) //kodowanie BCD
{
return ((((bcd)>>4) & 0x0F)*10)+ ((bcd)& 0x0F);
}

void funkcja1 (void) //fukcje dodaja 1 w przypadku wcisniecia klawisza
{
KEYA= 1;
}
void funkcja2 (void)
{
KEYB ++;
}
void funkcja3 (void)
{
KEYC++;
}

void klawisz_wcisniety (uint8_t * klock, volatile uint8_t * KPIN, uint8_t key_mask, void (*kfun)(void))
{
register uint8_t key_press = (*KPIN & key_mask);
if (!*klock && ! key_press)
{
*klock = 1;
if (kfun) kfun();
}
else if (*klock && key_press) (*klock)++ ;
}[/syntax]

[syntax=c]#ifndef VFD_H_
#define VFD_H_

#define PORT_SPI PORTA
#define PORT_PIN PINA
#define PORT_DDR DDRA
#define SDIN PA4
#define SCLK PA6
#define SSTB PA5
#define CMD_0 PORT_SPI &= ~(1<<SSTB)
#define CMD_1 PORT_SPI |= (1<<SSTB)
#define SCK_0 PORT_SPI &= ~(1<<SCLK)
#define SCK_1 PORT_SPI |= (1<<SCLK)
#define MOSI_0 PORT_SPI &= ~(1<<SDIN)
#define MOSI_1 PORT_SPI |= (1<<SDIN)

extern uint8_t moc;
extern uint8_t segment;
extern uint8_t HH,MM,SS;
extern uint8_t moc_VFD ;

void InitVFD(void); //Inicjalizacja sterownika
void InitVFD_SPI(void);
void SendVFDSpi( uint8_t bajt ); // Wys³anie bajtu do sterownika
void SendCharVFD( uint8_t znak ); //wys³anie znaku do wyswietlacza
//UWAGA! Funkcja od razu ustawia pierwszy znak
void Kontrast(uint8_t moc_VFD); // ustawia jasnosc swiecenia vfd 0- 7
//UWAGA nie dziala na kazdym sterowniku
void VFD_CLS(void); // czysci wyswietlacz wygaszajac pola
void Segment(uint8_t segment); //ustawia segment od którego ma wyswietlic
void Send_czas (uint8_t HH,uint8_t MM,uint8_t SS) ;

#endif[/syntax]

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


uint8_t moc;
uint8_t segment;
uint8_t HH,MM,SS;
uint8_t moc_VFD;


volatile const uint16_t znaki_tab[] PROGMEM = {

0b0110010001000110, //0 zero normalne
// 0b0110110101010110, //0 zero przekreslone w lewo
0b0000000100100000, //1
0b1010010101000101, //2
// 0b0100010101000101, //3 normalna
0b0100010101001001, //3 skosna
0b1100000100000111, //4
0b1100010101000011, //5
0b1110010101000011, //6
0b0100000001000110, //7
0b1110010101000111, //8
0b1100010101000111, //9
//elementy z zapalonym dwukropkiem
0b0110011001000110, //0 zero normalne
// 0b0110111101010110, //0 zero przekreslone w lewo
0b0000001100100000, //1
0b1010011101000101, //2
// 0b0100011101000101, //3 normalna
0b0100011101001001, //3 skosna
0b1100001100000111, //4
0b1100011101000011, //5
0b1110011101000011, //6
0b0100001001000110, //7
0b1110011101000111, //8
0b1100011101000111, //9
0b0000100101100101 //R 20
// 0b0000000000000000, //21 nic
// 0b0000001000000000, //22 dwukropek
// 0b1000000101000111, //23 symbol stopnia
// 0b0010010001000010, // 24 c
// 0b0000000101100000, // 25 T


};

void InitVFD_SPI(void) { // Ustawienie kierunków portów dla SPI
PORT_DDR |= (1<<SDIN)|(1<<SCLK)|(1<<SSTB);
}


void InitVFD(void) { //Inicjalizacja wywietlacza
CMD_1; //sterownik traktuje jako komendê ka¿dy (tylko!) pierwszy bajt bo
// mrygniêciu lini¹ STB
CMD_0;
// SendVFDSpi(0b00001101); // Command1 - 14znaków, 14 segmentów
SendVFDSpi(0b00000011);
CMD_1;
CMD_0;
// SendVFDSpi(0b01001000); //test mode
SendVFDSpi(0b01000000); // Command2 - Normal mode, Inkrementacja adresu po
//bajcie, obs³uga wyswietlacza
CMD_1;
CMD_0;

// SendVFDSpi(0b10001111); // Command4 - Display ON, PWM 14/16
SendVFDSpi(0b10001011);
CMD_1;//to dodane
CMD_0;
}

void SendVFDSpi( uint8_t bajt ) { //wysyla bajt do sterownika
uint8_t licznik=0x01;
SCK_0; //tykniêcie zegarem SPI
while( licznik ) { //odliczanie 8 bitów w pêtli
if( bajt & licznik ) MOSI_1; //iloczyn bitowy celem sprawdzenia wartoci bitu
else MOSI_0;
SCK_1;
SCK_0;
licznik<<=1; //przesuniêcie licznika w lewo
//(celem maskowania odpowiedniego bitu)
}
}

void SendCharVFD( uint8_t znak ) //wysy³a pojedynczy znak do wyswietlacza
{
SendVFDSpi(pgm_read_word(&znaki_tab[znak])>>8);
//pobranie starszej czesci
SendVFDSpi(pgm_read_byte(&znaki_tab[znak]));
//pobranie z tablicy z definicjami znakow mlodszej czesci

}
void Segment(uint8_t segment)
{
CMD_1;
CMD_0;
SendVFDSpi((0b11000000) | (segment*2)); // 2 bajty na zegment
}

void Kontrast(uint8_t moc_VFD)
{
moc = moc_VFD;
CMD_1;
CMD_0;
SendVFDSpi( (0b10001000)|(moc) ) ;
}
void VFD_CLS(void)
{
CMD_1; //sterownik traktuje jako komendê ka¿dy (tylko!) pierwszy bajt bo nrygniêciu lini¹ STB
CMD_0;
SendVFDSpi(0b11000000); // wyslij dane od zerowego segmentu
for (uint8_t i=0;i<14;i++) SendVFDSpi(0); //14 razy 0
}

void Send_czas (uint8_t HH,uint8_t MM,uint8_t SS)
{
//liczby dajemy odrazu w bcd
Segment(1); //zajmuje 8bajtów

SendCharVFD( HH>>4);
SendCharVFD( HH & 0x0F);

SendCharVFD( MM>>4);
SendCharVFD(MM & 0x0F );

SendCharVFD( SS>>4);
SendCharVFD( SS & 0x0F);
}[/syntax]

Statystyki: Napisane przez Elwood — 13 sty 2019, o 19:12

]]>