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

Stap 7: Het Display Prototyping en tijdinstelling

Hiervoor gebruiken we een enkelpolige dubbel gooien (SPDT) switch, of een "op - op" switch. De middelste leiding aan analoge input A2, één van de buiten leidt tot op de grond, en de andere buiten voorsprong naar 5V koppelen. De analogRead(A2) methode moet nu retourneren 0 of 1023 wanneer de schakelaar is van een knevel gevoorzid heen en weer.

Zullen we willen de gebruiker visueel te vertellen ze in de tijdweergave instelling met een LED. De Uno heeft slechts 14 digitale pinnen, en aangezien wij allen van hen (13 voor de LEDs tijd), en 1 pin al voor de PWM die zal worden gebruikt op de analoge meter gebruikt, kunnen wij gelukkig een analoge pin draaien in een digitale uit pin! Bel gewoon pinMode (A5, OUTPUT) A5 gebruiken als een digitale uitgang pin.

We zullen moeten controleren als we in de tijdinstelling of tijd-weergeven modus aan het begin van de loop-methode. We zetten deze logica in een methode genaamd checkMode().

Nu u een binaire klok die houdt van tijd hebben, en kan handmatig worden ingesteld door de gebruiker!

De volledige Code tot nu toe
/*
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, voorziet 12 en 13, in tijd
instellen met opdracht potentiometers, en kan worden toggled tussen tijd
instellen van de modus en tijd display mode.

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

int HOUR_INPUT_PIN = A0;
int MIN_INPUT_PIN = a1 worden verkregen;
int CLOCK_MODE_SWITCH_PIN = A2;
int CLOCK_MODE_LED_PIN = A5;

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
{
met behulp van één van de analoge ingangen als output
pinMode (CLOCK_MODE_LED_PIN, uitvoer);

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 (2, 18, 0);
}

de routine van de lus wordt uitgevoerd over en weer forever:
void loop
{
checkMode();

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_hour, m_minute en m_second 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()
{
Lees de potentiometers
int hourSensor = analogRead(HOUR_INPUT_PIN);
int minuteSensor = analogRead(MIN_INPUT_PIN);

schaal van de lezingen (van 0 tot 1023) naar de juiste schaal (0 tot en met 23 uur, 0 tot en met 59 minuten)
setTime (kaart (hourSensor, 0, 1023, 0, 23), kaart (minuteSensor, 0, 1023, 0, 59), 0);

We stellen de laatste teek op nu, omdat wanneer wij m_inTimeSetMode ingesteld op false,
kunnen veel seconden zijn verstreken sinds de laatste keer, en de tijd vooruit zou springen
m_lastTick = millis();
}

/**
* Deze methode controleert u CLOCK_MODE_SWITCH_PIN om te zien of het hoge. Als het is,
* het betekent dat we nu in de modus voor het instellen van klok (m_inTimeSetMode is ingesteld op true), en
* Hiermee schakelt u de CLOCK_MODE_LED_PIN.
*/
VOID checkMode()
{
m_inTimeSetMode = (analogRead(CLOCK_MODE_SWITCH_PIN) > 512);
digitalWrite (CLOCK_MODE_LED_PIN, m_inTimeSetMode);
}