Petit kit de portable LED - 12 LEDs de PWM d’un ATtiny85 reprogramable (7 / 8 étapes)

Étape 7: Code

Si vous voulez l’utiliser sur un 16 MHz Arduino puis simplement modifier la constante « Loop » en haut à 128 au lieu de 8.  Cette constante rend simplement le code tout répéter un certain nombre de fois.  Nous gérons notre ATtiny à 8 MHz, mais je pense que le diviseur d’horloge interne doit être défini par défaut parce qu’il se comporte comme si il est cadencé à 1MHz.

Pour obtenir une vitesse convenable, multipliez cette constante de la boucle vers le haut par la vitesse de l’horloge (par exemple s’il 64 pour un 328 en cours d’exécution sur l’oscillateur interne de 8 MHz) etc.  Assurez-vous que c’est toujours un multipe de 8 ou le code est susceptible d’avoir des ennuis.

Le code ci-joint est assez simple et a seulement 4 modes :

1 - impair et pair en alternance
2 - module de balayage dans le sens horaire
3 - module de balayage vers la gauche
4 - « Larsen » de type scanner de l’alternance.

Vous pouvez facilement ajouter plusieurs modes de transport plus et ce code de base ne prend autour de 1.6K, il faut donc un autre 6 + jouer avec.

Le même code doit compiler parfaitement bien pour un Arduino sans modification.  Sur un Arduino, PB0 à PB4 sont respectivement de « broches » numériques 8 à 12.  C’est 14-18 d’épingles sur la réelle ATmega328 ou 168 puce.  Ceci est très utile pour tester ou si vous codez pendant que vous attendez pour les pièces d’arriver.

Il s’agit de mon code :

Croquis de test
Chaque LED s’allume à son tour
Licence MIT
UGI 2012

Ce doit être mon multiplicateur standard afin que je peux modifier l’esquisse de minutage différent et des vitesses d’horloge.  128 pour Arduino
Faites-en un multiple de 8 !

const unsigned int boucle = 8 ;

Tiges de 8 à 12 carte aux bits de PORTB pertinents sur les 328.  Étant donné que nous allons utiliser des commandes directes de PORTB que cela devrait fonctionner sur 328 et ATtiny85

Cet exemple utilise l’accès direct PORTB - qui est pins D0 D4 sur Arduino minuscules ou D8 à D12 sur Arduino normal
Première série est actuelle disposition des broches.
Deuxième série est ancienne version :
//
Version actuelle :
octet DirMatrix [12] = {B10001, B10001, B10010, B10010, B10100, B10100, B01001, B01001, B01010, B01010, B01100, B01100} ; Les goupilles sont de sortie et qui sont à haute impédance
octet PolMatrix [12] = {B10000, B00001, B10000, B00010, B10000, B00100, B01000, B00001, B01000, B00010, B01000, B00100} ; Quelle goupille est élevé et qui est faible pour chaque LED
//
Ancienne version :
octet DirMatrix [12] = {B00110, B00110, B01010, B01010, B10010, B10010, B00101, B00101, B01001, B01001, B10001, B10001} ; Les goupilles sont de sortie et qui sont à haute impédance
octet PolMatrix [12] = {B00010, B00100, B00010, B01000, B00010, B10000, B00001, B00100, B00001, B01000, B00001, B10000} ; Quelle goupille est élevé et qui est faible pour chaque LED

octet Mode = 0 ; numérotées de zéro
const byte MaxModes = 4 ; Nombre réel de modes (donc 1 si un seul Mode 0 défini). Si supérieur à 12 devront modifier ChangeMode()
SwitchMode booléen = false ;
ButtonPress booléen = false ; Cela peut maintenant être redondant.

void setup() {}

Serial.Begin(9600) ; Il sont a quelques commandes de débogage Serial restants mais commentées.  Ils travaillent sur mes "mais pas de tiny85
Serial.println ("test de tiny85") ;
Serial.println ("Ugi 2012") ;

DDRB & = B11100000 ; Définissez toutes les broches à haute impédance

}

void loop() {}
interrupteur (Mode) {}
case 0 :
OddEvenFlash() ;
rupture ;
cas 1 :
Progressive(8,0) ;
rupture ;
cas 2 :
Progressive(8,1) ;
rupture ;
cas 3 :
Larsen(8) ;
rupture ;
}
Si (SwitchMode) {SwitchMode = false ; ChangeMode();}

}

Il s’agit de la routine de centrale qui s’allume une LED.
Prend juste le nombre de LED (0 à 11)
utilise directe pour la facilité et la rapidité d’accès aux voies
void LightLED(byte LEDno) {}
DDRB & = B11100000 ;  Définissez toutes les broches d’entrée
PORTB & = B11100000 ; Définissez toutes les broches faible
PORTB| = PolMatrix [LEDno] ; Réglez de façon strictement pertinents élevée et basse
DDRB| = DirMatrix [LEDno] ; mettre deux broches pertinentes à la sortie
}

Vérifie l’état du bouton.
Ne l’appelez pas trop souvent ' cos il tarde.
Boolean CheckButton() {}
DDRB & = B11100000 ;  Définissez toutes les broches d’entrée
PORTB & = B11100000 ; Définissez toutes les broches faible
PORTB| = B00000100 ; Définissez PB2 haute - set pullup interne
delayMicroseconds(100) ; Il fallait laisser pour reposer l’augmentation si mal avec bouton, appuyez sur
Serial.println (PINB & B00000100) ;
volatil presse booléen = PINB & B00000100 ;
if(!Press) {/ / si tiré vers le bas par commutateur
tandis que (! appuyez sur) {/ / attendre que touche relâchée
Serial.Print ("debounce") ; Serial.println (PINB & B00000100) ;
Delay(20) ;
Appuyez sur = PINB & B00000100 ;
}
retourne la valeur true ;
}
retourne la valeur false ;
}

