Cwik klok v1.0 - An Arduino Binary Clock (4 / 15 stap)

Stap 4: Programmeren van de klok

In deze stap maken we een programma om te worden geüpload naar de ATmega microcontroller op het bord van de Arduino Uno. Het programma zal de macht de 13 vereist LEDs om weer te geven van een 24-uurs klok in binaire. In latere stappen, zullen we ons zorgen maken over het instellen van de tijd, maar voor nu zal het altijd begint om 00:00.

Programmastructuur
Arduino programma's hebben 2 belangrijkste methoden; een methode die één keer aan het begin waar initialisatie wordt gedaan (de zogenaamde setup), en een andere methode die wordt aangeroepen continu wordt uitgevoerd (de zogenaamde lus).

In Setup, we de tijd ingesteld op 00:00, en instellen welke pinnen rijden de 13 LEDs gaat.

In loop zullen we zien als meer dan een seconde is verstreken (en als dat zo is, Verhoog de tijd), dan de tijd weergeven door het voeden van de juiste LED's. De millis() methode is instrumentaal tot het houden van de tijd. Het geeft als resultaat het aantal milliseconden dat is verstreken zijn sinds het circuit werd aangedreven als een unsigned long. "Unsigned" betekent dat het niet negatief, en lange zijn zal verwijst naar hoeveel bits (32 om precies te zijn) worden gebruikt voor het bijhouden van dit nummer (bits worden gebruikt voor het aantal binaire getallen).

De gril met millis()
Aangezien er een eindig aantal bits in een niet-ondertekende lang, op een gegeven moment gaan we opraken van cijfers! Volgens de Arduino documentatie over millis(), het zal teruglopen (ie, weer terug op nul gezet) na ongeveer 50 dagen. Hoe vervelend dat zou dat opnieuw instellen van uw klok om 50 dagen? Als een van de doelen Staten, we streven naar functionele perfectie en dit onderbrekende gedrag is onaanvaardbaar. Dus, de logica in onze tick()-methode wordt gebruikt om te zien wanneer we teruglopen en blijven zonder dat iemand wordt wijzer.

Pin-toewijzingen
Voordat we springen rechts in en beginnen met het toewijzen van digitale pinnen, zullen we een PWM (pulsbreedte gemoduleerd) pin voor weergave van de seconden op de analoge meter in een latere stap vereist. Op de Arduino Uno, pinnen 3, 5, 6, 9, 10 en 11 zijn ingeschakeld voor PWM (zoals aangegeven door de "~"). Ik ben dus pin 11 voor de analoge weergave opslaan en met behulp van pennen 0 - 10, 12 & 13 voor de binaire LED-display.

De code
/*
Cwik klok v1.0 - Prototyping het Display
Auteur: Dennis Cwik
Datum: 23 juli 2012

Dit programma is de controller voor een binaire klok, met LEDs
gekoppeld aan digitale pinnen 0 t/m 10, 12 en 13.

Deze voorbeeldcode is in het publieke domein.
*/

Dit kan worden gewijzigd voor debug doeleinden te maken een minuut sneller door.
int ONE_SECOND = 1000; gemeten in milliseconden
int DELAY_BETWEEN_LOOP_CALLS = 200; gemeten in milliseconden

Ik kom niet met dit, het is uit de arduino-documentatie
unsigned long MAX_UNSIGNED_LONG = 4294967295; = (2 ^ 32) - 1

1e kolom voor LEDs
int PIN_MIN1 = 0;
int PIN_MIN2 = 1;
int PIN_MIN4 = 2;
int PIN_MIN8 = 3;

2e kolom voor LEDs
int PIN_MIN10 = 4;
int PIN_MIN20 = 5;
int PIN_MIN40 = 6;

3e kolom voor LEDs
int PIN_HOUR1 = 7;
int PIN_HOUR2 = 8;
int PIN_HOUR4 = 9;
int PIN_HOUR8 = 10;

4e kolom voor LEDs
int PIN_HOUR10 = 12;
int PIN_HOUR20 = 13;

de laatste keer de seconden in de tijd werden verhoogd
unsigned long m_lastTick;

gebruikt om ons te vertellen als we de tijd, of niet instelt
Boole m_inTimeSetMode = false;

de tijd
byte m_second;
byte m_minute;
byte m_hour;

