Barista mästerskapet bryggning stoppur • inledning (4 / 7 steg)

Steg 4: kod

Följande kod bör kopieras och klistras in i Arduino IDE, och sedan, om det hade varit några nödvändiga förändringar ska laddas upp till Arduino styrelsen.

För direkt nedladdning som .ide fil, klicka på denna länk.

// ==========
Världen Barisa Championship brew tid propp
kodad och designad av Tamas Szekffy
2v0 från 15. mars 2014.
För förbättringar kontakta anteckningar, tips och felrapporter, vänligen professzore
Creative Commons licens erkännande icke-kommersiell dela lika (CC-av-NC-SA-4,0)
// ==========

medföljande bibliotek

#include / / grundläggande LCD-bibliotek
#include / / I2C ledningar bibliotek
#include / / MAX7221 bibliotek

// ==========
före installationen
// ==========

LiquidCrystal lcd (8, 9, 5, 4, 3, 2); LCD pinut
CONST byte dot = B10100101;
CONST byte full = B11111111;
CONST int LCDBK = 6; LCD-bakgrundsbelysning pin
CONST int ss1 = A3; Start/stopp 1 pin
CONST int ss2 = A2; Start/stopp 2 pin
CONST int rst = A1; Återställa PIN-koden
int bcklght = 200. LCD-bakgrundsbelysning värde (0 = inaktivera bakgrundsljus)

Timer variabler

booleska timer1 = false; True, om timer1 körs
booleska timer2 = false; True, om timer2 körs
booleska ssastate = false; blev sant, om ss1 knappen nedtryckt (används för debouncing)
booleska ssbstate = false; blev sant, om ss2 knappen nedtryckt (används för debouncing)
booleska rststate = false; blev sant, om första knappen nedtryckt (används för debouncing)
booleska finish = false; blev sant, så snart alla mätningar klar
osignerade långa atime; tillfälliga variabeln för första gången anger tiden tillbringade sedan början
osignerade långa atiden; tillfälliga variabeln för andra gången, anger tid som tillbringas sedan början
osignerade långa astime; variabel för första gången visar den tid då proppen igång
osignerade långa bstime; variabel för andra gången, visar den tid då proppen igång
osignerade långa debounce;
int omlopps [3]. matriser av variabler för att lagra första gången mätt, en efter en
int atid [3]. matriser av variabler för att lagra andra gången mätt, en efter en
int validtime = 3000; maximal tid som skillnaden mellan uppmätt gånger för att träffa WBC regler (millisekunder, 3 SEK = 3000)
osignerade långa menudelay = 0; variabel som ska mäta hur lång tid "reset" tryckte
booleska menustate = false; boolesk variabel att påpeka om systemet är i meny-läge för validering tid
booleska menustate2 = false; boolesk variabel att påpeka om systemet är i meny-läge för bakgrundsbelysning inställningen tid
byte atimecount = 0; variabel att räkna som mätning (första, andra eller första) är "i linje" för första gången
byte btimecount = 0; variabel att räkna som mätning (första, andra eller första) är "i linje" för andra gången

/*
stift 11 är ansluten till DataIn
stift 13 är ansluten till CLK
PIN 10 är ansluten till belastning
Vi har en enda (1) MAX72XX.
*/
LedControl lc=LedControl(11,13,10,1);

// ===========
Huvudsakliga Setup
// ===========

void setup() {
Wire.BEGIN(); Slå på I2C
analogWrite (LCDBK, bcklght); LCD backlight är på
LCD.BEGIN (16, 2); Ange storleken på LCD-skärmen (16 siffror, 2 rader)
LCD.Clear();
/*
MAX72XX är i energisparläge på uppstått,
Vi måste göra en väckarklocka
*/
LC.Shutdown(0,false);
/ * Ställa in ljusstyrkan * /
lc.setIntensity(0,8);
/ * och rensa displayen * /
lc.clearDisplay(0);

pinMode (ss1, ingång);
pinMode (ss2, ingång);
pinMode (rst, ingång);

testrun(); Avmarkera "/ /" om du behöver det första testet av systemet
Delay(1);

LCD.Clear();
lcd.setCursor(0,0);
LCD.Print ("WBC giltig tid");
lcd.setCursor(0,1);
LCD.Print(validtime);
LCD.Print ("MS");
Delay(2000);
LCD.Clear();

rstall();
}

