DIY Apple klockan (2 / 10 steg)

Steg 2: Prototyper och filer!

Om du bara vill bygga projektet detta steg är inte alltför nödvändigt. Jag kommer att tala om hur koden och hårdvara fungerar.

Jag kommer att gå igenom koden rad för rad nu :D

#include "avr/interrupt.h" //We använder pin change avbryter

ATtiny24, 44, 84 serien bara har 1 yttre mellanjobb (INT0) [Page 48 i databladet]. Detta är avbrottet som vi är mest vana att på Arduino. Du kan enkelt använda denna avbrott genom att säga "attachInterrupt()"

Även om det bara hade 1 avbrott, jag ville ha två knappar på min klocka: en knapp för att öka tiden och en annan för att minska tid. Ser tillbaka på databladet, ATtiny har två Pin Change Interrupt portar: PCINT0 och PCINT1 [Page 48].

Skillnaden mellan Externa avbryter och Pin Change avbryter är att externa avbrott har sin egen ISR (avbrottstjänstens rutin). PCINTerrupts delar en ISR för alla stift på en port. Detta innebär att med Pin Change avbryter kan vi göra någon pin vara ett avbrott, men då måste vi gå igenom besväret att bestämma vilken pin orsakade avbrottet på porten.

Här är två riktigt bra artiklar att läsa. Detta är hur jag lärde mig:

• http://thewanderingengineer.com/2014/08/11/Arduino... PCINT i allmänhet
• http://thewanderingengineer.com/2014/08/11/PIN-Cha... PCINT på ATtiny

flyktiga int dig1 = 0; Timmar TEN
flyktiga int dig2 = 0; Timmar som
flyktiga int dig3 = 0; Minuter TEN
flyktiga int dig4 = 0; Minuter som

Var och en av dessa variabler avgör vilket nummer som visas på varje av de fyra siffrorna på bubblan displayen.
Jag förklarade dem flyktiga eftersom de kommer att ändras i rutinerna som avbrott.
Ställa dem till 0 betyder när jag slår på min klocka, startar räkningen på 00:00 (12:00 AM).

CONST int latchPin = A3; PIN ansluten till ST_CP av 74HC595
CONST int clockPin = A4; PIN ansluten till SH_CP av 74HC595
CONST int dataPin = A5; PIN ansluten till DS för 74HC595

Fysiska stift 8(A5), 9(A4) och 10(A3) kommer att användas med 74HC595 SKIFT register.
Skiftregister ger oss möjlighet till kontroll segment, b, c, d, e, f, g och dp med stift Q0, Q1, Q2, Q3, Q4, Q5, F6 och F7.
Om du vill visa varje siffra, kommer vi multiplexing.

CONST int dig1Pin = A0; Stift för att multiplex och Visa digit1
CONST int dig2Pin = A1; Stift för att multiplex och Visa digit2
CONST int dig3Pin = A2; Stift för att multiplex och Visa digit3
CONST int dig4Pin = A6; Stift för att multiplex och Visa digit4

Bubbla displayen är gemensamma katod. Detta innebär att när siffran är jordad eller drog till en digital låg, siffran tänds. Vi kommer att använda fysiska stift 13(A0), 12(A1), 11(A2) och 7(A6) att styra visningen av varje siffra på bubblan displayen.

Två värden nedan för debouncing.
volatile osignerade långa xlastDebounceTime = 0;
volatile osignerade långa ylastDebounceTime = 0;
lång debounceDelay = 150; debounce tiden; öka om utdata flimrar

Detta är vissa värden som vi kommer att använda till Dämpningstid de två knapparna när avbrottet är aktiverad. En knapptryckning kunde registreras som fem utan debouncing, och med hjälp av klocka skulle vara irriterande.
Kontrollera ut Arduino exempel/Digital/Debounce om du vill.

Vi kommer att använda detta värde för att förhindra rolloever för millis() som uppstår varje 49 dagar.
osignerade långa currentMillis = 0;
volatile osignerade långa lastMillis = 0;

Arduino kan hålla långa variabler. Jag kommer att använda långa variablerna currentMillis och lastMillis för att läsa millis(); Efter 49 dagar, kommer att värdet av millis() få för stor för mikrokontroller och spill till 0.
Detta är en dålig sak om jag jämför currentMillis och lastMillis till Dämpningstid och värdet av currentMillis blir 0. Jag ska förklara lite mer senare.

int secTime = 0; Räknaren sekunder
byte tictoc = 0; Blinkande prick

Initierar några grejer. secTime räknaren sekunder och tictoc avgör om du vill visa pricken eller inte varje sekund.

void setup()
{
pinMode (latchPin, produktionen);
pinMode (clockPin, produktionen);
pinMode (dataPin, produktionen);
pinMode (dig1Pin, produktionen);
pinMode (dig2Pin, produktionen);
pinMode (dig3Pin, produktionen);
pinMode (dig4Pin, produktionen);
CLI(); inaktiverar avbrotten
GIMSK | = 0b00110000; slå på pin change avbryter
PCMSK0 | = 0b10000000; Aktivera avbrott på PCINT7(A7)
PCMSK1 | = 0b00000100; Aktivera avbrott på PCINT10(8)
SEI(); vänder avbryter tillbaka på
}

I setup-funktionen, kommer jag att förklara SKIFT register stiften och multiplexing pins som resultat

Följande är hur du initierar Pin Change avbryter.
CLI(); är en funktion vi behöva ringa inaktivera avbrott.

GIMSK är den Allmänna avbryta Mask registrera, ett register över ATtiny. Kolla sidan 51 i databladet att titta på vad varje bit av GIMSK registret gör.
0b00110000 vänder på 4 och 5 bitar i registret, som slå på PCIE0 och PCIE1. PCIE0 aktiverar Pin Change avbryter för den port som har stift 0 till 7. PCIE1 aktiverar Pin Change avbryter för den del som har stift 8 till 11.

