main.c
[syntax=c]#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <util/delay.h>
#include "LCD/lcd44780.h"
#include "I2C_TWI/i2c_twi.h"
#include "MULTIPLEKS/multipleks.h"
#define DS1307_ADDR 0xD0
volatile uint8_t int0_flag=1;// flaga zmieniana w przerwaniu i sprawdzana w pętli głównej
volatile int anoda;
volatile uint16_t cnt, liczba;
volatile uint8_t tys, set, dzi, jed;
const uint8_t cyfry[12] PROGMEM = {
(uint8_t)~(SEG_A|SEG_B|SEG_C|SEG_D|SEG_E|SEG_F), // 0 0x3F
(uint8_t)~(SEG_B|SEG_C), // 1 0x06
(uint8_t)~(SEG_A|SEG_B|SEG_D|SEG_E|SEG_G), // 2
(uint8_t)~(SEG_A|SEG_B|SEG_C|SEG_D|SEG_G), // 3
(uint8_t)~(SEG_B|SEG_C|SEG_F|SEG_G), // 4
(uint8_t)~(SEG_A|SEG_C|SEG_D|SEG_F|SEG_G), // 5
(uint8_t)~(SEG_A|SEG_C|SEG_D|SEG_E|SEG_F|SEG_G), // 6
(uint8_t)~(SEG_A|SEG_B|SEG_C|SEG_F), // 7
(uint8_t)~(SEG_A|SEG_B|SEG_C|SEG_D|SEG_E|SEG_F|SEG_G), // 8
(uint8_t)~(SEG_A|SEG_B|SEG_C|SEG_D|SEG_F|SEG_G), // 9
(uint8_t)~(SEG_DP),//10
0xFF // NIC
};
// konwersja liczby dziesiętnej na BCD
uint8_t dec2bcd(uint8_t dec);
// konwersja liczby BCD na dziesiętną
uint8_t bcd2dec(uint8_t bcd);
int main(void) {
/***********************************PODŚWIETLENIE****************************************
DDRA |= (1<<PA7);
PORTA |= (1<<PA7); // podświetlenie wyświetlacza LCD
****************************************************************************************/
liczba = 0;
led_init();
sei();
// Przerwanie INT0
MCUCR |= (1<<ISC01);// wyzwalanie zboczem opadającym
GICR |= (1<<INT0);// odblokowanie przerwania
PORTD |= (1<<PD2);// podciągnięcie pinu INT0 do VCC
// definiujemy sobie dla polepszenia czytelności programu typ wyliczeniowy
// wskazujący nam później na odpowiednie indeksy w tablicy (buforze)
enum {ss, mm, hh, dt, dd, mie, rr};
//Dni tygodnia
static uint8_t bufor[7];// rezerwacja bufora 3 bajty
volatile uint8_t sekundy, minuty, godziny, dzient, dni, miesiace, rok;
char *dzien[]={"", "NIE,", "PON,", "WTO,", "SRO,", "CZW,", "PIA,", "SOB,"};
char *miesiac[]={"", "STY", "LUT", "MAR", "KWI", "MAJ", "CZE", "LIP", "SIE", "WRZ", "PAZ", "LIS", "GRU"};
lcd_init();
i2cSetBitrate(100);
// Ustawianie czasu na godzinę: 18:34:27
bufor[0] = dec2bcd(0);// sekundy
bufor[1] = dec2bcd(0);// minuty
bufor[2] = dec2bcd(0);// godziny
bufor[3] = dec2bcd(1);// dzień tygodnia
bufor[4] = dec2bcd(10);// dni
bufor[5] = dec2bcd(3);// miesiące
bufor[6] = dec2bcd(19);// lata
// zapis 7 bajtów z bufora pod adres 0x00 w pamięci RAM naszego RTC
TWI_write_buf( DS1307_ADDR, 0x00, 7, bufor );
/****************************************ORYGINALNA FUNKCJA*********************************************
***********************FUNKCJA ZE STRONY https://forum.atnel.pl/topic9874.html**************************
* //Inicjalizacja DS1307
void DS1307_init( void ){
uint8_t ctrl = 0x10; //Rejstr kontrolny, ustawiamy cześtotliwośc oscylatora etc. (u nas 1Hz)
TWI_write_buf( DS1307_ADDR, 0x07, 1, &ctrl ); //Adres DS1307 0xD0
uint8_t CH = 0; //ustawienie bitu 7 w rejstrze o adresie 0x00 na 0 odblokowuje oscylator
TWI_write_buf(DS1307_ADDR, 0, 1, &CH);
}
TWI_write_buf(DS1307_ADDR, 0, 1, &CH);
*/
while(1) {
if ( int0_flag ) {
//odczyt 3 bajtów do bufora od adresu 0x00 z pamięci RAM naszego RTC
TWI_read_buf( DS1307_ADDR, 0x00, 7, bufor );
sekundy = bcd2dec( bufor[ss] );//&0x7f
minuty = bcd2dec( bufor[mm] );
godziny = bcd2dec( bufor[hh] );
dzient = bcd2dec( bufor[dt] );
dni = bcd2dec( bufor[dd] );
miesiace = bcd2dec( bufor[mie] );
rok = bcd2dec( bufor[rr] );
//WYŚWIETLANIE DNI TYGODNIA
lcd_str(dzien[dzient]);
// wyświetlenie czasu na LCD
lcd_locate(1,8);
if( godziny < 10 ) lcd_str("0");
lcd_int(godziny);
lcd_str(":");
if( minuty < 10 ) lcd_str("0");
lcd_int(minuty);
lcd_str(":");
if( sekundy < 10 ) lcd_str("0");
lcd_int(sekundy);
//WYŚWIETLANIE DATY
lcd_locate(0,5);
if (dni < 10 ) lcd_str("0");
lcd_int(dni);
lcd_str(" ");
//if (miesiace < 10 ) lcd_str("");
lcd_str(miesiac[miesiace]);
lcd_str(" ");
if (rok < 10) lcd_str("0");
lcd_str("20");
lcd_int(rok);
///////////////////////OBLICZENIE CYFR DLA LED///////////////////
/*tys = (minuty/10);
set = (minuty - (tys*10));
dzi = sekundy/10;
jed = (sekundy -(dzi*10));
*/
if(cnt==10){//liczba - szybkość zwiększania wyświetlanej liczby
liczba++;
cnt=0;
if(liczba>9999) liczba=0;
}
//////////////////////////////////zamiana liczby na pojedyncze cyfry///////////////////////////////
tys = (liczba/1000);
set = (liczba - (tys*1000))/100;
dzi = (liczba - (tys*1000)-(set*100))/10;
jed = (liczba - (tys*1000)-(set*100)-(dzi*10));
}
}
}
// procedura obsługi przerwania INT 0
ISR( INT0_vect ) {
int0_flag = 1;
}
///////////////////////////////PRZERWANIE DLA MULIPLRKSOWANIA LED//////////////////////////////////////
ISR(TIMER2_COMP_vect){
if(anoda>3){
anoda=0;
}
/****************************************CYFRA1*****************************************/
if (anoda==0){
//SEGMENTY_PORT |= 0xFF;//wygaszanie katod
ANODY_PORT |= ANODA4;//wygaszenie anody4
ANODY_PORT &= ~ANODA1;//zapalenie anody
SEGMENTY_PORT = pgm_read_byte (&cyfry[tys]);//zapalenie katod
//PORTD &= ~(1<<PD7);//zapalenie kropki po pierwszym znaku
}
/****************************************CYFRA2*****************************************/
if (anoda==1){
//SEGMENTY_PORT |= 0xFF;//wygaszanie katod
ANODY_PORT |= ANODA1;//wygaszenie anody
ANODY_PORT &= ~ANODA2;//zapalenie anody
SEGMENTY_PORT = pgm_read_byte (&cyfry[set]);//zapalenie katod
}
/****************************************CYFRA3*****************************************/
if (anoda==2){
//SEGMENTY_PORT |= 0xFF;//wygaszanie katod
ANODY_PORT |= ANODA2;//wygaszenie anody
ANODY_PORT &= ~ANODA3;//zapalenie anody
SEGMENTY_PORT = pgm_read_byte (&cyfry[dzi]);
}
/****************************************CYFRA4*****************************************/
if (anoda==3){
//SEGMENTY_PORT |= 0xFF;//wygaszanie katod
ANODY_PORT |= ANODA3;//wygaszenie anody
ANODY_PORT &= ~ANODA4;//zapalenie anody
SEGMENTY_PORT = pgm_read_byte (&cyfry[jed]);//zapalenie katod
}
/******************************KONIEC MULTIPLEKSOWANIA**********************************/
anoda++;
cnt++;
}
//////////////////////KONEC PRZERWANIA DLA MULTIPLEKSOWANIA LED//////////////////////////
// konwersja liczby dziesiętnej na BCD
uint8_t dec2bcd(uint8_t dec) {
return ((dec / 10)<<4) | (dec % 10);
}
// konwersja liczby BCD na dziesiętną
uint8_t bcd2dec(uint8_t bcd) {
return ((((bcd) >> 4) & 0x0F) * 10) + ((bcd) & 0x0F);
}[/syntax]
multipleks.c
[syntax=c]#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <avr/pgmspace.h>
#include "multipleks.h"
/*
const uint8_t cyfry[11] = {
(uint8_t)~(SEG_A|SEG_B|SEG_C|SEG_D|SEG_E|SEG_F), // 0
(uint8_t)~(SEG_B|SEG_C), // 1
(uint8_t)~(SEG_A|SEG_B|SEG_D|SEG_E|SEG_G), // 2
(uint8_t)~(SEG_A|SEG_B|SEG_C|SEG_D|SEG_G), // 3
(uint8_t)~(SEG_B|SEG_C|SEG_F|SEG_G), // 4
(uint8_t)~(SEG_A|SEG_C|SEG_D|SEG_F|SEG_G), // 5
(uint8_t)~(SEG_A|SEG_C|SEG_D|SEG_E|SEG_F|SEG_G), // 6
(uint8_t)~(SEG_A|SEG_B|SEG_C|SEG_F), // 7
(uint8_t)~(SEG_A|SEG_B|SEG_C|SEG_D|SEG_E|SEG_F|SEG_G), // 8
(uint8_t)~(SEG_A|SEG_B|SEG_C|SEG_D|SEG_F|SEG_G), // 9
0xFF // NIC (puste miejsce)
};
*/
void led_init(void){
///////////////////////////////////////////////////konfiguracja anod///////////////////////////////
DDRC |= (ANODA1|ANODA2|ANODA3|ANODA4); //piny PB1..PB4 wyjścia 0x1E
PORTC |= (ANODA1|ANODA2|ANODA3|ANODA4);//ustawienie stanu wysokiego na anodach(wygaszenie wyświetlacza)
//////////////////////////////////////////////////konfiguracja katod///////////////////////////////
DDRA |= 0xFF;//piny katod ustawione jako wyjścia
PORTA |= 0xFF;//piny katod wyzerowane (segmenty wygaszone)
////////////////////////inicjalizacja przerwania///////////////////////////////////////////////////
TCCR2 |= (1<<WGM21);//Tryb CTC
TCCR2 |= (1<<CS20)|(1<<CS21)|(1<<CS22);//preskaler 1024
OCR2 = 20;//wartość przepełnienia
TIMSK |= (1<<OCIE2);//zezwolenie na przerwanie ComtareeMatch
}
////////////////////////koniec funkcji led_init////////////////////////////////////////////////////
////////////////////////////dekodowanie liczby do wyświetlenia////////////////////////////////////[/syntax]
multipleks.h
[syntax=c]#ifndef MULTIPLEKS_H_
#define MULTIPLEKS_H_
//////////////////////////////definicja portów anod////////////////////////////////////////////////
#define ANODY_DIR DDRC
#define ANODY_PORT PORTC
/////////////////////////////definicja pinów anod//////////////////////////////////////////////////
#define ANODA1 (1<<PC4)
#define ANODA2 (1<<PC5)
#define ANODA3 (1<<PC6)
#define ANODA4 (1<<PC7)
//////////////////////////////////definicja portów segmentów///////////////////////////////////////
#define SEGMENTY_DIR DDRA
#define SEGMENTY_PORT PORTA
/////////////////////definicja pinów segmentów/////////////////////////////////////////////////////
#define SEG_A 1<<PA0
#define SEG_B 1<<PA1
#define SEG_C 1<<PA2
#define SEG_D 1<<PA3
#define SEG_E 1<<PA4
#define SEG_F 1<<PA5
#define SEG_G 1<<PA6
#define SEG_DP 1<<PA7
#define NIC 10
//szybkość multipleksowania
#define pre0 (1<<CS20)
#define pre8 (1<<CS21)
#define pre32 (1<<CS20)|(1<<CS21)
#define pre64 (1<<CS22)
#define pre128 (1<<CS20)|(1<<CS22)
#define pre256 (1<<CS21)|(1<<CS22)
#define pre1024 (1<<CS20)|(1<<CS21)|(1<<CS22)
/////////////////////////////////////przycisk//////////////////////////////////////////////////////
//#define przycisk 1<<PC3
//////////////////////////////////////funkcje//////////////////////////////////////////////////////
void led_init(void);
#endif /* MULTIPLEKS_H_ */[/syntax]
i2c.c
[syntax=c]#include <avr/io.h>
#include "i2c_twi.h"
void i2cSetBitrate(uint16_t bitrateKHz) {
uint8_t bitrate_div;
bitrate_div = ((F_CPU/1000l)/bitrateKHz);
if(bitrate_div >= 16)
bitrate_div = (bitrate_div-16)/2;
TWBR = bitrate_div;
}
void TWI_start(void) {
TWCR = (1<<TWINT)|(1<<TWEN)|(1<<TWSTA);
while (!(TWCR&(1<<TWINT)));
}
void TWI_stop(void) {
TWCR = (1<<TWINT)|(1<<TWEN)|(1<<TWSTO);
while ( !(TWCR&(1<<TWSTO)));
}
void TWI_write(uint8_t bajt) {
TWDR = bajt;
TWCR = (1<<TWINT)|(1<<TWEN);
while ( !(TWCR&(1<<TWINT)));
}
uint8_t TWI_read(uint8_t ack) {
TWCR = (1<<TWINT)|(ack<<TWEA)|(1<<TWEN);
while ( !(TWCR & (1<<TWINT)));
return TWDR;
}
void TWI_write_buf( uint8_t SLA, uint8_t adr, uint8_t len, uint8_t *buf ) {
TWI_start();
TWI_write(SLA);
TWI_write(adr);
while (len--) TWI_write(*buf++);
TWI_stop();
}
void TWI_read_buf(uint8_t SLA, uint8_t adr, uint8_t len, uint8_t *buf) {
TWI_start();
TWI_write(SLA);
TWI_write(adr);
TWI_start();
TWI_write(SLA + 1);
while (len--) *buf++ = TWI_read( len ? ACK : NACK );
TWI_stop();
}[/syntax]
i2c.h
[syntax=c]#ifndef I2C_TWI_H_
#define I2C_TWI_H_
#define ACK 1
#define NACK 0
// funkcje
void i2cSetBitrate(uint16_t bitrateKHz);
void TWI_start(void);
void TWI_stop(void);
void TWI_write(uint8_t bajt);
uint8_t TWI_read(uint8_t ack);
void TWI_write_buf( uint8_t SLA, uint8_t adr, uint8_t len, uint8_t *buf );
void TWI_read_buf(uint8_t SLA, uint8_t adr, uint8_t len, uint8_t *buf);
#endif /* I2C_TWI_H_ */[/syntax]
Statystyki: Napisane przez 11jacekj — 10 mar 2019, o 21:20
]]>