Étape 5: Télécharger le code
Allez sur le site du petit projet Arduino et téléchargez la version arduino-minuscule-0100-0010.zip. Suivez étape par étape les instructions dans le fichier Lisezmoi.txt inclus sur la façon de le faire fonctionner avec votre environnement arduino. (Pas vraiment difficile). En outre, vous devrez télécharger PinChangeInterrupt-0001.zip sur le site même. En outre, télécharger la bibliothèque Arduino. Installation des bibliothèques est assez simple, en cas de confusion se référer à ce site.Puis tournez votre arduino dans ce que l'on appelle FAI en ouvrant ide arduino, choisissez fichier-exemples-Arduino comme ISP dans le menu déroulant et en appuyant sur téléchargement bouton.
Une fois que vous avez fait, pâte qui suit le code il, sélectionnez Outils-Conseil-attiny85 (oscillateur interne, BOD désactivé), placer la puce attiny dans la prise programmateur ou maquette ou autre chose comme mentionné ici et continuer à télécharger.
!!!! IMPORTANT!!!
Si le téléchargement échoue, essayez en téléchargeant l’arduino comme fournisseur de services Internet dessinez depuis une ancienne version de l’ide arduino, comme 0022. Si même cela échoue, vous avez probablement vos connexions mal
#define encoderPinA 2
#define encoderPinB 0
#define buttonpin 2
#define loudspeakerpin 1
#include "Time.h"//I n’a pas fait cette bibliothèque
#include "PinChangeInterruptSimple.h"//And également cette bibliothèque n’a pas été faite par moi
volatile int encoderPos = 0; //position de l’encodeur, volatile car il modifie sur interrupt
unsigned int lastReportedPos = 1 ; gestion du changement
public static boolean tournant = false ; Debounce gestion
int stepstochangeitem = 10 ; Combien de marches codeur est nécessaires pour l’élément de menu à modifier
A_set booléen = false ; certains antirebonds vars connexes, qui sait, je n’ai pas fait cette partie du code
B_set booléen = false ;
les éléments int = 4; //number d’éléments de menu
selecteditem int = 0 ;
int R = 512 ; //307 ; //telling quel bouton est pressé-512 = pullup résistance a la même valeur que le bouton on
int numbertype [] = {//roman chiffres ; si vous modifiez, s’il vous plaît également changer la variable numtypesound tableau abd typecount
50, 10,5,1} ;
int numbertypesound [] = {//pitches des chiffres différents
100, 300, 500, 700} ;
int typecount = 4; //number des chiffres alltogether
int delaytime = 150 ;
Boolean inmenu = true; / / sommes-nous maintenant dans le menu ?
unsigned long presslength = 0; //buttons-for combien de temps une touche a été pressée
gestion de temps vars ci-dessous
long diff = 0; //difference entre les synchronisations de temps dans les millis
long realdiff = 0; //same comme ci-dessus, mais arrondies à des demi-heures
hh long non signé const = 1800000 ; //half heure en millisecondes
la dérive depuis longtemps = 0; //by combien la realdiff diffère de diff
unsigned long lastmillis = 0 ;
unsigned long lastcheckedtime = 0 ;
int onemetervalue = 300 ; //how durée (en mesures d’encodeur) est d’un mètre
driftenabled booléen = false ; //are nous corriger heure dérive ?
void setup() {}
pinMode (encoderPinA, entrée) ;
pinMode (encoderPinB, entrée) ;
pinMode (buttonpin, entrée) ;
pinMode (loudspeakerpin, sortie) ;
codeur axe sur interruption 0 (axe 2)
attachPcInterrupt (2, doEncoderA, changement) ;
codeur axe sur interruption 1 (axe 3)
attachPcInterrupt (0, doEncoderB, changement) ;
Serial.Begin (9600) ;
beepnumber (35); //I adore le son de cette
/ * int tempR=analogRead(buttonpin) ;
Si (tempR > 5)
{
R = tempR ;
playSound(1) ;
beepnumber(tempR) ;
encoderPos = 0 ;
SelectedItem = 0 ;
Delay(500) ;
}*/
}
valeur de //set int setvalue (boolean minutes) ; utilisé pour les routines de l’horloge et le sablier
{
[] wrapvalues = {0,2,1,4} ;
encoderPos = 0; //reset position de l’encodeur
SelectedItem = 0; //reset position du menu
int returnvalue = 0 ; la valeur à renvoyer à la fin de la fonction
int stepnumber = 0; //number de l’étape en cours. chaque paramètre chiffre = 1 étape
int laststepnumber = 0 ;
//infinite boucle (1) soit divisé par à l’aide de la commande break
{
inmenu = true ; //so qu’il émet un bip à l’élément de menu, qui est ici utilisée pour déterminer combien de fois vous voulez chaque chiffre dans votre nombre désiré
wrapEncValues() ;
inmenu = false ; //resets retour à la valeur appropriée
Si (stepnumber == 0 & & minutes == false) //setting heures ? Puis sauter 50-valeur (étape 0)
{
StepNumber = 1 ;
laststepnumber = 1 ;
}
Si (laststepnumber == stepnumber)
{
Si (minutes == false & & stepnumber == 2 & & returnvalue > = 20) //skipping actuelle 5 réglage si l’utilisateur est réglage des heures et a mettre à > 20 (réglage 25: 00 comme heure ne serait pas logique)
StepNumber = 3 ;
Si (minutes == true & & stepnumber == 1 & & returnvalue > = 50) //skipping actuelle 10 réglage si l’utilisateur est réglage minutes et a mettre à > 50 (59 est la valeur maximale pour les minutes)
StepNumber = 2 ;
beepnumber(NumberType[StepNumber]) ;
laststepnumber =-1 ;
}
Si (minutes == false)
{
commutateur (stepnumber)
{
cas 1: / / 10 s
éléments = 2 ;
rupture ;
case 2: / / 5 s
Si (returnvalue > = 20) //20-something valeur
StepNumber = 3; //skip 5 s
éléments = 1 ;
rupture ;
case 3: / / 1 s
Si (returnvalue > = 20) //20-something valeur
{
éléments = 3 ;
}
d’autre
éléments = 4 ;
rupture ;
}
}
d’autre
{
commutateur (stepnumber)
{
case 0: / / 50 s
éléments = 1 ;
rupture ;
cas 1: / / 10 s
Si (returnvalue > = 50) //50-something valeur
{
StepNumber = 2; //skip 10 s
rupture ;
}
éléments = 4 ;
rupture ;
case 2: / / 5 s
éléments = 1 ;
rupture ;
case 3: / / 1 s
éléments = 4 ;
rupture ;
}
}
Si (buttonpressed()==1)
{
returnValue = numbertype [stepnumber] * selecteditem ;
StepNumber += 1 ;
SelectedItem = 0 ;
laststepnumber = stepnumber ;
Si (stepnumber > 3)
{
inmenu = true ;
stepstochangeitem = 10 ;
SelectedItem = 1; //back au menu
éléments = 4; //not vraiment nécessaire étant donné que « des éléments » deja aura cette valeur par hasard
retour returnvalue ;
rupture ;
}
}
}
}
Sub wrapEncValues()
{
int beepnum =-1 ;
tandis que (encoderPos > stepstochangeitem)
{
encoderPos = encoderPos-stepstochangeitem ;
SelectedItem += 1 ;
beepnum = selecteditem ;
}
tandis que (encoderPos < 0)
{
encoderPos = stepstochangeitem + encoderPos ;
SelectedItem-= 1 ;
beepnum = selecteditem ;
}
Si (selecteditem > éléments)
{
SelectedItem = 0 ;
beepnum = selecteditem ;
}
Si (selecteditem < 0)
{
SelectedItem = en stock ;
beepnum = selecteditem ;
}
Si (beepnum! =-1 & & inmenu == true)
beepnumber(beepnum) ;
}
void //routine (int soundtype) de playSound pour bip des codes spécifiques (pour zero, entrant dans le programme, alarme et « Bip OK », qui est également utilisé pour séparer les heures et minutes quand afficher l’heure
{
Switch (soundtype)
{
case 0: / / saisie
/ * pour (int i = 0; i < = 100; i ++)
{
ton (loudspeakerpin, i * 5) ;
Delay(5) ;
}
noTone(loudspeakerpin) ;
*/
ton (loudspeakerpin, 500 250) ;
Delay(100) ;
ton (loudspeakerpin, 800 250) ;
Delay(500) ;
rupture ;
cas 1: / / mélodie
ton (loudspeakerpin, 200 250) ;
Delay(100) ;
ton (loudspeakerpin, 500 500) ;
Delay(50) ;
rupture ;
case 2: / / zéro
ton (loudspeakerpin, 950 250) ;
Delay(50) ;
ton (loudspeakerpin, 250 250) ;
rupture ;
case 3: / / point
Delay(100) ;
ton (loudspeakerpin, 950 250) ;
Delay(100) ;
noTone(loudspeakerpin) ;
ton (loudspeakerpin, 950 250) ;
Delay(400) ;
rupture ;
}
}
void loop()
{//Do choses ici
/ * pinMode(13,OUTPUT) ;
digitalWrite(13,HIGH) ;
delayMicroseconds(100000) ;
digitalWrite(13,LOW); * /
Si (driftenabled == true) correction de temps //auto activée
{
setlastcheckedtime booléen = false ;
tandis que (maintenant ()-lastcheckedtime > 3600) //more que la différence d’heures depuis la dernière heure de synchronisation
{
setlastcheckedtime = true ; //sync est arrivé
lastcheckedtime += 3600 ;
adjustTime(drift/1000) ;
}
Si (setlastcheckedtime == true) //set moment de la dernière synchronisation uniquement si la synchronisation s’est réellement passé
lastcheckedtime=Now()-(Drift/1000) ;
}
code a déménagé
wrapEncValues() ;
Si (Serial.read()=='B')
Serial.println (encoderPos, DEC) ;
Si (inmenu == true & & buttonpressed()==1)
{
inmenu = false ;
playSound(0) ;
commutateur (selecteditem)
{
case 0: / / horloge
Si (presslength < 2000) //press n’était pas plus de 2 secondes
{
beepnumber(Hour()) ;
Delay(200) ;
playSound(3) ;
Delay(200) ;
beepnumber(minute()) ;
inmenu = true ;
rupture ;
}
d’autre //longer que 2 sec
{
Si (presslength > 5000) //longer que 5 secondes
{
Si (lastmillis! = 0)
driftenabled = true ;
playSound(3) ;
code ci-dessous calcule dérive de l’oscillateur interne en comparant le délai prévu
(qui peut être facilement estimé, étant donné que l’utilisateur doit faire la synchronisation du flash à: 30 ou : 00) à pris de la valeur.
Calcule ensuite la dérive, il nomme une heure et permet d’économiser à la « dérive » en variable
diff = millis ()-lastmillis ;
unsigned long compval = hh/2 ;
int i ;
pour (i = 1; i < = 10000; i ++)
{
compval += hh ;
Si (diff < = compval)
rupture ;
}
realdiff = i * hh ;
Drift = realdiff-diff ;
Drift=(2*Drift)/(realdiff/HH) ;
lastmillis=Millis() ;
int hrz=hour() ;
minz int ;
Si (minute() > 15 & & minute() < 45) //assume l’horloge n’est pas hors de plus de 15 minutes
minz = 30 ;
d’autre
{
Si (minute() > 45)
HRZ += 1 ;
minz = 0 ;
}
setTime(hrz,minz,0,1,1,1) ;
}
d’autre
{
int hrz=setvalue(false) ;
int minz=setvalue(true) ;
setTime(hrz,minz,0,1,1,1) ;
driftenabled = false ;
lastmillis = 0 ;
lastcheckedtime=Now() ;
}
inmenu = true ;
rupture ;
}
rupture ;
cas 1: / / tape mesure
encoderPos = 0 ;
while(1)
{
wrapEncValues() ;
Si (buttonpressed()==1)
{
Si (presslength < 2000)
{
int cms=round(map(abs(encoderPos),0,onemetervalue,0,100)) ;
beepnumber(CMS) ;
inmenu = true ;
stepstochangeitem = 10 ;
SelectedItem = 1; //back au menu
éléments = 4 ;
encoderPos = 0 ;
rupture ;
}
else / / suppose que l’utilisateur a mesuré exactement un mètre et veut calibrer le ruban à mesurer
{
playSound(3) ;
onemetervalue=ABS(encoderPos) ;
encoderPos = 0 ;
inmenu = true ;
rupture ;
}
}
}
rupture ;
case 2: / / détecteur d’eau
{
stepstochangeitem = 4 ;
éléments = 10 ;
SelectedItem = 5 ;
{while(1)}
wrapEncValues() ;
Si (abs(selecteditem-5) > 2) //the sonde utilise le même NIP d’entrée sous forme de boutons ; donc, pour sortir le détecteur d’eau, l’utilisateur est obligé de tourner la roue codeuse
{
inmenu = true ;
stepstochangeitem = 10 ;
encoderPos = 0 ;
SelectedItem = 2; //back au menu
éléments = 4 ;
noTone(loudspeakerpin) ;
rupture ;
}
Tone(loudspeakerpin,Map(analogRead(buttonpin),0,512,100,1000)); //0-256 ; 100-500
}
rupture ;
}
case 3: / / chronomètre
{
int startingsecs ;
watchrunning booléen = false ;
while (1)
{
if(ButtonPressed()==1)
{
playSound(3) ;
Si (watchrunning == false)
{
watchrunning = true ;
startingsecs = millis () / 1000 ;
}
d’autre
{
watchrunning = false ;
beepnumber(Millis()/1000-startingsecs) ;
inmenu = true ;
SelectedItem = 3; //back au menu
rupture ;
}
}
}
rupture ;
}
case 4: / / egg timer
int minutemins = 99 ;
while (1)
{
int buttoncode = buttonpressed (); //so qu’il ne doit pas être prélevé deux fois
Si (buttoncode == 0)
rupture ;
Si (buttoncode == 1)
{
minutemins=SetValue(true) ;
minutemins = ((minute) + minutemins) %60;//to assurer cela fonctionnera correctement même si l’heure change alors que le sablier est en cours d’exécution (qui n’est pas vraiment possible maintenant quand je pense à ce sujet...)
playSound(3) ;
}
Si (minute()==minutemins)
{
playSound(1) ;
Si (buttoncode == 0)
rupture ;
}
}
rupture ;
}
}
}
Jusqu'à nouvel ordre, le code ci-dessous n'est pas le mien
void doEncoderA() {}
Debounce
Si le retard (rotation) (1) ; Attendez un peu que le rebond se fait
Test de transition, choses n’a vraiment changé ?
Si (digitalRead(encoderPinA)! = A_set) {/ / debounce une fois de plus
A_set = ! A_set ;
ajuster le compteur + si A conduit B
Si (A_set & & ! B_set)
encoderPos += 1 ;
rotation = false ; pas plus debouncing jusqu'à ce que loop() frappe à nouveau
}
}
Interruption sur B changer d’État, idem une
void doEncoderB() {}
Si le retard (rotation) (1) ;
Si (digitalRead(encoderPinB)! = B_set) {}
B_set = ! B_set ;
le rajustement counter - 1 si B conduit A
Si (B_set & & ! A_set)
encoderPos-= 1 ;
rotation = false ;
}
}
par la suite, le code est à moi à nouveau
int buttonpressed()
{
Si (analogRead(buttonpin) > 5) //is passe rien du tout ?
{
int returnvalue =-1 ;
unsigned long beginms = millis (); //variable pour plus tard comparation de dire pour combien longtemps la touche a été enfoncée
while(1)
{
unsigned long lastmillis ;
int value=analogRead(buttonpin) ;
Si (valeur > 5) //should être 0, mais certains hysteresion n’a jamais fait mal
{
lastmillis=Millis() ;
Si (abs(value-((2*R)/3)) < 10) //button 2
returnValue = 0 ;
d’autre
Si (abs(value-R) < 10) //button 1
{
returnValue = 1 ;
R = valeur ;
}
d’autre
Si (abs(value-((2*R)/5)*3) < 10) boutons de //both, ne fonctionne pas vraiment
returnValue = 2 ;
}
d’autre
Si (millis ()-lastmillis > 20) //to la debouncing ; bouton de décompte comme libérés une fois qu’il a été libéré pour plus de 20ms
{
presslength = millis ()-beginms ;
retour returnvalue ;
rupture ;
}
}
}
d’autre
Retourne -1 ;
}
int beepnumber (int num) //beeping le nombre. Pseudorecursively fonctionne en divisant l’argument par des chiffres du plus élevé au plus bas
et puis se nourrit le modulo de division retour à elle-même et reprend l’ensemble du processus
{
Si (num == 0)
{
playSound (2); //special code zéro
return 0 ;
}
int initpos = encoderPos ;
int numbertypevalue [] = {}
-1, -1, -1 ,-1 };
pour (int i = 0; i < typecount; i ++)
{
Si (num/numbertype [i] > = 1)
{
numbertypevalue[i]=Floor(num/NumberType[i]) ;
num = num % numbertype [i] ;
}
encoderPos = initpos ; //basically ignorer utilisateur tournant l’encodeur si bip la valeur
Si (numbertypevalue [i] > -1)
{
pour (int i2 = 0; i2 < numbertypevalue[i];i2++)
{
pour (int i3 = 0; i3 < 4-i; i3 ++)
{
Delay(DelayTime/2) ;
ton (loudspeakerpin, numbertypesound[i],delaytime) ;
Delay(DelayTime) ;
}
Delay(DelayTime*2) ;
}
}
}
}
