Cwik klocka v1.0 - An Arduino binär klocka (9 / 15 steg)

Steg 9: Prototyping displayen, tidsinställning och sekunder

Nu när vi har det bas programmet för att köra en binär klocka, know-how att läsa från potentiometrar och är experter på att använda amperemetrar, är det dags att sätta ihop allt! Det kan se ut som en råtta boet av kablar och komponenter, men du bör inte ha några problem om du följa med steg för steg.

I följande video använder jag växeln reset på Uno för att starta vårt program från början (tid 00:00). Du kan se de sekunder räknar den analog mätare som tyvärr har ett max värde på 50, inte 60 (men vi kan öppna upp och byta ut bakgrunden om så önskas). Oavsett vad mätaren läser, fästingar det"" 60 gånger per minut. Efter en hel minut, vi ser tiden ändra till 00:01 och analog mätare återställs. Jag senare byta i tid inställningsläge (detta är när orange lampan i mitten längst upp vänder), på vilken punkt du kan se sekunderna återställs till 0. Jag inställd på tiden 16:59, och det ögonblick jag slår tiden inställningsläget off (orange lampan i mitten längst upp stängs av), understöder på analog mätare börja räkna igen. Jag sedan vänta ytterligare en minut, varvid tidpunkten ändras till 17:00.

Den Final koden
/*
Cwik klocka v1.0 - prototyper displayen
Författare: Dennis Cwik
Datum: Juli 23, 2012

Detta program är registeransvarige för en binär klocka, med lysdioder
kopplade till digital stift 0 till 10, 12 och 13. 2 potentiometrar
ansluten till A0 och A1 kontroll timmar och minuter respektive
och endast när A2 dras hög. När A2 dras hög, en lysdiod på
PIN A5 tänds upp för att tala om för användaren att de är i tid inställda läge.
Slutligen, stift 11 används med PWM till att Visa sekunderna på en analog
amperemeter.

Denna exempelkod är offentlig.
*/

Detta kan ändras för debug ändamål att göra en minut gå snabbare.
int ONE_SECOND = 1000; mäts i millisekunder
int DELAY_BETWEEN_LOOP_CALLS = 200. mäts i millisekunder

Jag kom inte med detta, det är från arduino dokumentationen
osignerade långa MAX_UNSIGNED_LONG = 4294967295; = (2 ^ 32) - 1

int HOUR_INPUT_PIN = A0;
int MIN_INPUT_PIN = A1;
int CLOCK_MODE_SWITCH_PIN = A2;
int CLOCK_MODE_LED_PIN = A5;

1: a kolumnen av lysdioder
int PIN_MIN1 = 0;
int PIN_MIN2 = 1;
int PIN_MIN4 = 2;
int PIN_MIN8 = 3;

2: a kolumnen av lysdioder
int PIN_MIN10 = 4;
int PIN_MIN20 = 5;
int PIN_MIN40 = 6;

3: e kolumnen av lysdioder
int PIN_HOUR1 = 7.
int PIN_HOUR2 = 8;
int PIN_HOUR4 = 9;
int PIN_HOUR8 = 10;

PWM på analog mätare att Visa sekunder.
int SEC_OUTPUT_PIN = 11;

4: e kolumn med lysdioder
int PIN_HOUR10 = 12;
int PIN_HOUR20 = 13.

sista gången sekunderna i tiden var ökas
osignerade långa m_lastTick;

brukade berätta för oss om vi ställer tiden eller inte
booleska m_inTimeSetMode = false;

tid
byte m_second;
byte m_minute;
byte m_hour;

/**
* Obligatorisk setup rutin för Arduino, körs en gång alldeles i början.
*/
void setup()
{
med en av de analoga ingångarna som utdata
pinMode (CLOCK_MODE_LED_PIN, OUTPUT);

initiera stiften används för utskrift av tid
pinMode (PIN_MIN1, OUTPUT);
pinMode (PIN_MIN2, OUTPUT);
pinMode (PIN_MIN4, OUTPUT);
pinMode (PIN_MIN8, OUTPUT);
pinMode (PIN_MIN10, OUTPUT);
pinMode (PIN_MIN20, OUTPUT);
pinMode (PIN_MIN40, OUTPUT);

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

initiera klocka variabler
m_lastTick = 0;
setTime (0, 0, 0);
}

/**
* Obligatorisk metod för Arduino, det kallas kontinuerligt efter setup().
*/
void loop()
{
checkMode();

se om vi ställa in tiden, eller att låta tiden flöde normalt
om (m_inTimeSetMode)
{
getTimeFromPots();
}
annat
{
Tick();
}

nu när tiden har uppdaterats, Visa tid
displaySeconds();
displayMinutes();
displayHours();

godtyckliga fördröja så att vi inte behandlar bort 100% av tiden,
en handling av energispar
Delay(DELAY_BETWEEN_LOOP_CALLS);
}