de setup-routine wordt uitgevoerd zodra wanneer u drukt op reset
VOID Setup
{
initialiseren van de pinnen gebruikt voor de uitvoer van tijd als OUTPUT
pinMode (PIN_MIN1, uitvoer);
pinMode (PIN_MIN2, uitvoer);
pinMode (PIN_MIN4, uitvoer);
pinMode (PIN_MIN8, uitvoer);
pinMode (PIN_MIN10, uitvoer);
pinMode (PIN_MIN20, uitvoer);
pinMode (PIN_MIN40, uitvoer);

pinMode (PIN_HOUR1, uitvoer);
pinMode (PIN_HOUR2, uitvoer);
pinMode (PIN_HOUR4, uitvoer);
pinMode (PIN_HOUR8, uitvoer);
pinMode (PIN_HOUR10, uitvoer);
pinMode (PIN_HOUR20, uitvoer);

clock-variabelen initialiseren
m_lastTick = 0;
setTime (0, 0, 0);
}

de routine van de lus loopt over en weer forever
void loop
{
Als we de tijd instellen, of tijd stroom normaal laten zien
Als (m_inTimeSetMode)
{
getTimeFromPots();
}
anders
{
Tick();
}

nu dat het tijd is vernieuwd, de tijd weergeven
displaySeconds();
displayMinutes();
displayHours();

willekeurige vertragen zodat we niet weg 100% van de tijd, zijn verwerkt
een daad van energiebesparing
delay(DELAY_BETWEEN_LOOP_CALLS);
}

/**
* Een helper-methode om het m_second, m_minute en m_hour instellen.
*/
VOID setTime (byte newHour, byte newMinute, byte newSecond)
{
m_second = newSecond;
m_minute = newMinute;
m_hour = newHour;
}

/**
* Deze methode houdt spoor van de logische stroom van de tijd.  Als u genoeg tijd heeft
* verstreken sinds de laatste keer dat het werd geroepen, m_second, m_minute en m_hour
* zal nodig worden bijgewerkt. Dit houdt rekening met die millis() rolt
* over ongeveer elke 50 dagen.
*/
VOID tick()
{
niet-ondertekende lang = millis();
unsigned long msElapsed;

Allereerst moeten we erachter te komen hoeveel tijd is verstreken sinds de laatste keer dat we
genaamd tick()
Als (nu < m_lastTick)
{
zucht, ofwel heb gelukt om terug in de tijd, of millis() gewikkeld rond reizen!
msElapsed = (MAX_UNSIGNED_LONG - m_lastTick) + nu;
}
anders
{
msElapsed = nu - m_lastTick;
}

voor elke seconde dat verstreken (hopelijk slechts 1, tenzij onze code echt laggy is),
toevoegen van 1 seconde de tijd en de minuten & uren indien nodig verhoogd.
for (int i = 0; ik < msElapsed / ONE_SECOND; ++ ik)
{
m_lastTick = m_lastTick + ONE_SECOND;

++ m_second;
Als (m_second == 60)
{
m_second = 0;
++ m_minute;
Als (m_minute == 60)
{
m_minute = 0;
++ m_hour;
Als (m_hour == 24)
{
m_hour = 0;
}
}
}
}
}

VOID displaySeconds()
{
TODO de analoge weergave bepalen
}

/**
* Deze methode leest de variabele m_minute, wordt het geconverteerd naar een binair getal worden omgezet en
* het op de juiste LEDs (degenen die PIN_MIN *).
*/
VOID displayMinutes()
{
byte degenen = m_minute % 10;
digitalWrite (PIN_MIN1, degenen & B1);
digitalWrite (PIN_MIN2, degenen & B10);
digitalWrite (PIN_MIN4, degenen & B100);
digitalWrite (PIN_MIN8, degenen & B1000);

divisie is soort duur, maar we gaan ervan uit dat het compileren optimaliseert dit voor ons :)
byte tientallen = m_minute / 10;
digitalWrite (PIN_MIN10, trans-Europese netwerken & B1);
digitalWrite (PIN_MIN20, trans-Europese netwerken & B10);
digitalWrite (PIN_MIN40, trans-Europese netwerken & B100);
}

/**
* Deze methode leest de variabele m_hour, wordt het geconverteerd naar een binair getal worden omgezet en
* het op de juiste LEDs (degenen die PIN_HOUR *).
*/
VOID displayHours()
{
byte degenen = m_hour % 10;
digitalWrite (PIN_HOUR1, degenen & B1);
digitalWrite (PIN_HOUR2, degenen & B10);
digitalWrite (PIN_HOUR4, degenen & B100);
digitalWrite (PIN_HOUR8, degenen & B1000);

byte tientallen = m_hour / 10;
digitalWrite (PIN_HOUR10, trans-Europese netwerken & B1);
digitalWrite (PIN_HOUR20, trans-Europese netwerken & B10);
}

/**
* Deze methode leest de waarden van de 2 potentiometers, zet hen aan
* mimnutes en uren, en reeksen m_minute en m_hour naar de bijbehorende waarden.
*/
VOID getTimeFromPots()
{
TODO Lees de potentiometers, stelt u het uur en de minuten
}