Vacances Dice Roller (2 / 3 étapes)

Étape 2: Le Code (Sketch Arduino)

const int rollButton = 14 ;
const int secretButton = 15 ;

const int diceOne = 0 ;
const int diceTwo = 6 ;  Ajouter 6 aux broches d’adresse du deuxième die

int rollButtonState = élevé ;               la lecture actuelle de la goupille. ÉLEVÉ ne = pas pressé
int lastRollButtonState = élevé ;     la lecture précédente de la goupille
int secretButtonState = élevé ;             la lecture actuelle de la goupille de SECRET
int lastSecretButtonState = élevé ;   la lecture précédente de la goupille de SECRET

les variables suivantes sont longues de parce que le temps, mesuré en millisecondes,
deviendra rapidement un plus grand nombre que peuvent être stockés dans un int.
long lastSecretDebounceTime = 0 ;  la dernière fois que la broche de sortie a été activé/désactivée
long lastRollDebounceTime = 0 ;  la dernière fois que la broche de sortie a été activé/désactivée
debounceDelay long = 55 ;    le temps de debounce ; augmenter si la sortie scintille

void setup() {}

pinMode (0, sortie) ;        tout d’abord mourir de LED
pinMode (1, sortie) ;
pinMode (sortie 2) ;
pinMode (3, sortie) ;
pinMode (sortie 4) ;
pinMode (5, sortie) ;
pinMode (6, sortie) ;

pinMode (7, sortie) ;          die deuxième LED
pinMode (sortie 8) ;
pinMode (sortie 9) ;
pinMode (sortie 10,) ;
pinMode (sortie 11) ;
pinMode (sortie 12,) ;
pinMode (13, sortie) ;

pinMode (rollButton, entrée) ;            définit A0 broche comme entrée numérique ; Il s’agit de bouton ROLL
digitalWrite (rollButton, HIGH) ;        Allumez la résistance pullup

pinMode (secretButton, entrée) ;             définit A1 comme entrée numérique ; Il s’agit d’une touche SECRET
digitalWrite (secretButton, HIGH) ;         Allumez la résistance pullup

Serial.Begin(9600) ;

randomSeed(analogRead(3)) ;   Si la broche d’entrée analogique 3 est analogique non-connecté, aléatoire
bruit provoque l’appel à randomSeed() pour générer
nombre de graines différentes chaque fois le croquis est exécuté.
randomSeed() sera alors aléatoire la fonction aléatoire.

clearAll() ;

lightOne(0) ;                  Définissez les deux dés à lumières ceux pendant que vous attendez de commutateur ROLL à presser
lightOne(7) ;
}

void loop() {}

Serial.Print(rollButtonState) ;
Serial.println ("État du bouton Roll =") ;
Serial.println ("grande boucle") ;

checkRollButton() ;
checkSecretButton() ;
Si (rollButtonState == faible) / / bouton enfoncé = faible
{
blinkAll (300, 3) ;        un clin de & tout animé de 3 fois, 300 ms dehors et puis rouler
}

}

void checkSecretButton() {}
lire l’état de l’interrupteur dans une variable locale :
lecture int = digitalRead(secretButton) ;

Vérifiez si vous venez d’appuyer sur le bouton
(c'est-à-dire l’entrée est passé d’élevé à faible), et vous avez attendu
assez longtemps à ignorer les bruits :

Si l’interrupteur est faible, en raison de bruit ou de pressage :
Si (lecture == faible) {}
attendre le temps antirebonds
Delay(debounceDelay) ;
lire = digitalRead(secretButton) ;
Si (lecture == faible) //reading est encore faible retard debounce
{
secretButtonState = bas ;
Serial.println ("secretRoll de routine mis bas") ;
lastSecretButtonState = bas ; Il se souvient le bouton a été poussé et ne peut être réinitialisé après un rouleau secret
}
d’autre
{secretButtonState = élevé ;
}
}
d’autre
{secretButtonState = élevé ;
}
}

void checkRollButton() {}
lire l’état de l’interrupteur dans une variable locale :
lecture int = digitalRead(rollButton) ;

Vérifiez si vous venez d’appuyer sur le bouton
(c'est-à-dire l’entrée est passé d’élevé à faible), et vous avez attendu
assez longtemps à ignorer les bruits :

Si l’interrupteur est faible, en raison de bruit ou de pressage :
Si (lecture == faible) {}
attendre le temps antirebonds
Delay(debounceDelay) ;
lire = digitalRead(rollButton) ;
Si (lecture == faible) //reading est encore faible retard debounce
{rollButtonState = faible ;
Serial.println ("CheckRoll de routine mis bas") ;
}
d’autre
{rollButtonState = élevé ;
}
}
d’autre
{rollButtonState = élevé ;
}

}

void lightOne (int diceNumber) {}
Serial.println ("roulé un") ;
digitalWrite (diceNumber, HIGH) ;
}

void lightTwo (int diceNumber) {}
Serial.println ("roulé deux ») ;
digitalWrite (1 + diceNumber, HIGH) ;
digitalWrite (4 + diceNumber, HIGH) ;
}

void lightThree (int diceNumber) {}
Serial.println ("roulé trois") ;
digitalWrite (1 + diceNumber, HIGH) ;
digitalWrite (4 + diceNumber, HIGH) ;
digitalWrite (0 + diceNumber, HIGH) ;
}

