Mam zamiar zaprojektować płytkę pod zegarek binarny opisany w EDW 07/2011, a jako, że muszą to zrobić na bardzo małym obszarze dobrze byłoby zmienić piny do których podłączone będą diody. I tu rodzi się moje pytanie - czy w poniższym kodzie nie będzie większych problemów ze zmianą wyprowadzeń? Niby są definicje, ale są one określone dla jednego portu. Najpewniej wyjdzie mi to tak, że podłączenia będą porozrzucane po całej medze do różnych portów.
[syntax=c]//////////////////////////////////////////////////////////
// uClock bsw v.2.0
//////////////////////////////////////////////////////////
#include <avr\io.h>
#include <avr\interrupt.h>
#include <avr\pgmspace.h>
#include <avr\sleep.h>
#include <avr\eeprom.h>
#include <util\delay.h>
//////////////////////////////////////////////////////////
// Makra upraszczające dostęp do portów
//////////////////////////////////////////////////////////
// PORT
#define PORT(x) XPORT(x)
#define XPORT(x) (PORT##x)
// PIN
#define PIN(x) XPIN(x)
#define XPIN(x) (PIN##x)
// DDR
#define DDR(x) XDDR(x)
#define XDDR(x) (DDR##x)
//////////////////////////////////////////////////////////
// Makro upraszczające definicję zmiennych eeprom
//////////////////////////////////////////////////////////
#define EEPROM __attribute__ ((section (".eeprom")))
//////////////////////////////////////////////////////////
// Definicje portów
//////////////////////////////////////////////////////////
// Definicje wyprowadzeń portu B
// Definicje wyprowadzeń portu C
#define H01 0
#define H02 1
#define H04 2
#define H08 3
// Definicje wyprowadzeń portu D
#define KEY 2
#define M32 1
#define M16 3
#define M08 4
#define M04 5
#define M02 7
#define M01 6
// Definicje trybów wyświetlania
#define DISP_MODE_OFF 0
#define DISP_MODE_BIN 1
#define DISP_MODE_BIN2 2
#define DISP_MODE_POV 3
#define DISP_MODE_SET 4
#define DISP_MODE_SETH 5
#define DISP_MODE_SETM 6
#define DISP_MODE_SETN 7
#define DISP_MODE_SETC 8
#define DISP_MODE_TO_OFF 9
// Definicje symboli w trybie ustawiania
#define SYMB_HI 48
#define SYMB_LO 3
#define SYMB_CR 12
// Definicje stałych
#define SECOND_TO_ADD 2
#define BELL_2SECONDS 1800
#define BLINK_DELAY 150
#define STEP_DELAY 150
#define CORRECTION_DELAY STEP_DELAY*6
#define POV_DELAY 1000
#define SET_DELAY 1200
#define LONG_DELAY 5000
// wzorce cyfer w pamięci programu
prog_uint8_t g_Digit[41]=
{
_BV(2) | _BV(4), //:
_BV(2) | _BV(3) | _BV(4) | _BV(5), //0
_BV(1) | _BV(6), //0
_BV(1) | _BV(6), //0
_BV(2) | _BV(3) | _BV(4) | _BV(5), //0
0, //1
_BV(3), //1
_BV(2), //1
_BV(1) | _BV(2) | _BV(3) | _BV(4) | _BV(5) | _BV(6), //1
_BV(2) | _BV(5) | _BV(6), //2
_BV(1) | _BV(4) | _BV(6), //2
_BV(1) | _BV(4) | _BV(6), //2
_BV(2) | _BV(3) | _BV(6), //2
_BV(2) | _BV(5), //3
_BV(1) | _BV(6), //3
_BV(1) | _BV(3) | _BV(6), //3
_BV(2) | _BV(4) | _BV(5), //3
_BV(3) | _BV(4), //4
_BV(2) | _BV(4), //4
_BV(1) | _BV(2) | _BV(3) | _BV(4) | _BV(5) | _BV(6), //4
_BV(4), //4
_BV(1) | _BV(2) | _BV(3) | _BV(5), //5
_BV(1) | _BV(3) | _BV(6), //5
_BV(1) | _BV(3) | _BV(6), //5
_BV(1) | _BV(4) | _BV(5), //5
_BV(2) | _BV(3) | _BV(4) | _BV(5), //6
_BV(1) | _BV(3) | _BV(6), //6
_BV(1) | _BV(3) | _BV(6), //6
_BV(1) | _BV(4) | _BV(5), //6
_BV(1), //7
_BV(1) | _BV(4) | _BV(5) | _BV(6), //7
_BV(1) | _BV(3), //7
_BV(1) | _BV(2), //7
_BV(2) | _BV(4) | _BV(5), //8
_BV(1) | _BV(3) | _BV(6), //8
_BV(1) | _BV(3) | _BV(6), //8
_BV(2) | _BV(4) | _BV(5), //8
_BV(2) | _BV(3) | _BV(6), //9
_BV(1) | _BV(3) | _BV(6), //9
_BV(1) | _BV(3) | _BV(6), //9
_BV(2) | _BV(3) | _BV(4) | _BV(5) //9
};
//////////////////////////////////////////////////////////
// TIME
//////////////////////////////////////////////////////////
// typ czas
typedef struct
{
uint8_t Sec;
uint8_t Min;
uint8_t Hour;
} Time;
// globalnie czas
volatile Time g_CurrTime;
// wyświetlany czas
volatile Time g_DispTime;
//korekcja czasu
uint8_t CorrectionValue EEPROM;
volatile uint8_t g_CorrectionValue = 0;
volatile uint8_t g_LastCorrection = 0;
// wyliczenie korekcji czasu
uint8_t CalculateCorrectionTime(void)
{
if(g_LastCorrection>0)
{
g_LastCorrection--;
return 0;
}
if(0==g_CorrectionValue) return 0;
if(g_CurrTime.Min>0) return 0;
if(!((3==g_CurrTime.Hour)||(9==g_CurrTime.Hour))) return 0;
if((30==g_CurrTime.Sec)||(31==g_CurrTime.Sec))
{
g_LastCorrection=15;
uint8_t Value;
if(g_CorrectionValue>=8)
return Value=g_CorrectionValue-8;
else
return Value=g_CorrectionValue;
if(3==g_CurrTime.Hour)
Value = Value/2;
else
Value = Value/2 + Value%2;
if(g_CorrectionValue>=8)
return -Value;
else
return Value;
}
else return 0;
}
//////////////////////////////////////////////////////////
// DISPLAY POV
//////////////////////////////////////////////////////////
#define MAX_POV 60
// Bufor wyświetlacza POV
typedef struct
{
uint8_t Buffer[MAX_POV];
uint8_t Phase;
} DisplayPov;
volatile DisplayPov g_DisplayPov;
// ustaw bufor wyswietlacza POV
void SetDisplayPov(uint8_t hour, uint8_t min)
{
uint8_t h1 = hour/10;
uint8_t h2 = hour%10;
uint8_t m1 = min/10;
uint8_t m2 = min%10;
uint8_t i;
for(i=0;i<MAX_POV;i++) g_DisplayPov.Buffer[i]=0;
g_DisplayPov.Phase=0;
for(i=4;i>0;--i)
{
g_DisplayPov.Buffer[g_DisplayPov.Phase++]=pgm_read_byte(&g_Digit[m2*4+i]);
g_DisplayPov.Buffer[g_DisplayPov.Phase++]=0;
}
g_DisplayPov.Buffer[g_DisplayPov.Phase++]=0;
for(i=4;i>0;--i)
{
g_DisplayPov.Buffer[g_DisplayPov.Phase++]=pgm_read_byte(&g_Digit[m1*4+i]);
g_DisplayPov.Buffer[g_DisplayPov.Phase++]=0;
}
g_DisplayPov.Buffer[g_DisplayPov.Phase++]=0;
g_DisplayPov.Buffer[g_DisplayPov.Phase++]=0;
g_DisplayPov.Buffer[g_DisplayPov.Phase++]=pgm_read_byte(&g_Digit[0]);
g_DisplayPov.Buffer[g_DisplayPov.Phase++]=pgm_read_byte(&g_Digit[0]);
g_DisplayPov.Buffer[g_DisplayPov.Phase++]=0;
g_DisplayPov.Buffer[g_DisplayPov.Phase++]=0;
g_DisplayPov.Buffer[g_DisplayPov.Phase++]=0;
for(i=4;i>0;--i)
{
g_DisplayPov.Buffer[g_DisplayPov.Phase++]=pgm_read_byte(&g_Digit[h2*4+i]);
g_DisplayPov.Buffer[g_DisplayPov.Phase++]=0;
}
if(h1>0)
{
g_DisplayPov.Buffer[g_DisplayPov.Phase++]=0;
for(i=4;i>0;--i)
{
g_DisplayPov.Buffer[g_DisplayPov.Phase++]=pgm_read_byte(&g_Digit[h1*4+i]);
g_DisplayPov.Buffer[g_DisplayPov.Phase++]=0;
}
g_DisplayPov.Phase=0;
}
}
// Ustaw wyświetlacz POV
void ShowDisplayPov(void)
{
uint8_t line = g_DisplayPov.Buffer[g_DisplayPov.Phase++];
PORT(D) = ~(((line & _BV(1))>>1)*_BV(M01) | ((line & _BV(2))>>2)*_BV(M02) |
((line & _BV(3))>>3)*_BV(M04) | ((line & _BV(4))>>4)*_BV(M08) |
((line & _BV(5))>>5)*_BV(M16) | ((line & _BV(6))>>6)*_BV(M32));
if(g_DisplayPov.Phase>=MAX_POV) g_DisplayPov.Phase=0;
}
//////////////////////////////////////////////////////////
// DISPLAY BIN
//////////////////////////////////////////////////////////
// Bufor wyświetlacza BIN
typedef struct
{
uint8_t h08,h04,h02,h01;
uint8_t m32,m16,m08,m04,m02,m01;
} DisplayBuf;
volatile DisplayBuf g_DisplayBuf;
// ustaw bufor wyswietlacza BIN
void SetDisplayBin(uint8_t hour, uint8_t min)
{
g_DisplayBuf.h08 = ((hour & (1<<3))>>3);
g_DisplayBuf.h04 = ((hour & (1<<2))>>2);
g_DisplayBuf.h02 = ((hour & (1<<1))>>1);
g_DisplayBuf.h01 = (hour & (1<<0));
g_DisplayBuf.m32 = ((min & (1<<5))>>5);
g_DisplayBuf.m16 = ((min & (1<<4))>>4);
g_DisplayBuf.m08 = ((min & (1<<3))>>3);
g_DisplayBuf.m04 = ((min & (1<<2))>>2);
g_DisplayBuf.m02 = ((min & (1<<1))>>1);
g_DisplayBuf.m01 = (min & (1<<0));
}
// Ustaw wyświetlacz BIN
void ShowDisplayBin(void)
{
PORT(C) = ~(g_DisplayBuf.h01*_BV(H01) | g_DisplayBuf.h02*_BV(H02) |
g_DisplayBuf.h04*_BV(H04) | g_DisplayBuf.h08*_BV(H08));
PORT(D) = ~(g_DisplayBuf.m01*_BV(M01) | g_DisplayBuf.m02*_BV(M02) |
g_DisplayBuf.m04*_BV(M04) | g_DisplayBuf.m08*_BV(M08) |
g_DisplayBuf.m16*_BV(M16) | g_DisplayBuf.m32*_BV(M32));
}
// wyczyść wyświetlacz
void ClearDisplay(void)
{
PORT(C) = _BV(H01) | _BV(H02) | _BV(H04) | _BV(H08);
PORT(D) = _BV(M01) | _BV(M02) | _BV(M04) | _BV(M08) |
_BV(M16) | _BV(M32) | _BV(KEY);
}
//////////////////////////////////////////////////////////
// GLOBAL
//////////////////////////////////////////////////////////
volatile uint8_t g_Mode = DISP_MODE_TO_OFF;
volatile uint16_t g_BellMode = 0;
volatile uint8_t g_DisplaySec = 0;
volatile uint8_t g_DisplayBlink = 0;
volatile uint8_t g_DisplayPhase = 0;
volatile uint16_t g_DisplayDelay = 0;
//////////////////////////////////////////////////////////
// MAIN
//////////////////////////////////////////////////////////
int main(void)
{
//konfiguracja portów - wyjść
DDR(C) = _BV(H01) | _BV(H02) | _BV(H04) | _BV(H08);
DDR(D) = _BV(M01) | _BV(M02) | _BV(M04) | _BV(M08) | _BV(M16) | _BV(M32);
//wyłączenie komparatora analogowego (oszczędność prądu)
ACSR = _BV(ACD);
//ustawienie timera 0 do obsługi wyświetlacza
TIMSK = _BV(TOIE0); //Obsługa T/C
TCNT0 = 0x00;
TCCR0 = _BV(CS02); //prescaler/256
//ustawienie timera 2 do obsługi zliczania czasu z zewnętrznego kwarcu w trybie asynchronicznym
TIMSK |= _BV(TOIE2); //Obsługa T/C Overflow Interrupt Enable
ASSR = _BV(AS2);
TCNT2 = 0x00;
TCCR2 = _BV(CS22) | _BV(CS21); //prescaler/256 -2sek
//umożliwienie usypiania
MCUCR = _BV(SE);
//czas początkowy
g_CurrTime.Sec=0;
g_CurrTime.Min=0;
g_CurrTime.Hour=12;
g_DispTime = g_CurrTime;
//wartość korekcji czasu
g_CorrectionValue=eeprom_read_byte(&CorrectionValue);
if(g_CorrectionValue>15) g_CorrectionValue=0;
ClearDisplay();
//globalne zezwolenie na przerwania
sei();
for(;;)
{
//obsługa klawisza
if(!(PIN(D) & _BV(KEY))) //czy wcisniety
{
_delay_ms(10);
//jednak wcisciety
if(!(PIN(D) & _BV(KEY)))
{
//wyzeruj czas wcinięcia
g_DisplayDelay = 0;
//nadal wciśnięty
while (!(PIN(D) & _BV(KEY)))
{
_delay_ms(10);
//tryb mrugania co minutę
if((DISP_MODE_SET==g_Mode)&&(g_DisplayDelay>=STEP_DELAY))
{
if(g_BellMode>0)
SetDisplayBin(0,0);
else
SetDisplayBin(15,63);
}
else
//tryb korekcji
if((DISP_MODE_SETH==g_Mode)&&(g_DisplayDelay>=CORRECTION_DELAY))
{
SetDisplayBin(g_CorrectionValue,SYMB_CR);
}
else
//inne tryby ustawień
if(g_DisplayDelay>=STEP_DELAY)
{
if(DISP_MODE_SETH==g_Mode) SetDisplayBin(g_DispTime.Min,SYMB_HI);
if(DISP_MODE_SETM==g_Mode) SetDisplayBin(g_DispTime.Sec,SYMB_LO);
if(DISP_MODE_SETN==g_Mode)
{
g_DisplayBlink = 0;
SetDisplayBin(g_DispTime.Hour,g_DispTime.Min*10+g_DispTime.Sec);
}
if(DISP_MODE_SETC==g_Mode)
{
g_DisplayBlink = 0;
SetDisplayBin(g_DispTime.Hour,SYMB_CR);
}
}
}
//zwolniony
switch(g_Mode)
{
case DISP_MODE_BIN: if(g_DisplayDelay<STEP_DELAY) g_Mode=DISP_MODE_POV;
else g_Mode=DISP_MODE_TO_OFF;
break;
case DISP_MODE_BIN2: g_Mode=DISP_MODE_TO_OFF;
break;
case DISP_MODE_POV: if(g_DisplayDelay<STEP_DELAY) g_Mode=DISP_MODE_SET;
else g_Mode=DISP_MODE_TO_OFF;
break;
case DISP_MODE_SET: if(g_DisplayDelay<STEP_DELAY)
{
//przejdź do trybu ustawiania godzin
g_DisplayBlink = 1;
g_Mode=DISP_MODE_SETH;
SetDisplayBin(g_DispTime.Hour,0);
//przelicz na jedności(Sec) i dziesiątki minut(Min)
g_DispTime.Sec=g_DispTime.Min%10;
g_DispTime.Min=g_DispTime.Min/10;
}
else
if(g_DisplayDelay>=STEP_DELAY)
{
//przełącz tryb mrugania co minutę
if(g_BellMode>0)
g_BellMode = 0;
else
g_BellMode = BELL_2SECONDS;
g_Mode=DISP_MODE_TO_OFF;
}
break;
case DISP_MODE_SETH: if(g_DisplayDelay<STEP_DELAY)
{
//inkrementuj godzinę
g_DispTime.Hour++;
if(g_DispTime.Hour>12) g_DispTime.Hour=1;
SetDisplayBin(g_DispTime.Hour,0);
}
else
if(g_DisplayDelay>=CORRECTION_DELAY)
{
//przełącz w tryb ustawiania korekcji czasu
g_Mode=DISP_MODE_SETC;
g_DispTime.Hour=g_CorrectionValue;
SetDisplayBin(g_DispTime.Hour,SYMB_CR);
}
else
{
//przełącz w tryb ustawiania dziesiatek minut
g_Mode=DISP_MODE_SETM;
SetDisplayBin(g_DispTime.Min,SYMB_HI);
}
break;
case DISP_MODE_SETM: if(g_DisplayDelay<STEP_DELAY)
{
//inkrementuj dziesiątki minut
g_DispTime.Min++;
if(g_DispTime.Min>5) g_DispTime.Min=0;
SetDisplayBin(g_DispTime.Min,SYMB_HI);
}
else
{
//przełącz w tryb ustawiania jedności minut
g_Mode=DISP_MODE_SETN;
SetDisplayBin(g_DispTime.Sec,SYMB_LO);
}
break;
case DISP_MODE_SETN: if(g_DisplayDelay<STEP_DELAY)
{
//inkrementuj jedności minut
g_DispTime.Sec++;
if(g_DispTime.Sec>9) g_DispTime.Sec=0;
SetDisplayBin(g_DispTime.Sec,SYMB_LO);
}
else
{
//ustaw obowiązujący czas
g_DispTime.Min=g_DispTime.Min*10+g_DispTime.Sec;
g_DispTime.Sec=0;
g_CurrTime=g_DispTime;
g_Mode=DISP_MODE_TO_OFF;
}
break;
case DISP_MODE_SETC: if(g_DisplayDelay<STEP_DELAY)
{
//inkrementuj zmienną pomocniczą korekcji
g_DispTime.Hour++;
if(8==g_DispTime.Hour) g_DispTime.Hour==9;
if(g_DispTime.Hour>15) g_DispTime.Hour=0;
SetDisplayBin(g_DispTime.Hour,SYMB_CR);
}
else
{
//ustaw obowiązującą wartość korekcji
if(g_CorrectionValue!=g_DispTime.Hour)
{
g_CorrectionValue=g_DispTime.Hour;
eeprom_write_byte(&CorrectionValue,g_CorrectionValue);
}
g_DispTime = g_CurrTime;
g_Mode=DISP_MODE_TO_OFF;
}
break;
}
}
}
//obsługa zwłoki (czy za długo nic się nie dzieje?)
switch(g_Mode)
{
case DISP_MODE_POV: if(g_DisplayDelay>POV_DELAY) g_Mode=DISP_MODE_TO_OFF; break;
case DISP_MODE_BIN2:
case DISP_MODE_SET: if(g_DisplayDelay>SET_DELAY) g_Mode=DISP_MODE_TO_OFF; break;
case DISP_MODE_BIN:
case DISP_MODE_SETH:
case DISP_MODE_SETM:
case DISP_MODE_SETN:
case DISP_MODE_SETC: if(g_DisplayDelay>LONG_DELAY) g_Mode=DISP_MODE_TO_OFF; break;
}
//przygotowanie do uśpienia
if(DISP_MODE_TO_OFF==g_Mode)
{
//ustawinie obsługi przerwania Int0...
GICR = _BV(INT0);
//zgaszenie wyświetlacza
ClearDisplay();
g_DisplaySec = 0;
g_DisplayBlink = 0;
g_Mode=DISP_MODE_OFF;
}
//przejście w uśpienie
if(DISP_MODE_OFF==g_Mode)
{
set_sleep_mode(SLEEP_MODE_PWR_SAVE);
sleep_mode();
}
}
return 0;
}
//////////////////////////////////////////////////////////
// SIGNAL
//////////////////////////////////////////////////////////
// Przycisk
SIGNAL(SIG_INTERRUPT0)
{
if(DISP_MODE_OFF==g_Mode)
{
//wyłączenie obsługi przerwania INT0
GICR = 0;
//obliczenie czasu do wyświetlenia
g_DispTime = g_CurrTime;
SetDisplayBin(g_DispTime.Hour,g_DispTime.Min);
SetDisplayPov(g_DispTime.Hour,g_DispTime.Min);
//przełączenie na wyświetlanie BIN
g_DisplayDelay = 0;
g_Mode = DISP_MODE_BIN;
}
}
// Wyświetlanie
SIGNAL(SIG_OVERFLOW0)
{
//wartość początkowa
TCNT0 = 249;
//inkrementacja dla obsługi klawiatury
if(DISP_MODE_OFF!=g_Mode)
g_DisplayDelay++;
//tryb widmowy POV
if(DISP_MODE_POV==g_Mode)
{
ClearDisplay();
ShowDisplayPov();
}
//tryb binarny (wyświetlania i nastawiania)
if(DISP_MODE_BIN==g_Mode ||
DISP_MODE_BIN2==g_Mode ||
DISP_MODE_SET==g_Mode ||
DISP_MODE_SETH==g_Mode ||
DISP_MODE_SETM==g_Mode ||
DISP_MODE_SETN==g_Mode ||
DISP_MODE_SETC==g_Mode)
{
g_DisplayPhase++;
if(0==g_DisplayBlink || g_DisplayPhase<=BLINK_DELAY)
{
//pojedyncze mignięcie co 2 sekundy
if(g_DisplaySec>0)
{
g_DisplaySec = 0;
PORT(C) = 0;
PORT(D) = _BV(KEY);
}
//wyświetlanie czasu
else
{
ShowDisplayBin();
}
}
//przerwa w wyświetlaniu (mruganie w trybie ustawiania)
else
{
ClearDisplay();
}
}
}
// Zliczanie czasu
SIGNAL(SIG_OVERFLOW2)
{
//inkrementacja bieżącego czasu
g_CurrTime.Sec+=SECOND_TO_ADD;
if(g_CurrTime.Sec>=60)
{
g_CurrTime.Sec=g_CurrTime.Sec-60;
g_CurrTime.Min++;
}
if(g_CurrTime.Min>=60)
{
g_CurrTime.Min=g_CurrTime.Min-60;
g_CurrTime.Hour++;
}
if(g_CurrTime.Hour>12)
{
g_CurrTime.Hour=g_CurrTime.Hour-12;
}
//korekcja czasu
g_CurrTime.Sec+=CalculateCorrectionTime();
//ustawienie aktualnego czasu dla wyświetlacza w trybie BIN
if(((DISP_MODE_BIN==g_Mode)||(DISP_MODE_BIN2==g_Mode))&&
(g_CurrTime.Min!=g_DispTime.Min))
{
g_DispTime = g_CurrTime;
SetDisplayBin(g_DispTime.Hour,g_DispTime.Min);
}
//tryb mrugania co minutę
if(g_BellMode>0)
{
g_BellMode--;
if((DISP_MODE_OFF==g_Mode)&&((0==g_CurrTime.Sec)||(1==g_CurrTime.Sec)||
(15==g_CurrTime.Sec)||(16==g_CurrTime.Sec)||
(30==g_CurrTime.Sec)||(31==g_CurrTime.Sec)||
(45==g_CurrTime.Sec)||(46==g_CurrTime.Sec)))
{
g_DispTime = g_CurrTime;
SetDisplayBin(g_DispTime.Hour,g_DispTime.Min);
g_Mode = DISP_MODE_BIN2;
g_DisplayDelay = 0;
GICR = 0;
}
}
//ustawienie mrugnięcia co 2 sek
if(DISP_MODE_BIN==g_Mode ||
DISP_MODE_BIN2==g_Mode ||
DISP_MODE_SET==g_Mode)
{
g_DisplaySec = 1;
}
}
//////////////////////////////////////////////////////////
// KONIEC
//////////////////////////////////////////////////////////
[/syntax]
źródło
http://elportal.pl/ftp_05/201107avt2983.zipStatystyki: Napisane przez miszczo — 26 kwi 2012, o 18:34
]]>