// =============
Huvudsakliga rutin
// =============

void loop()
{
om (digitalRead(ss1) == hög & & ssastate == false & & avsluta! = true & & debounce + 200 < millis()) {
startstopa();
Dämpningstid = millis();
}
om (digitalRead(ss1) == låg & & ssastate == true) {
ssastate = false;
}
om (digitalRead(ss2) == hög & & ssbstate == false & & avsluta! = true & & debounce + 200 < millis()) {
startstopb();
Dämpningstid = millis();
}
om (digitalRead(ss2) == låg & & ssbstate == true) {
ssbstate = false;
}
om (digitalRead(rst) == hög & & rststate == false & & avsluta == true & & debounce + 200 < millis()) {
rstall();
Dämpningstid = millis();
avsluta = false;
menudelay = 0;
}
om (digitalRead(rst) == hög & & rststate == false & & avsluta == false & & menudelay == 0)
{
menudelay = millis() + 3000;
rststate = sant;
}
om (digitalRead(rst) == hög & & rststate == true & & menudelay! = 0 & & menudelay < millis())
{
menustate = sant;
LCD.Clear();
}
om (digitalRead(rst) == låg & & rststate == true) {
rststate = false;
menudelay = 0;
}
om (atimecount == btimecount & & atimecount! = 0) {
validate();
}
om (atimecount == 3 & & btimecount == 3) {
avsluta = sant;
}

// ============================
Tid kontrollera värdet inställningsmenyn /
// ============================

While(menustate)
{
lc.clearDisplay(0);
lcd.setCursor(0,0);
LCD.Print ("WBC giltig tid");
lcd.setCursor(0,1);
LCD.Print(validtime);
LCD.Print ("MS");
om (digitalRead(ss1) == hög & & ssastate == false & & validtime > 0 & & debounce + 200 < millis()) {
ssastate = sant;
validtime-= 100.
Dämpningstid = millis();
}
om (digitalRead(ss1) == låg & & ssastate == true) {
ssastate = false;
}
om (digitalRead(ss2) == hög & & ssbstate == false & & validtime < 32700 & & debounce + 200 < millis()) {
ssbstate = sant;
validtime + = 100.
Dämpningstid = millis();
}
om (digitalRead(ss2) == låg & & ssbstate == true) {
ssbstate = false;
}

om (digitalRead(rst) == låg & & rststate == true) {
rststate = false;
menudelay = 0;
}
om (digitalRead(rst) == hög & & rststate == false & & menudelay == 0)
{
menustate = false;
menustate2 = sant;
rststate = sant;
menudelay = millis() + 200.
}
}
SLUTET av submenu1

// =====================
Bakgrundsbelysning inställningsmenyn
// =====================

While(menustate2)
{
lc.clearDisplay(0);
lcd.setCursor(0,0);
LCD.Print ("Backlight värde");
lcd.setCursor(0,1);
LCD.Print(bcklght);
LCD.Print("");
om (digitalRead(ss1) == hög & & ssastate == false & & bcklght > 0 & & debounce + 200 < millis()) {
ssastate = sant;
bcklght-= 10.
Dämpningstid = millis();
}
om (digitalRead(ss1) == låg & & ssastate == true) {
ssastate = false;
}
om (digitalRead(ss2) == hög & & ssbstate == false & & bcklght < 250 & & debounce + 200 < millis()) {
ssbstate = sant;
bcklght += 10.
Dämpningstid = millis();
}
om (digitalRead(ss2) == låg & & ssbstate == true) {
ssbstate = false;
}

om (digitalRead(rst) == låg & & rststate == true) {
rststate = false;
menudelay = 0;
}
om (digitalRead(rst) == hög & & rststate == false & & menudelay > millis())
{
menustate2 = false;
rststate = sant;
Delay(1);
rstall();
Delay(1);
}
analogWrite (LCDBK, bcklght);
}
SLUTET av submenu2

Delay(1);
}