void lightFour (int diceNumber) {}
Serial.println ("roulé quatre") ;
digitalWrite (3 + diceNumber, HIGH) ;
digitalWrite (1 + diceNumber, HIGH) ;
digitalWrite (4 + diceNumber, HIGH) ;
digitalWrite (6 + diceNumber, HIGH) ;
}

void lightFive (int diceNumber) {}
Serial.println ("roulé cinq") ;
digitalWrite (1 + diceNumber, HIGH) ;
digitalWrite (3 + diceNumber, HIGH) ;
digitalWrite (4 + diceNumber, HIGH) ;
digitalWrite (6 + diceNumber, HIGH) ;
digitalWrite (0 + diceNumber, HIGH) ;
}

void lightSix (int diceNumber) {}
Serial.println ("roulé SIX") ;
digitalWrite (1 + diceNumber, HIGH) ;
digitalWrite (2 + diceNumber, HIGH) ;
digitalWrite (3 + diceNumber, HIGH) ;
digitalWrite (4 + diceNumber, HIGH) ;
digitalWrite (5 + diceNumber, HIGH) ;
digitalWrite (6 + diceNumber, HIGH) ;
}

void clearAll() {}
digitalWrite (0, faible) ;
digitalWrite (1, faible) ;
digitalWrite (2, basse) ;
digitalWrite (3, faible) ;
digitalWrite (4, faible) ;
digitalWrite (5, faible) ;
digitalWrite (6, faible) ;
digitalWrite (7, faible) ;
digitalWrite (8, faible) ;
digitalWrite (9, faible) ;
digitalWrite (10, faible) ;
digitalWrite (11, faible) ;
digitalWrite (12, faible) ;
digitalWrite (13, faible) ;
}

void blinkAll (int t [, int n) {}
clearAll() ;
pour (int x = 0; x < n; x ++) {/ / Loop n fois
digitalWrite (0, faible) ;
digitalWrite (1, faible) ;
digitalWrite (2, basse) ;
digitalWrite (3, faible) ;
digitalWrite (4, faible) ;
digitalWrite (5, faible) ;
digitalWrite (6, faible) ;
digitalWrite (7, HIGH) ;
digitalWrite (8, HIGH) ;
digitalWrite (9, HIGH) ;
digitalWrite (10, haute) ;
digitalWrite (11, haute) ;
digitalWrite (12, HIGH) ;
digitalWrite (13, HIGH) ;

Delay(t) ;

digitalWrite (0, HIGH) ;
digitalWrite (1, haut) ;
digitalWrite (2, haut) ;
digitalWrite (3, élevée) ;
digitalWrite (4, élevée) ;
digitalWrite (5, HIGH) ;
digitalWrite (6, HIGH) ;
digitalWrite (7, faible) ;
digitalWrite (8, faible) ;
digitalWrite (9, faible) ;
digitalWrite (10, faible) ;
digitalWrite (11, faible) ;
digitalWrite (12, faible) ;
digitalWrite (13, faible) ;

Delay(t) ;
}

clearAll() ;

tout d’abord vérifier si le bouton secret a été précédemment poussé
Si (lastSecretButtonState == faible) / / si le secret a été enfoncée, lastSecretButtonState sera encore faible
{
secretDiceRoll() ;
}
d’autre
{
randomDiceRoll() ;
}

}

void randomDiceRoll() {}

int randNumber = 6 ;

/*
code d’essai
clearAll() ;

lightOne(diceOne) ;                  Définissez les deux dés à lumières ceux pendant que vous attendez de commutateur ROLL à presser
lightOne(diceTwo) ;
*/

Serial.println ("Random numéro code saisi") ;
Serial.Print(rollButtonState) ;
Serial.println ("État du bouton Roll =") ;

pour (d int = 0; d < 8; d = j + 7) {/ / faire une fois pour ea die

obtenir un nombre aléatoire de 1 à 6
randNumber = au hasard (6) + 1 ;

Switch (randNumber) {}

cas 1 :
lightOne(d) ;
rupture ;

cas 2 :
lightTwo(d) ;
rupture ;

cas 3 :
lightThree(d) ;
rupture ;

cas 4 :
lightFour(d) ;
rupture ;

cas no 5 :
lightFive(d) ;
rupture ;

cas 6 :
lightSix(d) ;
rupture ;

par défaut :
clearAll() ;
rupture ;
}
}

rollButtonState = élevé ;

Serial.println ("est sorti numéro code aléatoire ») ;
Serial.Print(rollButtonState) ;
Serial.println ("État du bouton Roll =") ;
Serial.println("") ;

}

void secretDiceRoll() {bouton //secret causes aléatoires doubles

int secretRandNumber = 6 ;

secretRandNumber = au hasard (6) + 1 ;

Switch (secretRandNumber) {}

cas 1 :
{lightOne(0) ; lightOne(7) ; break;}

cas 2 :
{lightTwo(0) ; lightTwo(7) ; break;}

cas 3 :
{lightThree(0) ; lightThree(7) ; break;}

cas 4 :
{lightFour(0) ; lightFour(7) ; break;}

cas no 5 :
{lightFive(0) ; lightFive(7) ; break;}

cas 6 :
{lightSix(0) ; lightSix(7) ; break;}

par défaut :
{clearAll() ; break;}
}
secretButtonState = élevé ;
lastSecretButtonState = élevé ;
}