PCMSK0 är Pin Change aktiverar Mask för stiften 0 till 7. Detta aktiveras från PCIE0. Jag vill aktivera ett avbrott på PCINT7 eller A7 på ATtiny44.
För att göra detta jag aktivera bit 7: 0b10000000 [Page 53]

PCMSK1 är samma som PCMSK0 förutom stift 8 till 11. Detta aktiveras från PCIE1. Jag vill aktivera ett avbrott på PCINT10 eller pin-8.
Det gör jag möjliggöra den 2: a lite: 0b00000100 [Page 52]

SEI(); vänder på avbrotten.

void loop()
{
Display(dig1,dig2,dig3,dig4); Visa alla siffror

//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
Denna del växlar pricken varje sekund
currentMillis = millis();
om ((unsigned long) (currentMillis - lastMillis) > = 1000)
{
secTime ++; Med användning av detta om loop för att öka andra
IF(tictoc == 1)
{
dig2 = dig2 - 10.
tictoc = 0;
}
annat
{
dig2 = dig2 + 10.
tictoc = 1;
}
lastMillis = millis();
}
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////

Display() är en funktion som jag kommer att förklara i nästa steg. Det gör bara vad du tror att den gör.

Fästet i koden växlar i grunden pricken på displayen 2 någonsin andra till simulera tics och innehållsförteckningar.
I grund och botten var 1000 millisekunder, koden kontrolleras om tictoc är 1 eller 0. Om det är 0, det sätter pricken på och tictoc till 1. Om det är 1, det släcks pricken och tictoc till 0.
de + 10 och -10 kommer vettigt senare
I detta fäste ingår också en ökning för secTime, som räknar hur många sekunder har gått.

//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
Denna del gör räkna på klockan.
IF(secTime == 60)
{
secTime = 0;
dig4 ++;
IF(dig4 == 10)
{
dig4 = 0;
dig3 ++;
IF(dig3 == 6)
{
dig3 = 0;
dig2 ++;
IF(dig2 == 10)
{
dig2 = 0;
dig1 ++;
IF(dig1 == 3)
{
dig1 = 0;
}
}
}
}
}
om (dig1 == 2 & & dig2 == 4)
{
dig1 = 0;
dig2 = 0;
}
Den om loopar ovan bara berätta när siffrorna bör återställa eller rulla över
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
}

Om secTime når 60, vi öka dig4 (minuter)

Följande om loopar i princip avgöra när siffran svämmar över och ska återställas. Till exempel om vi har 9 på dig4, nästa ska vara 0 och dig2 bör ökas stegvis med 1.

Om dig1 (tiotals timmar) är 2 och dig2 (timmar de) är 4, vi återställa klockan 00.

/***********************************************************************/
Nedan är pin ändringen avbryta funktioner

//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
Kör om A7 skjuts
ISR(PCINT0_vect)
{
secTime = 0; Göra sekunder 0
IF(tictoc == 1) //Set dot till 0 så att vi inte är förvirrad
{
dig2 = dig2 - 10.
tictoc = 0;
}
currentMillis = millis();
om ((unsigned long) (currentMillis - xlastDebounceTime) > = debounceDelay)
{
dig4--;
om (dig4 == -1)
{
dig4 = 9;
dig3--;
om (dig3 == -1)
{
dig3 = 5;
dig2--;
om (dig2 == -1)
{
dig2 = 9;
dig1--;
om (dig1 == -1)
{
dig1 = 2;
}
}
}
}
Ovanstående var, igen, mer om loopar för siffra overflow och sånt.

Nedan hanterar problemet med kommer att 29 i stället för 00 när du säkerhetskopierar.
om (dig1 == 2 & & dig2 == 9)
{
dig2 = 3;
}
xlastDebounceTime = millis();
}
}
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////

ISR(PCINT0_vect) {} är avbrott rutin som körs när PCINT0 aktiveras genom pin A7.
Den här funktionen anger i princip secTime till 0 och minskar dig4 av 1.
Följande om loopar i princip hantera overflow.
Hela funktionen slås av en debouncing om loop.

//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
Kör om 8 skjuts
ISR(PCINT1_vect)
{
secTime = 0; Göra sekunder 0
IF(tictoc == 1) //Set dot till 0 så att vi inte är förvirrad
{
dig2 = dig2 - 10.
tictoc = 0;
}
currentMillis = millis();
om ((unsigned long) (currentMillis - ylastDebounceTime) > = debounceDelay)
{
dig4 ++;
IF(dig4 == 10)
{
dig4 = 0;
dig3 ++;
IF(dig3 == 6)
{
dig3 = 0;
dig2 ++;
IF(dig2 == 10)
{
dig2 = 0;
dig1 ++;
IF(dig1 == 3)
{
dig1 = 0;
}
}
}
}
Ovanstående var, igen, mer om loopar för siffra overflow och sånt.

Nedan hanterar problemet med kommer att 24 istället för 00 när du går framåt.
om (dig1 == 2 & & dig2 == 4)
{
dig1 = 0;
dig2 = 0;
}
ylastDebounceTime = millis();
}
}

ISR(PCINT1_vect) {} är avbrott rutin som körs när PCINT1 aktiveras genom stift 8.
Detta gör i princip samma sak som på andra avbryta utom ökning i stället för att minska.

Detta är vad som händer i WATCHG.ino skissen. För att hålla ordning, gjorde jag en annan skiss ShiftDatas.ino att hålla vissa variabler och funktioner. Vi kommer att gå över som i nästa steg.