// ========================
Start/stopp av propp 1
// ========================

void startstopa()
{
ssastate = sant; knappen har intryckt
om (timer1 == false) / / om timern inte är igång...
{
astime = millis(); spela in starttid
timer1 = sant; indikera början av timern
lcd.setCursor(2,0);
LCD.Print("Run");
lc.setChar(0,3,'-',false);
}
annat / / om timern är aktiverad...
{
timer1 = false; Ange stoppet av timern
atid = millis() - astime; beräknar den tid sedan början
lcd.setCursor(2,0);
LCD.Print("...");
lc.setChar (0,3, "", falsk);
atid = atime/100.
atid = tid * 100;
omlopps [atimecount] = atime;
write7Segment (omlopps [atimecount], 0);
om (atimecount < 3) {
lcd.setCursor(6+(atimecount*2),0);
LCD.write(full);
atimecount ++;
}
}
}

// ========================
Start/stopp av propp 2
// ========================

void startstopb()
{
ssbstate = sant; knappen har intryckt
om (timer2 == false) / / om timern inte är igång...
{
bstime = millis(); spela in starttid
timer2 = sant; indikera början av timern
lcd.setCursor(2,1);
LCD.Print("Run");
lc.setChar(0,7,'-',false);
}
annat / / om timern är aktiverad...
{
timer2 = false; Ange stoppet av timern
atiden = millis() - bstime; beräknar den tid sedan början
lcd.setCursor(2,1);
LCD.Print("...");
lc.setChar (0,7, "", falsk);
atiden = atiden/100.
atiden = tid * 100;
atid [btimecount] = atiden;
write7Segment (atid [btimecount], 4);
om (btimecount < 3) {
lcd.setCursor(6+(btimecount*2),1);
LCD.write(full);
btimecount ++;
}
}
}

// ===================
Skriv tid på 7221
// ===================

void write7Segment (osignerade långa v, byte i) {
byte en;
byte TEN;
delar av byte.
v = v/100;
fraktioner = v % 10.
v = v/10;
de = v % 10.
v = v/10;
tens = v % 10.
lc.setDigit(0,i,tens,false);
lc.setDigit(0,i+1,ones,true);
lc.setDigit(0,i+2,fractions,false);
}

// ================================
Verifiera varje mätning-par
// ================================

void validate()
{
unsigned int lägsta;
unsigned int högsta;
unsigned int skillnad;
lägsta = min(atimes[atimecount-1],btimes[btimecount-1]);
högsta = max(atimes[atimecount-1],btimes[btimecount-1]);
skillnaden = högsta - lägsta;
om (skillnaden > validtime) {
lcd.setCursor(12,0);
LCD.Print("Fail");
byte en;
byte TEN;
delar av byte.
skillnaden = skillnaden/100.
fraktioner = skillnad % 10.
skillnaden = skillnaden/10;
de = skillnad % 10.
skillnaden = skillnaden/10;
tens = skillnad % 10.
lcd.setCursor(12,1);
LCD.Print(TENS);
lcd.setCursor(13,1);
LCD.Print(Ones);
lcd.setCursor(14,1);
LCD.Print('.');
lcd.setCursor(15,1);
LCD.Print(fractions);
}
annat
{
lcd.setCursor(12,0);
LCD.Print ("OK");
byte en;
byte TEN;
delar av byte.
skillnaden = skillnaden/100.
fraktioner = skillnad % 10.
skillnaden = skillnaden/10;
de = skillnad % 10.
skillnaden = skillnaden/10;
tens = skillnad % 10.
lcd.setCursor(12,1);
LCD.Print(TENS);
lcd.setCursor(13,1);
LCD.Print(Ones);
lcd.setCursor(14,1);
LCD.Print('.');
lcd.setCursor(15,1);
LCD.Print(fractions);
}
}

// ===========================================
Återställa alla värden, återvänder till starttillstånd
// ===========================================