Avance de la variable « Mode ».
void ChangeMode() {}
Mode ++ ;
Si (Mode > = MaxModes) Mode = 0 ;
Serial.println(mode) ;
pour (flash octets = 0; flash < = Mode ; flash ++) {}
LightLED(Mode) ;
Delay(5) ;
DDRB & = B11100000 ;
Delay(15) ;
}
}

Fonctions du mode définies ci-dessous...

OddEvenFlash - conçu comme la fonction par défaut.  Elle clignote alternativement LED paires et impair.
Pourrait être utile pour le débogage du matériel ainsi que la recherche OK.
void OddEvenFlash() {}
const unsigned int Timer = 300 ;
ButtonPress = 0 ;
Odd booléen = false ;
while (!. ButtonPress) {}
pour (int unsigned temps = 0; temps <(Loop*Timer) ; temps ++) {}
pour (octet LED = 0 ; LED < 12 ; LED + = 2) {}
LightLED(LED+Odd) ;
}
}
Impair = ! Impair ;
SwitchMode=CheckButton() ;
Si {(découpage)
Serial.println ("set de SwitchMode") ;
retour ;
}
}
}

Progressif en boucle
Envoie un « oeil » de 4 LED autour de la boucle en se fanant à séquentiellement.
Deuxième fonction - pour faciliter le débogage de matériel & aussi a l’air cool !

Sub {Progressive (octet incrément, boolean Reverse)
octet EyePos [4] = {3,2,1,0} ;
Si {(inverse)
EyePos [0] = 8 ;
EyePos [1] = 9 ;
EyePos [2] = 10 ;
EyePos [3] = 11 ;
}
octet, EyeInt[4]={64,192,(192-Increment),(64-Increment)} ;
while (!. ButtonPress) {}
pour (octet vitesse = 0 ; Vitesse < boucle ; Vitesse += 8) {/ / cela devrait égaliser la vitesse d’horloge freq
pour (octet Pos = 0 ; POS < 4 ; POS++) {/ / light 4 LED selon leur luminosité
LightLED(EyePos[Pos]) ;
Serial.Print (EyePos [Pos], DEC) ; Serial.Print("=") ; Serial.Print(EyeInt[pos],DEC) ; Serial.Print("") ;
octet Scrap ;
pour (byte Count = 0 ; Comte < EyeInt [Pos] ; Count++) {PORTB & = B11111111;}
}
Serial.println("") ;

EyeInt [0] += Increment ;
EyeInt [1] += Increment ;
EyeInt [2] = incrément ;
EyeInt [3] = incrément ;

Si (EyeInt [3] < Increment) {}
EyeInt [3] = EyeInt [2] ;
EyeInt [2] = EyeInt [1] ;
EyeInt [1] = EyeInt [0] ;
EyeInt [0] = 0 ;
EyePos [3] = EyePos [2] ;
EyePos [2] = EyePos [1] ;
EyePos [1] = EyePos [0] ;

{if(Reverse)}
EyePos [0]--;
Si (EyePos [0] > 200) {EyePos [0] = 11;}
}
else {}
EyePos [0] ++ ;
Si (EyePos [0] > 11) {EyePos [0] = 0;}
}
SwitchMode=CheckButton() ;
if(SwitchMode) {return;}
}
}
}
}

Vague de type scanner Larsen
Peut être en mesure de le faire dans le cadre du progressif.  Je ne pouvais pas rendre efficace.
void Larsen(byte Increment) {}
octet EyePos [4] = {3,2,1,0} ;
octet, EyeInt[4]={64,192,(192-Increment),(64-Increment)} ;
Boolean Reverse = false ;
while (!. ButtonPress) {}
pour (octet vitesse = 0 ; Vitesse < boucle ; Vitesse += 8) {/ / cela devrait égaliser la vitesse d’horloge freq
pour (octet Pos = 0 ; POS < 4 ; POS++) {/ / light 4 LED selon leur luminosité
LightLED(EyePos[Pos]) ;
Serial.Print (EyePos [Pos], DEC) ; Serial.Print("=") ; Serial.Print(EyeInt[pos],DEC) ; Serial.Print("") ;
pour (byte Count = 0 ; Comte < EyeInt [Pos] ; Count++) {PORTB & = B11111111;} / / tenir la LED allumée pendant un certain temps selon l’intensité de l’oeil
}
Serial.println("") ;
}
EyeInt [0] += Increment ;
EyeInt [1] += Increment ;
EyeInt [2] = incrément ;
EyeInt [3] = incrément ;

Si (EyeInt [3] < Increment) {}
EyeInt [3] = EyeInt [2] ;
EyeInt [2] = EyeInt [1] ;
EyeInt [1] = EyeInt [0] ;
EyeInt [0] = 0 ;
EyePos [3] = EyePos [2] ;
EyePos [2] = EyePos [1] ;
EyePos [1] = EyePos [0] ;

{if(Reverse)}
EyePos [0]--;
Si (EyePos [0] > 200) {EyePos [0] = 1 ; Reverse = false;}
}
else {}
EyePos [0] ++ ;
Si (EyePos [0] > 11) {EyePos [0] = 10 ; Reverse = true;}
}
SwitchMode=CheckButton() ;
if(SwitchMode) {return;}
}
}
}