API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jan 19th, 2018
100
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 11.26 KB | None | 0 0
raw download clone embed print report
  1.  
  2. #define F_CPU 8000000UL
  3. #include <avr/pgmspace.h>
  4. #include <stdint.h>
  5.  
  6. #include <avr/interrupt.h>
  7. #include <avr/io.h>
  8. #include <util/delay.h>
  9.  
  10. #define SW1 (1<<PD7)
  11. #define SW2 (1<<PD6)
  12. #define SW3 (1<<PD5)
  13.  
  14.  
  15. #define C_DS1307Readtryb_U8   0xD1u
  16. #define C_DS1307Writetryb_U8  0xD0u
  17.  
  18. #define WS_OUT          PORTB
  19. #define WS_IN           PINB
  20. #define WS_DDR          DDRB
  21. #define WS_BIT_CLK      _BV(PB0)
  22. #define WS_BIT_DAT      _BV(PB1)
  23.  
  24. #define WS_PRAWY        0x01
  25. #define WS_LEWY         0x00
  26.  
  27. #define wyswietlacz_cyfry   4
  28. #define WS_CLK_LOW()            (WS_OUT &= ~WS_BIT_CLK)
  29. #define WS_CLK_HIGH()           (WS_OUT |= WS_BIT_CLK)
  30. #define WS_DAT_LOW()            (WS_OUT &= ~WS_BIT_DAT)
  31. #define WS_DAT_HIGH()           (WS_OUT |= WS_BIT_DAT)
  32.  
  33. #define WS_CLK_FLOAT()
  34.  
  35. #define WS_DATA_CMD             0x40
  36. #define WS_WYSW_CTRL            0x80
  37. #define WS_adres_CMD             0xC0
  38.  
  39. #define WS_WRITE_WYSW           0x00
  40. #define WS_READ_KEYS            0x02
  41. #define WS_FIXED_adres           0x04
  42.  
  43. #define WS_WYSW_PWM_MASK        0x07
  44. #define WS_WYSW_ENABLE          0x08
  45.  
  46. #define DELAY_US                1
  47.  
  48. uint8_t kropka;
  49. uint8_t tryb;
  50.  
  51. PROGMEM const uint8_t WS_cyfry[] =
  52. {
  53.     0x3F, // 0
  54.     0x06, // 1
  55.     0x5B, // 2
  56.     0x4F, // 3
  57.     0x66, // 4
  58.     0x6D, // 5
  59.     0x7D, // 6
  60.     0x07, // 7
  61.     0x7F, // 8
  62.     0x6F, // 9
  63. };
  64. class komunikacja
  65. {
  66. public:
  67. void Init(uint32_t speed);
  68. void Start();
  69. void Stop();
  70. void adresess(uint8_t data);
  71. void Write(uint8_t data);
  72. uint8_t ReadACK();
  73. uint8_t ReadNACK();
  74. private:
  75. uint8_t data;
  76. uint8_t speed;
  77. };
  78. class wyswietlacz
  79. {
  80.     public:
  81.     wyswietlacz();
  82.     void kasuj();
  83.     void wyswietlBajt(const uint8_t polozenie, const uint8_t b);
  84.     void wyswietlCyfre(const uint8_t polozenie, const uint8_t cyfra);
  85.     void wyswietlCyfry(uint32_t liczba, uint8_t przesuniecie = wyswietlacz_cyfry-1, const uint8_t rownanie = WS_PRAWY);
  86.     void ustawJasnosc(const uint8_t jasnosc);
  87.  
  88.     protected:
  89.    
  90.     uint8_t _dotMask;
  91.     uint8_t polozenie;
  92.     uint8_t b;
  93.     uint8_t cyfra;
  94.     uint8_t rownanie;
  95.     uint8_t jasnosc;
  96.     uint8_t liczba;
  97. };
  98.  
  99. class temperatura
  100. {
  101.     public:
  102.     void odczyt(const uint8_t o);
  103.     private:
  104.     float tempr;
  105.     uint8_t read;
  106.  
  107. };
  108.  
  109. class zegar
  110. {
  111.     public:
  112.     uint8_t sekundy;
  113.     uint8_t minuty;
  114.     uint8_t godziny;
  115.     uint8_t dTygodnia;
  116.     uint8_t dzien;
  117.     uint8_t miesiac;
  118.     uint8_t rok;
  119. };
  120.  
  121. class mzegar
  122.  
  123. : public zegar
  124. {
  125. typedef zegar czasBDC;
  126. typedef zegar czasDEC;
  127. public:
  128.  
  129. uint8_t DECnaBCD(uint8_t data);
  130. czasBDC DECnaBCD(czasDEC data);
  131. uint8_t BCDnaDEC(uint8_t data);
  132. czasDEC BCDnaDEC(czasBDC data);
  133. void rtcUstawCzasBDC(czasBDC data);
  134. void rtcUstawCzasDEC(czasDEC data);
  135. czasBDC rtcPobierzCzasBDC();
  136. czasDEC rtcPobierzCzasDEC();
  137. };
  138.  
  139. zegar teraz;
  140. zegar bufor;
  141. #define ustaw(reg, num) ((reg) |= (1 << (num)))
  142. #define clear(reg, num) ((reg) &= ~(1 << (num)))
  143.  
  144.  
  145.  
  146.  
  147.  
  148.  
  149. namespace
  150. {
  151.     void port_setup()
  152.     {
  153.         WS_DDR |= WS_BIT_CLK | WS_BIT_DAT;
  154.         WS_OUT |= WS_BIT_CLK;
  155.     }
  156.  
  157.     void start()
  158.     {
  159.         WS_CLK_HIGH();
  160.         WS_DAT_HIGH();
  161.         _delay_us(DELAY_US);
  162.  
  163.         WS_DAT_LOW();
  164.         _delay_us(DELAY_US);
  165.     }
  166.  
  167.     void stop()
  168.     {
  169.         WS_CLK_LOW();
  170.         _delay_us(DELAY_US);
  171.  
  172.         WS_CLK_HIGH();
  173.         WS_DAT_LOW();
  174.         _delay_us(DELAY_US);
  175.  
  176.         WS_DAT_HIGH();
  177.     }
  178.  
  179.     void wyslij(uint8_t b)
  180.     {
  181.        
  182.  
  183.         for (uint8_t i = 8; i; --i, b >>= 1)
  184.         {
  185.             WS_CLK_LOW();
  186.             if (b & 1)
  187.             WS_DAT_HIGH();
  188.             else
  189.             WS_DAT_LOW();
  190.             _delay_us(DELAY_US);
  191.  
  192.             WS_CLK_HIGH();
  193.             _delay_us(DELAY_US);
  194.         }
  195.  
  196.  
  197.         WS_CLK_LOW();
  198.         WS_DAT_LOW();
  199.         _delay_us(DELAY_US);
  200.  
  201.         WS_CLK_HIGH();
  202.         _delay_us(DELAY_US);
  203.     }
  204.  
  205.     void wyslij_cmd(const uint8_t cmd)
  206.     {
  207.         start();
  208.         wyslij(cmd);
  209.         stop();
  210.     }
  211.  
  212.     void wyslij_data(const uint8_t adres, const uint8_t data)
  213.     {
  214.         wyslij_cmd(WS_DATA_CMD | WS_FIXED_adres);
  215.  
  216.         start();
  217.         wyslij(WS_adres_CMD | adres);
  218.         wyslij(data);
  219.         stop();
  220.  
  221.         _delay_us(DELAY_US);
  222.     }
  223.  
  224.     uint8_t przesuniecie_cyfry(uint32_t num)
  225.     {
  226.         uint8_t cyfry = 0;
  227.         while (num >= 10)
  228.         {
  229.             num /= 10;
  230.             ++cyfry;
  231.         }
  232.     return cyfry;
  233.     }
  234. }
  235.  
  236. wyswietlacz::wyswietlacz()
  237. : _dotMask(0)
  238. {
  239.     port_setup();
  240.  
  241.     wyslij_cmd(WS_DATA_CMD | WS_WRITE_WYSW);
  242.     wyslij_cmd(WS_WYSW_CTRL | WS_WYSW_ENABLE | WS_WYSW_PWM_MASK);
  243.  
  244.     kasuj();
  245. }
  246.  
  247. void wyswietlacz::kasuj()
  248. {
  249.     for (uint8_t a = 0; a != wyswietlacz_cyfry; ++a)
  250.     wyslij_data(a, 0x00);
  251. }
  252.  
  253. void wyswietlacz::wyswietlBajt(const uint8_t polozenie, const uint8_t b)
  254. {
  255.     wyslij_data(polozenie, b | (_dotMask & (1 << polozenie)));
  256. }
  257.  
  258. void wyswietlacz::wyswietlCyfre(const uint8_t polozenie, const uint8_t cyfra) {
  259.     if (polozenie == 1 and kropka){
  260.         uint8_t x = pgm_read_byte(&WS_cyfry[cyfra & 0xF]);
  261.         wyswietlBajt(polozenie, x | 0x80);
  262.     }
  263.     else {
  264.         wyswietlBajt(polozenie, pgm_read_byte(&WS_cyfry[cyfra & 0xF]));
  265.     }
  266. }
  267.  
  268. void wyswietlacz::wyswietlCyfry(uint32_t liczba, uint8_t przesuniecie, const uint8_t rownanie)
  269. {
  270.     if (rownanie == WS_LEWY)
  271.     przesuniecie += przesuniecie_cyfry(liczba);
  272.     while (liczba && przesuniecie != 0xFF)
  273.     {
  274.         wyswietlCyfre(przesuniecie--, liczba % 10 );
  275.        
  276.         liczba /= 10;
  277.     }
  278. }
  279.  
  280. void wyswietlacz::ustawJasnosc(const uint8_t jasnosc)
  281. {
  282.     wyslij_cmd(WS_WYSW_CTRL | WS_WYSW_ENABLE | (jasnosc & WS_WYSW_PWM_MASK));
  283. }
  284.  
  285. wyswietlacz wysw;
  286.  
  287. void komunikacja::Init(uint32_t speed)
  288. {
  289.    
  290.     TWCR = (1<<TWEA) | (1<<TWEN);
  291.     uint8_t prescaler = 0;
  292.     speed = (F_CPU/speed/100-16)/2;
  293.  
  294.     while(speed > 255)
  295.     {
  296.         prescaler++;
  297.         speed=speed/4;
  298.     }
  299.  
  300.     TWSR = (TWSR & ((1<<TWPS1) | (1<<TWPS0))) | prescaler;
  301.     TWBR = speed;
  302. }
  303.  
  304. void komunikacja::Start()
  305. {
  306.     TWCR = (1<<TWINT)|(1<<TWSTA)| (1<<TWEN);
  307.     while (!(TWCR & (1<<TWINT)));
  308. }
  309.  
  310. void komunikacja::Stop()
  311. {
  312.     TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTO);
  313.     while(TWCR & (1<<TWSTO));
  314. }
  315.  
  316. void komunikacja::adresess(uint8_t data)
  317. {
  318.     TWDR = data;
  319.     TWCR = (1<<TWINT) | (1<<TWEN);
  320.     while (!(TWCR & (1<<TWINT)));
  321. }
  322.  
  323. void komunikacja::Write(uint8_t data)
  324. {
  325.     TWDR = data;
  326.     TWCR = (1<<TWINT) | (1<<TWEN);
  327.     while (!(TWCR & (1<<TWINT)));
  328. }
  329.  
  330. uint8_t komunikacja::ReadACK()
  331. {
  332.     TWCR = (1<<TWEA) | (1<<TWINT) | (1<<TWEN);
  333.     while (!(TWCR & (1<<TWINT)));
  334.  
  335.     return TWDR;
  336. }
  337. uint8_t komunikacja::ReadNACK()
  338. {
  339.     TWCR = (1<<TWINT) | (1<<TWEN);
  340.     while (!(TWCR & (1<<TWINT)));
  341.  
  342.     return TWDR;
  343. }
  344. komunikacja twi;
  345.  
  346. typedef zegar czasBDC;
  347. typedef zegar czasDEC;
  348.  
  349. uint8_t mzegar::DECnaBCD(uint8_t data)
  350. {
  351.     uint8_t wynik;
  352.  
  353.     wynik = (data / 10) << 4;
  354.     wynik += (data % 10);
  355.  
  356.     return wynik;
  357. }
  358.  
  359. czasBDC mzegar::DECnaBCD(czasDEC data)
  360. {
  361.     czasBDC wynik;
  362.  
  363.     wynik.sekundy = DECnaBCD(data.sekundy);
  364.     wynik.minuty = DECnaBCD(data.minuty);
  365.     wynik.godziny = DECnaBCD(data.godziny);
  366.     wynik.dTygodnia = DECnaBCD(data.dTygodnia);
  367.     wynik.dzien = DECnaBCD(data.dzien);
  368.     wynik.miesiac = DECnaBCD(data.miesiac);
  369.     wynik.rok = DECnaBCD(data.rok);
  370.  
  371.     return wynik;
  372. }
  373.  
  374. uint8_t mzegar::BCDnaDEC(uint8_t data)
  375. {
  376.     uint8_t wynik;
  377.  
  378.     wynik = data & 0x0f;
  379.     wynik += ((data >> 4)) * 10;
  380.  
  381.     return wynik;
  382. }
  383.  
  384. czasDEC mzegar::BCDnaDEC(czasBDC data)
  385. {
  386.     czasDEC wynik;
  387.  
  388.     wynik.sekundy = BCDnaDEC(data.sekundy);
  389.     wynik.minuty = BCDnaDEC(data.minuty);
  390.     wynik.godziny = BCDnaDEC(data.godziny);
  391.     wynik.dTygodnia = BCDnaDEC(data.dTygodnia);
  392.     wynik.dzien = BCDnaDEC(data.dzien);
  393.     wynik.miesiac = BCDnaDEC(data.miesiac);
  394.     wynik.rok = BCDnaDEC(data.rok);
  395.  
  396.     return wynik;
  397.     }
  398.  
  399. void mzegar::rtcUstawCzasBDC(czasBDC data)
  400. {
  401.     twi.Start();
  402.     twi.adresess(208);
  403.     twi.Write(0);
  404.  
  405.     twi.Write(data.sekundy);
  406.     twi.Write(data.minuty);
  407.     twi.Write(data.godziny);
  408.     twi.Write(data.dTygodnia);
  409.     twi.Write(data.dzien);
  410.     twi.Write(data.miesiac);
  411.     twi.Write(data.rok);
  412.  
  413.     twi.Stop();
  414.  
  415. }
  416. void mzegar::rtcUstawCzasDEC(czasDEC data)
  417. {
  418.     rtcUstawCzasBDC(DECnaBCD(data));
  419. }
  420.  
  421. czasBDC mzegar::rtcPobierzCzasBDC()
  422. {
  423.     czasBDC data;
  424.  
  425.     twi.Start();
  426.     twi.adresess(208);
  427.     twi.Write(0);
  428.     twi.Start();
  429.     twi.adresess(209);
  430.  
  431.     data.sekundy = twi.ReadACK();
  432.     data.minuty = twi.ReadACK();
  433.     data.godziny = twi.ReadACK();
  434.     data.dTygodnia = twi.ReadACK();
  435.     data.dzien = twi.ReadACK();
  436.     data.miesiac = twi.ReadACK();
  437.     data.rok = twi.ReadNACK();
  438.  
  439.     twi.Stop();
  440.     return data;
  441.  
  442. }
  443. czasDEC mzegar::rtcPobierzCzasDEC()
  444. {
  445.     return BCDnaDEC(rtcPobierzCzasBDC());
  446. }
  447. mzegar mzegar;
  448.  
  449. void rtcInit()
  450. {
  451.     twi.Init(400000);
  452.     twi.Start();
  453.     twi.adresess(208);
  454.     twi.Write(7);
  455.     twi.Write(0b00010000);
  456.     twi.Stop();
  457.     ustaw(PORTD, PD2);
  458.     EICRA |= (1 << ISC00) | (1 << ISC01);
  459.     EIMSK |= (1 << INT0);
  460. }
  461.  
  462. void ustawtryb(){
  463.     if(!(PIND & SW1) && ((tryb==4) || (tryb==6) || (tryb==8) || (tryb==10))){
  464.     tryb=1;}
  465.     if((PIND & SW1) && (tryb==1)){
  466.     tryb=2;}
  467.  
  468.     if(!(PIND & SW2) && ((tryb==2) || (tryb==6) || (tryb==8) || (tryb==10))){
  469.     tryb=3;}
  470.     if((PIND & SW2) && (tryb==3)){
  471.     tryb=4;}
  472.  
  473.     if(!(PIND & SW3) && ((tryb==4) || (tryb==2) || (tryb==8) || (tryb==10))){
  474.     tryb=5;}
  475.     if((PIND & SW3) && (tryb==5)){
  476.     tryb=6;}
  477.  
  478.     if(!(PIND & SW1) && (tryb==2)){
  479.     tryb=7;}
  480.     if((PIND & SW1) && (tryb==7)){
  481.     tryb=8;}
  482.  
  483.     if(!(PIND & SW2) && (tryb==4)){
  484.     tryb=9;}
  485.     if((PIND & SW2) && (tryb==9)){
  486.     tryb=10;}
  487.  
  488. }
  489.  
  490. void czas(){
  491.  
  492.     bufor = mzegar.rtcPobierzCzasDEC();
  493.     if(bufor.sekundy%2 == 0){
  494.     kropka=1;}
  495.     else{kropka = 0;};
  496.     wysw.wyswietlCyfry(bufor.godziny,1);
  497.     wysw.wyswietlCyfry(bufor.minuty,3);
  498.     if(bufor.godziny <=9){
  499.     wysw.wyswietlCyfre(0,0);};
  500.     if(bufor.godziny == 0){
  501.     wysw.wyswietlCyfre(1,0);};
  502.     if(bufor.minuty <=9){
  503.     wysw.wyswietlCyfre(2,0);};
  504.     if(bufor.minuty == 0){
  505.     wysw.wyswietlCyfre(3,0);};
  506. };
  507.  
  508. void dzien(){
  509.     bufor = mzegar.rtcPobierzCzasDEC();
  510.     kropka=1;
  511.     wysw.wyswietlCyfry(bufor.dzien + 3,1);
  512.     wysw.wyswietlCyfry(bufor.miesiac,3);
  513.     if(bufor.dzien <=9){
  514.     wysw.wyswietlCyfre(0,0);};
  515.     if(bufor.dzien == 0){
  516.     wysw.wyswietlCyfre(1,0);};
  517.     if(bufor.miesiac <=9){
  518.     wysw.wyswietlCyfre(2,0);};
  519.     if(bufor.miesiac == 0){
  520.     wysw.wyswietlCyfre(3,0);}
  521. ;};
  522. void InitADC()
  523. {
  524.     ADMUX |= (1<<REFS0)|(1<<REFS1) ;
  525.     ADCSRA |= (1<<ADPS2)|(1<<ADPS1)|(1<<ADEN);
  526. }
  527.  
  528. uint16_t odczytADC(uint8_t wejscie)
  529. {
  530.     ADMUX = (ADMUX & 0xF0) | (wejscie & 0x0F);
  531.     ADCSRA |= (1<<ADSC);
  532.     while( ADCSRA & (1<<ADSC) );
  533.     return ADC;
  534. }
  535.  
  536. void temperatura::odczyt(const uint8_t o){
  537.     kropka = 0;
  538.     tempr = odczytADC(o);
  539.  
  540.     tempr = tempr / 1024;
  541.     tempr = tempr - 0.5;
  542.     tempr = tempr*111;
  543.     wysw.wyswietlCyfry(tempr,0,WS_LEWY);
  544.     wysw.wyswietlBajt(2,0b1100011);
  545.     if (o == 0) wysw.wyswietlBajt(3,0b1000000);
  546.     if (o == 1) wysw.wyswietlBajt(3,0b0000001);
  547.     _delay_ms(200);
  548. };
  549.  
  550.  
  551. int main(){
  552.     temperatura temp;
  553.     sei();
  554.     rtcInit();
  555.     /* WGRYWANIE DATY
  556.     teraz.sekundy = x ; 0-60
  557.     teraz.minuty = x ; 0-60
  558.     teraz.godziny = x ; 0-24
  559.     teraz.dTygodnia=x ; // Dzien tygodnia w formacie pon = 1, wt = 2...
  560.     teraz.dzien = x ; 1-31
  561.     teraz.miesiac = x; 1-12
  562.     teraz.rok = x; //00-99
  563.     rtc.rtcUstawCzasDEC(teraz);
  564.     */
  565.     InitADC();
  566.     uint8_t ujasnosc = 1;
  567.    
  568.     wysw.ustawJasnosc(ujasnosc);
  569.     float napiecie;
  570.  
  571.     tryb=2;
  572.    
  573.  
  574.     while(1){
  575.        
  576.  
  577.  
  578.         ustawtryb();
  579.         switch(tryb)
  580.         {
  581.             case 2:
  582.             czas();
  583.             if (bufor.godziny > 9 and bufor.godziny < 18){
  584.             wysw.ustawJasnosc(7);}
  585.             else {wysw.ustawJasnosc(1);}
  586.             break;
  587.             case 8:
  588.             dzien();
  589.             break;
  590.             case 4:
  591.             temp.odczyt(0);
  592.             break;
  593.             case 10:
  594.             temp.odczyt(1);
  595.             break;
  596.             case 6:
  597.             kropka = 1;
  598.             napiecie = odczytADC(3);
  599.             napiecie = napiecie * 167.6;
  600.             napiecie = napiecie/1024;
  601.             if (napiecie > 5){
  602.             wysw.wyswietlCyfry(napiecie,0,WS_LEWY);}
  603.             else wysw.kasuj();
  604.             _delay_us(200);
  605.            
  606.             break;
  607.             default:
  608.             wysw.kasuj();
  609.             break;
  610.         }
  611.  
  612.     }
  613. }
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!