void rstall()
{
rststate = sant;
lc.clearDisplay(0);
Delay(100);
write7Segment (0, 0);
write7Segment (0, 4);
Återställ alla variabler
timer1 = false;
timer2 = false;
atid = 0;
atiden = 0;
astime = 0;
bstime = 0;
omlopps [0] = 0;
omlopps [1] = 0;
omlopps [2] = 0;
atid [0] = 0;
atid [1] = 0;
atid [2] = 0;
atimecount = 0;
btimecount = 0;
LCD.Clear();
lcd.setCursor(0,0);
LCD.Print('1');
lcd.setCursor(0,1);
LCD.Print('2');
lcd.setCursor(2,0);
LCD.Print("...");
lcd.setCursor(2,1);
LCD.Print("...");
lcd.setCursor(6,0);
LCD.write(dot);
lcd.setCursor(8,0);
LCD.write(dot);
lcd.setCursor(10,0);
LCD.write(dot);
lcd.setCursor(6,1);
LCD.write(dot);
lcd.setCursor(8,1);
LCD.write(dot);
lcd.setCursor(10,1);
LCD.write(dot);
lcd.setCursor(12,0);
LCD.Print("...");
lcd.setCursor(12,1);
LCD.Print("...");
}

// ========================================================================
Testa rutin, kan startas av un-/ / samtal i slutet av void. Setup
// ========================================================================

void testrun()
{
lc.clearDisplay(0);
LCD.Clear();
lcd.setCursor(0,0);
LCD.Print ("WBC stoppur");
lcd.setCursor(0,1);
LCD.Print ("Made av Tamas Szekffy 2014");
Delay(2000);
för (int scroll = 0; scroll < 18; scroll ++)
{
lcd.scrollDisplayLeft();
Delay(500);
}
LCD.Clear();
lcd.setCursor(0,0);
LCD.Print ("prov köra kommer").
lcd.setCursor(0,1);
LCD.Print ("genomgå i 5 s");
Delay(5000);
LCD.Clear();
lc.clearDisplay(0);
för (int jag = 0; jag < 10; i ++)
{
lc.setDigit(0,0,i,false);
lc.setDigit(0,1,i,true);
lc.setDigit(0,2,i,false);
lc.setDigit(0,4,i,false);
lc.setDigit(0,5,i,true);
lc.setDigit(0,6,i,false);
Delay(500);
}
lc.clearDisplay(0);
Delay(500);
LCD.Clear();
Delay(250);
lcd.setCursor(0,0);
LCD.Print('1');
Delay(250);
lcd.setCursor(0,1);
LCD.Print('2');
Delay(250);
lcd.setCursor(2,0);
LCD.Print("...");
Delay(250);
lcd.setCursor(2,0);
LCD.Print("Run");
Delay(250);
lcd.setCursor(2,1);
LCD.Print("...");
Delay(250);
lcd.setCursor(2,1);
LCD.Print("Run");
Delay(250);
lcd.setCursor(6,0);
LCD.write(dot);
Delay(250);
lcd.setCursor(6,0);
LCD.write(full);
Delay(250);
lcd.setCursor(8,0);
LCD.write(dot);
Delay(250);
lcd.setCursor(8,0);
LCD.write(full);
Delay(250);
lcd.setCursor(10,0);
LCD.write(dot);
Delay(250);
lcd.setCursor(10,0);
LCD.write(full);
Delay(250);
lcd.setCursor(6,1);
LCD.write(dot);
Delay(250);
lcd.setCursor(6,1);
LCD.write(full);
Delay(250);
lcd.setCursor(8,1);
LCD.write(dot);
Delay(250);
lcd.setCursor(8,1);
LCD.write(full);
Delay(250);
lcd.setCursor(10,1);
LCD.write(dot);
Delay(250);
lcd.setCursor(10,1);
LCD.write(full);
Delay(250);
lcd.setCursor(12,0);
LCD.Print("...");
Delay(250);
lcd.setCursor(12,1);
LCD.Print("...");
Delay(1000);
LCD.Clear();
lcd.setCursor(0,0);
LCD.Print ("redo att gå!");
Delay(3000);
LCD.Clear();
}