/**
* En helper metoden att ställa in m_hour, m_minute och m_second.
*/
void setTime (byte newHour, byte newMinute, byte newSecond)
{
m_second = newSecond;
m_minute = newMinute;
m_hour = newHour;
}

/**
* Denna metod håller reda på det logiska flödet av tid. Om tillräckligt med tid har
* gått sedan den senaste gången som det kallades, m_second, m_minute och m_hour
* kommer att uppdateras lämpliga. Detta beaktar den millis() rullar
* över ungefär varje 50 dagar.
*/
void tick()
{
osignerade långa nu = millis();
osignerade långa msElapsed;

först måste vi ta reda på hur mycket tid har gått sedan senast gången vi
kallas tick()
om (nu < m_lastTick)
{
Flämta, antingen har vi lyckats resa tillbaka i tiden, eller millis() virad runt!
msElapsed = (MAX_UNSIGNED_LONG - m_lastTick) + nu;
}
annat
{
msElapsed = nu - m_lastTick;
}

för varje sekund som har passerat (förhoppningsvis bara 1, om inte vår kod är verkligen laggar),
Lägg till 1 sekund till tiden och öka minuter & timmar om det behövs
för (int jag = 0; jag < msElapsed / ONE_SECOND; ++ jag)
{
m_lastTick = m_lastTick + ONE_SECOND;

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

/**
* Denna metod används PWM för att Visa m_second på en analog mätare anslutna
* till SEC_OUTPUT_PIN.
*/
void displaySeconds()
{
analogWrite (SEC_OUTPUT_PIN, karta (m_second, 59-0, 0, 255));
}

/**
* Metoden läser m_minute, omvandlar den till ett binärt och visar
* det på lämplig lysdioder (de vara PIN_MIN *).
*/
void displayMinutes()
{
byte som = m_minute % 10.
digitalWrite (PIN_MIN1, kära & B1);
digitalWrite (PIN_MIN2, kära & B10);
digitalWrite (PIN_MIN4, kära & B100);
digitalWrite (PIN_MIN8, kära & B1000);

uppdelningen är ganska dyra, men antar vi att sammanställa optimerar detta för oss :)
byte tior = m_minute / 10;
digitalWrite (PIN_MIN10, tens & B1);
digitalWrite (PIN_MIN20, tens & B10);
digitalWrite (PIN_MIN40, tens & B100);
}

/**
* Metoden läser m_hour, omvandlar den till ett binärt och visar
* det på lämplig lysdioder (de vara PIN_HOUR *).
*/
void displayHours()
{
byte som = m_hour % 10.
digitalWrite (PIN_HOUR1, kära & B1);
digitalWrite (PIN_HOUR2, kära & B10);
digitalWrite (PIN_HOUR4, kära & B100);
digitalWrite (PIN_HOUR8, kära & B1000);

byte tior = m_hour / 10;
digitalWrite (PIN_HOUR10, tens & B1);
digitalWrite (PIN_HOUR20, tens & B10);
}

/**
* Denna metod läser värdena från de 2 potentiometrar, konverterar dem till
* mimnutes och timmar, och uppsättningar m_minute och m_hour till de associerade värdena.
*/
void getTimeFromPots()
{
Läs potentiometrar
int hourSensor = analogRead(HOUR_INPUT_PIN);
int minuteSensor = analogRead(MIN_INPUT_PIN);

skala sensormätningar (från 0 till 1023) till rätt
skala (0 till 23 timmar, 0 till 59 minuter)
setTime (karta (hourSensor, 0, 1023, 0, 23), karta (minuteSensor, 0, 1023, 0, 59), 0);

vi ställa in den sista markeringen nu, eftersom när vi in m_inTimeSetMode till false
många sekunder kunde har gått sedan sist, och tiden skulle hoppa framåt
m_lastTick = millis();
}

/**
* Denna metod kontrollerar CLOCK_MODE_SWITCH_PIN för att se om det är hög. Om det är,
* Det innebär att vi nu i klockläge set (m_inTimeSetMode är satt till true), och
* blir CLOCK_MODE_LED_PIN.
*/
void checkMode()
{
m_inTimeSetMode = (analogRead(CLOCK_MODE_SWITCH_PIN) > 512);
digitalWrite (CLOCK_MODE_LED_PIN, m_inTimeSetMode);
}