API tools faq
paste
Advertisement
PowerTGS440

KEY&LED

PowerTGS440
Mar 13th, 2021 (edited)
149
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 32.56 KB | None | 0 0
raw download clone embed print report
  1. //-------------------------------------------------------------------------------------------//
  2. // ledkey.h v0.0.6 beta by Tomasz Majcher                                                    //
  3. //                                                                                           //
  4. // TRANSLINE LUBIN                                                                           //
  5. // transline.majcher@gmail.com                                                               //
  6. // licencja: FREE                                                                            //
  7. //                                                                                           //
  8. // Ciężki Transport Drogowy ( silosy / wywrotki / gabaryty )                                 //
  9. // Automatyka Przemysłowa   ( STM32 / ESP32 / FPGA  )                                        //
  10. // Kryszywa Naturalne       ( piasek / żwiry / Bazalt / Granit )                             //
  11. //                                                                                           //
  12. // POZOSTAŁE USŁUGI TRANSLINE                                                                //
  13. //                                                                                           //
  14. // Logistyka Transportowa   Wiktoria.Majcher@gmail.com                                       //
  15. // Spedycja Krajowa         Wiktoria.Majcher@gmail.com                                       //
  16. // Windykacja Należności    Sylwia.Majcher@gmail.com                                         //
  17. // Usługi Serwisowe         Marcin.Majcher@gmail.com                                         //
  18. //                                                                                           //
  19. // data utworzenia : 01.12.2019                                                              //
  20. // library  : ledkey 8x pushbutto, 8x led, 2x lcd 4 digit                                    //
  21. //                                                                                           //
  22. //                                                                                           //
  23. // v0.0.7 beta (26.12.2019) : optymalizacja klasy                                            //
  24. // v0.0.6 beta (15.12.2019) : led_step_0_7 - dioda krocząca (wszystkie moduły)               //
  25. // v0.0.5 beta (13.12.2019) : dodanie znaku stopnia (10) i literca "C" (11)                  //
  26. // v0.0.4 beta (03.12.2019) : optymalizacja LCD                                              //
  27. // v0.0.3 beta (02.12.2019) : dodano obsługa LCD (2x)                                        //
  28. // v0.0.2 beta (01.12.2019) : dodana obsługa przyciskow (8x)                                 //
  29. // v0.0.1 beta (01.12.2019) : dodana obsługa ledów (8x)                                      //
  30. //                                                                                           //
  31. ///////////////////////////////////////////////////////////////////////////////////////////////
  32.  
  33. #ifndef wiring_shift_mod_h
  34. #define wiring_shift_mod_h
  35. #endif
  36.  
  37. #define CLOCK_NORMAL 0
  38. #define CLOCK_INVERT 1
  39. #define CLOCK_TYPE  CLOCK_INVERT
  40. #define CLOCK_DELAY_US 1
  41.  
  42. //--- klasa LEDKEY ------------------------------------------
  43. //
  44. // konstruktory:
  45. //                LEDKEY();   strobe = 2, clock = 1, data = 0
  46. //                LEDKEY(strobe, clock, data)
  47. //
  48. //
  49. // metody LED:
  50. //                LedTurnON1(index)
  51. //                LedTurnON2(index)
  52. //                LedTurnOFF1(index)
  53. //                LedTurnOFF2(index)
  54. //                LedChange1(index)
  55. //                LedChange2(index)
  56. //                LedStep0()
  57. //                LedStep1()
  58. //                LedStep2()
  59. //
  60. // metody BUTTON:
  61. //                Button()                                 -->  zwraca (uint8_t) nr. wcisnietego przycisku 1,2,3,4,5,6,7,8 (dla kodów 1,2,4,8,16,32,64,128)
  62. //
  63. // metody LCD:
  64. //                ShowLCD1(uint8_t tablica[4], bool tryb); --> na wejsciu tablica 4 liczb do wyswietlenia, tryb 0,1 (kropka miedzy 2 a 3 segmentem)      
  65. //                ShowLCD2(uint8_t tablica[4], bool tryb); --> na wejsciu tablica 4 liczb do wyswietlenia, tryb 0,1 (kropka miedzy 2 a 3 segmentem)      
  66. //
  67.  
  68. class LEDKEY
  69. {
  70.     private:
  71.       int stb_pin;    // strobe pin
  72.       int clk_pin;    // clock pin
  73.       int din_pin;    // digital pin            
  74.    
  75.       const uint8_t LedAdres1[4] = { 0xC1, 0xC3, 0xC5, 0xC7 };  // adresy LED moduł: LEDKEY1
  76.       const uint8_t LedAdres2[4] = { 0xC9, 0xCB, 0xCD, 0xCF };  // adresy LED moduł: LEDKEY2
  77.       const uint8_t LCDAdres1[4] = { 0xC0, 0xC2, 0xC4, 0xC6 };  // adresy LCD moduł: LEDKEY1      
  78.       const uint8_t LCDAdres2[4] = { 0xC8, 0xCA, 0xCC, 0xCE };  // adresy LCD moduł: LEDKEY2
  79.  
  80.       // --- struktura LED (2 obiekty, 2x 4 diody)
  81.       struct LED                                                
  82.       {
  83.           uint8_t LedAdres[4];                                   // adresy LED
  84.           uint8_t LedStatus[4];                                  // stany LED (0 - OFF, 1 - ON);
  85.           inline void setAdres(const uint8_t temp[]) { for(uint8_t index = 0; index < 4; index++) LedAdres[index] = temp[index]; }
  86.           inline void setStatus(uint8_t index, uint8_t stan) { LedStatus[index] = stan; }
  87.           inline bool getStatus(uint8_t index) { return LedStatus[index]; }      
  88.       }
  89.       led1, led2;
  90.  
  91.       // --- struktura LCD (2 obiekty, 2x 4 digit)
  92.       struct LCD
  93.       {
  94.                                   /*0*/ /*1*/ /*2*/ /*3*/ /*4*/ /*5*/ /*6*/ /*7*/ /*8*/ /*9*/  /*^*/ /*C*/
  95.           uint8_t nCyfra[12]   = { 0x3f, 0x06, 0x5b, 0x4f, 0x66, 0x6d, 0x7d, 0x07, 0x7f, 0x6f, 0x63, 0x39 };      // cyfry bez kropki
  96.           uint8_t dCyfra[12]   = { 0xBF, 0x86, 0xdb, 0xcf, 0xe6, 0xed, 0xfd, 0x87, 0xff, 0xef, 0x63, 0x39 };      // cyfry z kropką
  97.           uint8_t LCDAdres[4];                                   // adresy wyswietlacza
  98.           inline void setAdres(const uint8_t temp[]) { for(uint8_t index = 0; index <4; index++) LCDAdres[index] = temp[index]; }          
  99.           inline uint8_t getAdres(uint8_t index) { return LCDAdres[index]; }
  100.           uint8_t *makeLCDset(uint8_t temp[],bool rodzaj);       // zwroc tablicę złożoną z licb dla LCD (1,2,3,4)
  101.           uint8_t *makeLCDadr();                                 // zwroc tablicę złożoną z adresów dla LCD
  102.       } *lcd1, *lcd2;
  103.            
  104.     public:
  105.          
  106.       LEDKEY();                                                // konstruktor domyślny
  107.       LEDKEY(int , int , int );
  108.       ~LEDKEY()
  109.       {
  110.         delete lcd1,lcd2;
  111.       };
  112.       void setPIN();                                           // utwórz piny              
  113.       uint8_t readButtons(void);                               // obsługa : przyciski
  114.      
  115.       // --- deklaracje dla LED -------------------------------------------------------------------------------------------------------------
  116.       // ------------------------------------------------------------------------------------------------------------------------------------
  117.       void LedTurnON(uint8_t index, LED *wsk);                 // wlacz diode (wskaznik na strukture led1 lub led2)
  118.       inline void LedTurnON1(uint8_t index) { LedTurnON(index, &led1); }
  119.       inline void LedTurnON2(uint8_t index) { LedTurnON(index, &led2); }
  120.  
  121.       void LedTurnOFF(uint8_t index, LED *wsk);                // wylacz diode (wskaznik na strukture led1 lub led2)
  122.       inline void LedTurnOFF1(uint8_t index) { LedTurnOFF(index, &led1); }
  123.       inline void LedTurnOFF2(uint8_t index) { LedTurnOFF(index, &led2); }
  124.  
  125.       void LedStep(LED *wsk);                                  // dioda kroczaca      
  126.       inline void LedStep1() { LedStep(&led1); }
  127.       inline void LedStep2() { LedStep(&led2); }
  128.       void LedStep0();                                         // dioda ktocząca (0,1,2,3,4,5,6,7) ze statyczną zmienną aktualnej
  129.  
  130.       void LedChange(uint8_t index, LED *wsk);                 // zmien status diody
  131.       inline void LedChange1(uint8_t index) { LedChange(index,&led1); }
  132.       inline void LedChange2(uint8_t index) { LedChange(index,&led2); }
  133.      
  134.       // ------------------------------------------------------------------------------------------------------------------------------------
  135.       // --- deklaracje do obsługi LCD ------------------------------------------------------------------------------------------------------
  136.       void sendCommand(uint8_t wartosc);                       // obsluga : send command
  137.       void reset();                                            // obsługa : reset
  138.       uint8_t shiftInMod(uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder, uint8_t clock_type, uint16_t clock_delay_us);
  139.       void shiftOutMod(uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder, uint8_t clock_type, uint16_t clock_delay_us, uint8_t val);
  140.      
  141.       // ------------------------------------------------------------------------------------------------------------------------------------
  142.       // --- deklaracje dla LCD -------------------------------------------------------------------------------------------------------------
  143.       void ShowLCDset(uint8_t temp[], LCD *wsk, bool mode);    // wyswietl liczby na LCD
  144.       inline void ShowLCDset_wdot(uint8_t tab[], LCD *wsk) { ShowLCDset(tab,wsk,1); }           // pokaz liczby z kropka
  145.       inline void ShowLCDset_ndot(uint8_t tab[], LCD *wsk) { ShowLCDset(tab,wsk,0); }           // pokaz liczby bez kropki
  146.       void ShowLCDdig(uint8_t adres, uint8_t liczba);          // wyswietl liczbe na LCD
  147.       void ShowLCD1(uint8_t temp[], bool mode);
  148.       void ShowLCD2(uint8_t temp[], bool mode);
  149.       void ShowTEMP(uint8_t temp, uint8_t wyswietlacz);                   // pokaz temperature na LCD1
  150.       // -----------------------------------------------------------------------------------------------------------------------------------
  151.       // --- deklaracje dla PRZYCISK -------------------------------------------------------------------------------------------------------
  152.       word Button();                                           // zwraca numer przycisku
  153. };                                                             // koniec klasy LEDKEY
  154.  
  155. // -----------------------------------------------------------------------------------------------------------------------------------------
  156. // --- definicje klasy LEDKEY --------------------------------------------------------------------------------------------------------------
  157. // -----------------------------------------------------------------------------------------------------------------------------------------
  158. // --- definicje obsługi LCD ---------------------------------------------------------------------------------------------------------------
  159. // -----------------------------------------------------------------------------------------------------------------------------------------
  160. uint8_t *LEDKEY::LCD::makeLCDset(uint8_t temp[],bool rodzaj)
  161. {
  162.     static uint8_t tab[4];                                                             // tablica statyczna na rejestr procesora
  163.     for(uint8_t index = 0; index < 4; index++) tab[index] = nCyfra[temp[index]];       // zapisz to zwracanej tablicy kody liczb
  164.     if(rodzaj) tab[1] = dCyfra[temp[1]];                                                     // jesli 0 - liczba bez kropki, 1 - liczba z kropka
  165.     return( tab );                                                                     // zwroc tablice z funkcji
  166. }
  167.  
  168. uint8_t *LEDKEY::LCD::makeLCDadr()
  169. {
  170.     static uint8_t tab[4];
  171.     for(uint8_t index = 0; index <4; index++) tab[index] = LCDAdres[index];
  172.     return( tab );
  173. }
  174.  
  175. void LEDKEY::ShowLCDset(uint8_t temp[], LCD *wsk, bool mode)
  176. {
  177.     uint8_t *T_adres;           // wskaznik (stworz) do adresow
  178.     uint8_t *T_digit;           // wskaznik (stworz) do liczb
  179.  
  180.     T_adres = wsk -> makeLCDadr();
  181.    
  182.     if(!mode ) T_digit = wsk -> makeLCDset(temp,0);       // zapisz pod wskaznik liczby bez kropki
  183.     else
  184.     if( mode ) T_digit = wsk -> makeLCDset(temp,1);       // zapisz pod wskaznik liczby z   kropką  
  185.                
  186.     for(byte index = 0; index < 4; index++) ShowLCDdig(T_adres[index], T_digit[index]);    // pokaz liczby na LCD  
  187.     //delete T_adres;
  188.     //delete T_digit;
  189. }
  190.  
  191. void LEDKEY::ShowLCD1(uint8_t temp[], bool mode)
  192. {
  193.   static bool check_mode = 0;
  194.   if(!mode) ShowLCDset_ndot(temp, lcd1);           // pokaz na wyswietlaczu nr.1 tablice[] liczb bez kropki
  195.   else
  196.   if (mode)                                        // jesli mrugajaca kropka wykonaj ponizsze warunki
  197.   {      
  198.       if( !check_mode )                            // kropka nie aktywna (wlacz)
  199.       {
  200.           ShowLCDset_ndot(temp, lcd1);
  201.           check_mode = 1;
  202.       }
  203.       else                                         // kropka aktywna (wylacz)
  204.       {
  205.           ShowLCDset_wdot(temp, lcd1);
  206.           check_mode = 0;
  207.       }
  208.   }  
  209. }
  210.  
  211. void LEDKEY::ShowLCD2(uint8_t temp[], bool mode)
  212. {
  213.   static bool check_mode = 0;
  214.  
  215.   if(!mode) ShowLCDset_ndot(temp, lcd2);           // pokaz na wyswietlaczu nr.1 tablice[] liczb bez kropki
  216.   else
  217.   if( mode)
  218.   {      
  219.       if( !check_mode )
  220.       {
  221.           ShowLCDset_ndot(temp, lcd2);
  222.           check_mode = 1;
  223.       }
  224.       else              
  225.       {
  226.           ShowLCDset_wdot(temp, lcd2);
  227.           check_mode = 0;
  228.       }
  229.   }
  230. }
  231.  
  232. // --- LEDKEY :: ShowTEMP --- na wejściu temperatura, i nr. wyswietlacza (1,2) ------------------------------------- //
  233. void LEDKEY::ShowTEMP(uint8_t temperatura, uint8_t wyswietlacz)                  // ShowTEMP ----------------------- //
  234. {                                                                                // ................................ //
  235.   uint8_t tab[4];                                                                // tablica do zmontowania wyjscie . //
  236.   tab[0] = temperatura / 10;                                                     // tab[0] - dziesiatki temperatury  //
  237.   tab[1] = temperatura % 10;                                                     // tab[1] - jednosci temperatury    //
  238.   tab[2] = 10;                                                                   // tab[2] = 10    znak stopnia      //
  239.   tab[3] = 11;                                                                   // tab[3] = 11    znak C            //
  240.   if(wyswietlacz == 1) ShowLCD1(tab,0);                                          // jesli w = 1 to LCD 1             //
  241.   else                                                                           // w innym przypadku                //
  242.   if(wyswietlacz == 2) ShowLCD2(tab,0);                                          // jesli w = 2 to LCD 2             //
  243. }                                                                                // ................................ //
  244. // ----------------------------------------------------------------------------------------------------------------- //
  245. void LEDKEY::ShowLCDdig(uint8_t adres, uint8_t liczba)
  246. {
  247.     sendCommand(0x40);      
  248.     digitalWrite(stb_pin, LOW);
  249.     shiftOutMod(din_pin, clk_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, adres);          // adres segmentu
  250.     shiftOutMod(din_pin, clk_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, liczba);         // liczba HEX
  251.     digitalWrite(stb_pin, HIGH);
  252. }
  253. // -----------------------------------------------------------------------------------------------------------------------------------------
  254. // --- definicje klasy LEDKEY --------------------------------------------------------------------------------------------------------------
  255. // -----------------------------------------------------------------------------------------------------------------------------------------
  256. // --- definicje obsługi LED ---------------------------------------------------------------------------------------------------------------
  257. // -----------------------------------------------------------------------------------------------------------------------------------------
  258.  
  259. void LEDKEY::LedTurnON(uint8_t index, LED *wsk)
  260. {
  261.     sendCommand(0x44);
  262.     digitalWrite(stb_pin, LOW);
  263.     shiftOutMod(din_pin, clk_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, wsk->LedAdres[index]);
  264.     shiftOutMod(din_pin, clk_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, 1);
  265.     digitalWrite(stb_pin, HIGH);
  266.     wsk->setStatus(index,1);
  267. }
  268.  
  269. void LEDKEY::LedTurnOFF(uint8_t index, LED *wsk)
  270. {
  271.     sendCommand(0x44);
  272.     digitalWrite(stb_pin, LOW);
  273.     shiftOutMod(din_pin, clk_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, wsk->LedAdres[index]);
  274.     shiftOutMod(din_pin, clk_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, 0);
  275.     digitalWrite(stb_pin, HIGH);
  276.     wsk->setStatus(index,0);
  277. }
  278.  
  279. void LEDKEY::LedChange(uint8_t index, LED *wsk)
  280. {
  281.     if( wsk->getStatus(index) ) LedTurnOFF(index,wsk);
  282.     else LedTurnON(index,wsk);
  283. }
  284.  
  285. // ---------------------------------------------------------------------------------------------- //
  286. // --- LedKey0 --- dioda kroczącza : 0,1,2,3,4,5,6,7 -------------------------------------------- //
  287. // ---------------------------------------------------------------------------------------------- //
  288. void LEDKEY::LedStep0()                                                                           //
  289. {                                               // start ---------------------------------------- //
  290.   static byte index = 0;                        // zmienna statyczna index (pozycja diody) ------ //
  291.   if(index == 0)                                // jeśli index = 0, zgaś led 7, włącz led 0 ----- //
  292.   {                                             // ---------------------------------------------- //
  293.     LedTurnON(index,&led1);                     // włącz diodę: 0 na module &led1 --------------- //
  294.     LedTurnOFF(3,&led2);                        // wyłącz diodę 3 (7) na module &led2 ----------- //
  295.     index ++;                                   // zwiększ o jeden index ------------------------ //
  296.   }                                             // koniec --------------------------------------- //
  297.   else if(index > 0 && index < 4)               // jeśli index większy od 0 a mniejszy od 4 ----- //
  298.   {                                             // start ---------------------------------------- //
  299.     LedTurnOFF(index - 1, &led1);               // wyłącz diodę poprzedającą na module &led1 ---- //
  300.     LedTurnON(index, &led1);                    // włącz diodę wskazywaną przez index na &led1 -- //
  301.     index++;                                    // zwiększ o jeden index ------------------------ //
  302.   }                                             // koniec --------------------------------------- //
  303.   else if(index == 4)                           // jeśli index ma wartość równą 4 --------------- //
  304.   {                                             // start ---------------------------------------- //
  305.     LedTurnON(index - 4, &led2);                // włącz diodę 0 (5) na module &led2 ------------ //
  306.     LedTurnOFF(3,&led1);                        // wyłącz diodę 3 (4) na module &led1 ----------- //
  307.     index ++;                                   // zwiększ o jeden wartość zmiennej index ------- //
  308.   }                                             // koniec --------------------------------------- //
  309.   else if(index > 4 && index < 8)               // jeśli index większy od 4 a mniejszy od 8 ----- //
  310.   {                                             // start ---------------------------------------- //
  311.     LedTurnOFF(index - 5, &led2);               // wyłącz diodę poprzedającą w module &led2 ----- //
  312.     LedTurnON(index  - 4, &led2);               // włącz diodę wskazywaną przez index na &led2 -- //
  313.     index ++;                                   // zwiększ o jeden wartość zmiennej index ------- //
  314.   }                                             // koniec --------------------------------------- //
  315.   else if (index == 8)                          // jeśli wartość index równa jest 8 ------------- //
  316.   {                                             // start ---------------------------------------- //
  317.       LedTurnOFF(3, &led2);                     // wylacz diode 3 (7) na module &led2 ----------- //
  318.       index = 0;                                // wyzerun zmienną index, ustaw 0 --------------- //
  319.       LedTurnON(index, &led1);                  // włącz diodę 0 (0) na module &led1 ------------ //
  320.       index++;                                  // zwiększ wartość zmiennej index o jeden ------- //
  321.   }                                             // koniec --------------------------------------- //
  322. }                                               // KONIEC -> void LEDKEY::LedStep0()------------- //
  323. // ---------------------------------------------------------------------------------------------- //
  324. // --- LedStep(Led który_moduł) ----------------------------------------------------------------- //
  325. // ---------------------------------------------------------------------------------------------- //
  326. void LEDKEY::LedStep(LED *wsk)                                                                    //
  327. {                                                                                                 //
  328.     static byte index = 0;                      // zmienna statyczna -> pozycja diody ----------- //
  329.     if (index == 0)                             // jesli wartość index = 0 ---------------------- //
  330.     {                                           // start ---------------------------------------- //
  331.       LedTurnON(index,wsk);                     // zapal diode 0 (nr. 1) na module & ------------ //
  332.       LedTurnOFF(3,wsk);                        // zgaś diodę  3 (nr. 4) na module & ------------ //
  333.       index++;                                  // zwiększ wartość zmiennej index o 1 ----------- //
  334.     }                                           // koniec --------------------------------------- //
  335.     else if (index > 0 && index < 4)            // jeśli zmienna index wieksza od 0 mniejsza od 4 //
  336.     {                                           // start ---------------------------------------- //
  337.       LedTurnOFF(index - 1, wsk);               // wyłącz diodę poprzedająca na module & -------- //
  338.       LedTurnON (index, wsk);                   // włącz diodę wskazywaną przez wartość index & - //
  339.       index++;                                  // zwiększ wartość zmiennej index o 1 ----------- //
  340.     }                                           // koniec --------------------------------------- //
  341.     else if (index == 4   )                     // jesli wartość zmiennej index to 4 ------------ //
  342.     {                                           // start ---------------------------------------- //
  343.       LedTurnOFF(3, wsk);                       // wylacz diodę 3 (nr.4 - ostatnią) na module & - //
  344.       index = 0;                                // ustaw nową wartość zmiennej index, 0 --------- //
  345.       LedTurnON(index, wsk);                    // zapal diode (pierwszą) na module & ----------- //
  346.       index++;                                  // zwiększ wartość zmiennej index o 1 ----------- //
  347.     }                                           // koniec --------------------------------------- //
  348. }                                               // KONIEC - void LEDKEY::LedStep(LED *wsk) ------ //
  349. // ---------------------------------------------------------------------------------------------- //
  350. // ---------------------------------------------------------------------------------------------- //
  351. // --- definicje klasy LEDKEY ------------------------------------------------------------------- //
  352. // ---------------------------------------------------------------------------------------------- //
  353. // --- konstruktor domyślny --------------------------------------------------------------------- //
  354. // ---------------------------------------------------------------------------------------------- //
  355. LEDKEY::LEDKEY()                                // to jest konstruktor domyślny klasy LEDKEY ---- //
  356. {                                               // start ---------------------------------------- //
  357.     stb_pin = 2;                                // ustaw strobe_pin (PIN DIGITAL 2) ------------- //
  358.     clk_pin = 1;                                // ustaw clk_pin    (PIN DIGITAL 1) ------------- //
  359.     din_pin = 0;                                // ustaw din_pin    (PIN DIGITAL 0) ------------- //
  360.     led1.setAdres(LedAdres1);                   // ustaw adresy fizyczne dla modułu led1 -------- //
  361.     led2.setAdres(LedAdres2);                   // ustaw adresy fizyczne dla modułu led2 -------- //
  362.     lcd1 = new LCD;                             // stwórz nowy obiekt lcd1 (wyświetlacz LCD 1) -- //
  363.     lcd2 = new LCD;                             // stwórz nowy obiekt lcd2 (wyświetlacz LCD 2) -- //
  364.     lcd1 -> setAdres(LCDAdres1);                // ustaw adresy fizyczne dla modułu lcd1 -------- //
  365.     lcd2 -> setAdres(LCDAdres2);                // ustaw adresy fizyczne dla modułu lcd2 -------- //
  366.     setPIN();                                   // wykonaj pinMode dla stb_pin, clk_pin, din_pin  //
  367. }                                               // koniec --------------------------------------- //
  368. // ---------------------------------------------------------------------------------------------- //
  369. // --- konstruktor z parametrem------------------------------------------------------------------ //
  370. // ---------------------------------------------------------------------------------------------- //
  371. LEDKEY::LEDKEY(int stbp, int clkp, int dinp)                                                   //
  372. {                                               // to jest konstuktor z parametrami wejścia ----- //
  373.     stb_pin = stbp;                             // ustaw stb_pin (PIN DIGITAL) = stbp ----------- //
  374.     clk_pin = clkp;                             // ustaw clk_pin (PIN DIGITAL) = clkp ----------- //
  375.     din_pin = dinp;                             // ustaw din_pin (PIN DIGITAL) = dinp ----------- //
  376.     led1.setAdres(LedAdres1);                   // ustaw adresy fuzyczne dla modułu led1 -------- //
  377.     led2.setAdres(LedAdres2);                   // ustaw adresy fizyczne dla modułu led2 -------- //
  378.     lcd1 = new LCD;                             // stwórz nowy obiekt lcd1 (wyświetlacz LCD 1) -- //
  379.     lcd2 = new LCD;                             // stwórz nowy obiekt lcd2 (wyświetlacz LCD 2) -- //
  380.     lcd1 -> setAdres(LCDAdres1);                // ustaw adresy fizyczne dla modułu lcd1 -------- //
  381.     lcd2 -> setAdres(LCDAdres2);                // ustaw adresy fizyczne dla modułu lcd2 -------- //
  382.     setPIN();                                   // wykonaj pinMode dla stb_pin, clk_pon, din_pin  //
  383. }                                               // koniec --------------------------------------- //
  384. // ---------------------------------------------------------------------------------------------- //
  385. // --- definicje klasy LEDKEY ------------------------------------------------------------------- //
  386. // ---------------------------------------------------------------------------------------------- //
  387. // --- setup klasy LEDKEY ----------------------------------------------------------------------- //
  388. // ---------------------------------------------------------------------------------------------- //
  389. void LEDKEY::setPIN()                                                                             //
  390. {                                               // ustawianie pinów ----------------------------- //
  391.     pinMode(stb_pin, OUTPUT);                   // stb_pin DIGITAL OUT -------------------------- //
  392.     pinMode(clk_pin, OUTPUT);                   // clk_pin DIGITAL OUT -------------------------- //
  393.     pinMode(din_pin, OUTPUT);                   // din_pin DIGITAL OUT -------------------------- //
  394.     sendCommand(0x8f);                          // aktywuj LED & KEY ---------------------------- //
  395.     reset();                                    // resetuj LED & KEY ---------------------------- //
  396. }                                               // KONIEC LEDKEY::setPIN ------------------------ //
  397. // ---------------------------------------------------------------------------------------------- //
  398. // --- definicje klasy LEDKEY ------------------------------------------------------------------- //
  399. // ---------------------------------------------------------------------------------------------- //
  400. // --- obsługa diód i wyświetlacza fizyczna------------------------------------------------------ //
  401. // ---------------------------------------------------------------------------------------------- //
  402. void LEDKEY::sendCommand(uint8_t wartosc)
  403. {
  404.   digitalWrite(stb_pin, LOW);
  405.   shiftOutMod(din_pin, clk_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, wartosc);
  406.   digitalWrite(stb_pin, HIGH);
  407. }
  408.  
  409. void LEDKEY::reset()
  410. {  
  411.   sendCommand(0x40);
  412.   digitalWrite(stb_pin, LOW);
  413.   shiftOutMod(din_pin, clk_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, 0xc0);                                    // reset od adresu 0      
  414.   for (uint8_t i = 0; i < 16; i++) shiftOutMod(din_pin, clk_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, 0x00);   // 8x LED + 8x DIGIT reset  
  415.   digitalWrite(stb_pin, HIGH);
  416. }
  417.  
  418. uint8_t LEDKEY::shiftInMod(uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder, uint8_t clock_type, uint16_t clock_delay_us)
  419. {
  420.   uint8_t value = 0;
  421.  
  422.   for (uint8_t i = 0; i < 8; ++i)
  423.   {
  424.     digitalWrite(clockPin, (clock_type ? LOW : HIGH));
  425.     delayMicroseconds(clock_delay_us);
  426.     if (bitOrder == LSBFIRST) value |= digitalRead(dataPin) << i;
  427.     else value |= digitalRead(dataPin) << (7 - i);
  428.          
  429.     digitalWrite(clockPin, (clock_type ? HIGH : LOW));
  430.    }
  431.    return value;
  432. }
  433.  
  434. void LEDKEY::shiftOutMod(uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder, uint8_t clock_type, uint16_t clock_delay_us, uint8_t val)
  435. {
  436.   for (uint8_t i = 0; i < 8; i++)  
  437.   {
  438.     if (bitOrder == LSBFIRST) digitalWrite(dataPin, !!(val & (1 << i)));
  439.     else  digitalWrite(dataPin, !!(val & (1 << (7 - i))));
  440.      
  441.     digitalWrite(clockPin, (clock_type ? LOW : HIGH));
  442.     delayMicroseconds(clock_delay_us);
  443.     digitalWrite(clockPin, (clock_type ? HIGH : LOW));    
  444.    }
  445. }
  446.  
  447. // -----------------------------------------------------------------------------------------------------------------------------------------
  448. // --- definicje klasy LEDKEY --------------------------------------------------------------------------------------------------------------
  449. // -----------------------------------------------------------------------------------------------------------------------------------------
  450. // --- definicja obsługi przycisków---------------------------------------------------------------------------------------------------------
  451. // -----------------------------------------------------------------------------------------------------------------------------------------
  452.  
  453. word LEDKEY::Button()
  454. {
  455.   word button = readButtons();         // pobierz do zmienniej button kod przycisku z modulu LED&KEY
  456.  
  457.   switch (button)
  458.   {
  459.       case   1: return 1;   // zwroc kod 1
  460.                 break;      // przerwij dalej
  461.  
  462.       case   2: return 2;   // zwroc kod 2
  463.                 break;      // przerwij dalej
  464.  
  465.       case   4: return 3;   // zwroc kod 3
  466.                 break;      // przerwij dalej
  467.  
  468.       case   8: return 4;   // zwroc kod 4
  469.                 break;      // przerwij dalej
  470.  
  471.       case  16: return 5;   // zwroc kod 5
  472.                 break;      // przerwij dalej
  473.  
  474.       case  32: return 6;   // zwroc kod 6
  475.                 break;      // przerwij dalej
  476.  
  477.       case  64: return 7;   // zwroc kod 7
  478.                 break;      // przerwij dalej
  479.  
  480.       case 128: return 8;   // zwroc kod 8
  481.                 break;      // przerwij dalej
  482.  
  483.       default:  return 0;   // zwroc kod 0
  484.                 break;      // przerwij dalej
  485.   }
  486. }
  487.  
  488. uint8_t LEDKEY::readButtons(void)
  489. {
  490.   uint8_t buttons = 0;
  491.   digitalWrite(stb_pin, LOW);
  492.   shiftOutMod(din_pin, clk_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, 0x42);
  493.   pinMode(din_pin, INPUT);
  494.   for (uint8_t i = 0; i < 4; i++)
  495.   {
  496.     uint8_t v = shiftInMod(din_pin, clk_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US) << i;
  497.     buttons |= v;
  498.   }
  499.   pinMode(din_pin, OUTPUT);
  500.   digitalWrite(stb_pin, HIGH);
  501.   return buttons;
  502. }
  503.  
  504. // -----------------------------------------------------------------------------------------------------------------------------------------
  505. // --- KONIEC KLASY KEYLED -----------------------------------------------------------------------------------------------------------------
  506. // -----------------------------------------------------------------------------------------------------------------------------------------
  507.  
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!