Throwduino Basic - détection de lumière clignotant Throwie avec 1 partie ajoutée - maintenant avec le Code Morse (3 / 7 étapes)

Étape 3: Programmer la puce

Ayant mis en place votre programmeur dans la dernière étape, charger le croquis de base Throwduino pour l’IDE. Il a collé ci-dessous et également joint.

seuil = (total >> 5) ; la valeur seuil de point (fracture totale de 128) moyen.

devrait probablement être :

seuil = (total >> 7) ; la valeur seuil de point (fracture totale de 128) moyen.

Il a travaillé pour moi car c’était, mais cela pourrait causer des problèmes avec la détection de lumière.  Je vais vérifier et corriger si nécessaire.

Si vous souhaitez modifier la séquence-flash de votre thowie alors maintenant est le temps.  Assurez-vous que votre code s’adaptera dans la mémoire de la puce que vous avez.  Il n’est pas susceptible d’être un problème pour quoi que ce soit plus grand qu’un ATtiny25.  Le croquis ci-dessous ne prend pas plus de 1K.  Le code ci-dessous affiche le bien connu "1-4-3" séquence flash.  Ceci, bien sûr, peut-être pas votre truc, tellement hack-loin.

La séquence flash se tient dans le tableau et détient tout simplement une liste de numéros de flash.  Ceux-ci sont joués avec une courte pause entre chacun, suivis par une pause de 2 secondes avant de répéter.  Par exemple, pour :

Le throwie se met à clignoter une fois, mettre en pause, flash 4 fois, mettre en pause, clignoter 3 fois, pause de 2 secondes et répéter.

Une fois l’esquisse est prêt, sélectionnez ATtiny85 1Mz (ou n’importe quel ATtiny vous utilisez) dans la liste de conseils dans l’IDE.  Si vous ne sélectionnez pas le bon conseil, vous pouvez obtenir une erreur de compilation (XXXX pas définie dans cette étendue).  Si vous obtenez ceci, vérifiez que vous avez sélectionné un ATtinyX5.

Appuyez sur « upload » dans l’IDE.  Par défaut, le Arduino Tiny utilise l’ISP de l’Arduino.  Vous devriez voir le pin13 conduit sur votre scintillement Arduino comme l’esquisse est transférée.

Comment fonctionne l’esquisse ?

Nous avons quelques fonctions définies qui font des choses utiles et vous pouvez utiliser dans le piratage :

flash(byte) Sub - émet les clignotements de la LED "byte".
int lightLevel() - retourne un entier contenant la mesure de niveau la lumière de la LED contre la 2.56v Réf interne.
Sub setup_watchdog(int) - définit le temporisateur à valeur "int". Il y a 10 graduations allant de 0 à 9 correspondant à 16, 32, 64, 128, 250, 500, 1000, 2000, 4000 et 8000 ms.
system_sleep() Sub - met le système à dormir pendant le délai prévu dans le programme d’installation de chien de garde.

Pour commencer, nous pousser à quelques registres pour configurer les choses et de minimiser le gaspillage d’énergie.  Puis dans la configuration, nous clignoter 3 fois et prenons 148 mesures de l’intensité lumineuse.  Nous jeter les 20 premiers et les 128 restant en moyenne.  Cela définit le seuil de laquelle nous jugerons quand il fait sombre.  Nous clignoter la LED ce nombre seuil avant exerçant son activité.  Il s’agit plus pour le débogage que quelque chose d’utile.

Dans la boucle principale nous mesurer le niveau de lumière et comparer à la valeur de seuil.  Si son inférieur à la valeur puis nous clignoter la LED par notre modèle prédéterminé.  Si le niveau de luminosité est élevé alors que nous dormons pendant 8 secondes (la plus longue que nous pouvons) avant de tester à nouveau.

Merci à InsideGadgets pour cet article qui faisait le point de départ pour le code de sommeil.  Il est à noter si vous utilisez ce que vous devez réinitialiser l’indicateur d’activer interruption chaque fois que la WDT arrive à expiration ou la puce se réinitialisera la prochaine fois.

Sketch (cela devrait compiler à environ 1262 octets) :

Throwduino base
UGI 2012
Licence MIT
Écrit pour fonctionner sur ATtiny25/45/85 en utilisant Arduino Tiny core - http://code.google.com/p/arduino-tiny/
Ne compilera pas pour autres Arduinos (ATMega168, ATMega328 etc.)
Assurez-vous de que sélectionner le bon conseil avant de compiler.

Ref :
Broches de l’ADC :
ADC1 = PB2
ADC2 = PB4
ADC3 = PB3

Si vous voulez juste changer la séquence de clignotement, faites-le ici.
valeur par défaut est :
//
const byte flashSeq [3] = {1,4,3} ;  Séquence de clignotement
//
Cela donne 1 flash, pause, quatre clignotements, pause, trois clignotements, pause.
Si vous voulez juste une pause plus longue, utilisez 0 pour chaque 500ms.
Après la séquence, nous attendons pendant 2 secondes avant de répéter.

const byte flashSeq [3] = {1,4,3} ;  Séquence de clignotement.  Modifier cela.

le nombre d’entrées dans la séquence de clignotement.
const byte seqLength = sizeof(flashSeq) ;

Maintenant nous allons faire un throwie pour cette séquence...

const int LEDpin = 4 ; Bien que ce soit dans une constante, il y a beaucoup d’accès direct au port
Je n’essaierais pas de changer cela sans aller throu' la totalité du code.

unsigned int seuil = 10 ; Nous allons définir cela correctement pendant l’installation

Cela met en place des bibliothèques et des définitions utilisées avec la fonction Sleep
#include < avr/sleep.h >
#include < avr/wdt.h >
#ifndef DRAS
#define DRAS (sfr, bit) (_SFR_BYTE(sfr) & = ~_BV(bit))
#endif
#ifndef sbi
#define sbi (sfr, bit) (_SFR_BYTE(sfr) | = _BV(bit))
#endif

ISR(WDT_vect) {WDTCR| = B01000000;} / / reset Watchdog Timer Interrupt mode chaque fois.

Déconner avec certains registres à éteindre trucs et définissez des références.
void setup() {}
ADCSRB & = B10111111 ; désactiver comparitor
ACSR | = B10000000 ; Mettez hors tension comparitor
ADCSRA | = B10000000; / / mettez le ADC
DDRB & = B11100000 ; Mettez les à l’entrée
DDRB| = B00011010 ; La valeur 1, 3 et 4 en sortie
PORTB & = B11110111 ; Set PB3 faible - il s’agissait pour la phase de test.  Peut sans doute être supprimé maintenant.
PRR & = B11111110 ; claire ADC disable bit en puissance réduction Reg
analogReference(6) ; 2.56v interne de référence avec aucune déviation - INTERNAL2v56NB-

Montrer que nous sommes éveillés :
Flash(3) ;  Trois clignotements - nous sommes en cours d’exécution.


Définissez le seuil de détection lumineuse durant les premières 40 secondes.
Nous prenons 148 Mensurations, bin les 20 premiers et puis moyenne la prochaine 128.
total unsigned int = 0 ;
pour (rep octets = 0; rep < 148 ; rep ++) {}
int value=lightLevel() ;
int valeur = 10 ;
if(REP>19) {}
valeur total += ; Teyssandier au total 128 lectures
}
Flash(value) ;

DDRB & = B11100000 ; Mettez les à l’entrée
setup_watchdog(4) ;
system_sleep(); / / sommeil deuxième trimestre
DDRB| = B00011010 ; La valeur 1, 3 et 4 en sortie
PORTB & = B1110000 ; Tout bas
}
seuil = (total >> 7) ; la valeur seuil de point (fracture totale de 128) moyen.

Flash(THRESHOLD) ; C’est principalement pour des fins de débogage.
}

Boucle principale
On mesure le niveau de lumière.  S’il est faible alors nous flash notre séquence puis le sommeil pendant 2 secondes.
Si la lumière niveau élevé, nous dormons pour 8 s.
void loop() {}
analogReference(6) ; 2.56v interne de référence avec aucune dérivation

Mesurer le niveau de lumière et si elle est assez basse, afficher notre séquence flash
Si (lightLevel() < seuil) {}
pour (séquence d’octets = 0; séquence < seqLength ; séquence ++)
Flash(flashSeq[Sequence]) ;
Si nous étions clignotant, nous dormons maintenant pendant 2 secondes
DDRB & = B11100000 ; Mettez les à l’entrée
setup_watchdog(7) ;
system_sleep(); / / sommeil pendant deux secondes
DDRB| = B00011010 ; La valeur 1, 3 et 4 en sortie
PORTB & = B11110111 ; PB3 faible.
}
else {}
Si nous n’étions pas clignote puis nous dormons pour 8 s
DDRB & = B11100000 ; Mettez les à l’entrée
setup_watchdog(9) ;
system_sleep(); / / sommeil pendant deux secondes
DDRB| = B00011010 ; La valeur 1, 3 et 4 en sortie
PORTB & = B11110111 ; PB3 faible.
}

} / / fin de boucle principale

Mesurer le niveau de luminosité en regardant la tension générée par LED connecté à D4 (A2) en broche 3 de la puce.
Sortie et faible pour commencer à s’acquitter de toute accumulation de charge - ne sais pas si nous en avons besoin
int lightLevel() {}
pinMode (LEDpin, sortie) ;
digitalWrite (LEDpin, basse) ;
delayMicroseconds(50) ;
pinMode (entrée, LEDpin) ;
delayMicroseconds(100) ; Laissez-le se stabiliser en tant qu’entrée à nouveau
unsigned int valeur = analogRead(A2) ;
retourne la valeur ;
}

Flash de routine - 70ms, 250 ms désactivé
Répéter certain nombre de fois et ensuite une pause 500ms
void flash(byte No) {}
pinMode (LEDpin, sortie) ;

if (!. Non) {/ / si nous recevons un zéro, juste faire une pause.
DDRB & = B11100000 ; Mettez les à l’entrée
setup_watchdog(5) ;
system_sleep(); / / sommeil pendant 500 ms
DDRB| = B00011010 ; La valeur 1, 3 et 4 en sortie
PORTB & = B11110111 ; PB3 faible.
}

Si nous avions un nombre différent de zéro, des bouffées de chaleur, nous les ferons maintenant
pour (rep octets = 0; rep < non ; rep ++) {}
DDRB| = B00011010 ; La valeur 1, 3 et 4 en sortie
PORTB & = B11110111 ; PB3 faible.
PORTB| = B00010000 ; PB4 haute
digitalWrite (LEDpin, élevé) ;
Delay(70) ;
PORTB & = B11101111 ; PB4 faible.
DDRB & = B11100000 ; Mettez les à l’entrée
digitalWrite(LEDpin,LOW) ;
setup_watchdog(4) ; WDT 3 = 128MS
system_sleep() ;
}

Faire une pause (sleep)
DDRB & = B11100000 ; Mettez les à l’entrée
setup_watchdog(5) ; WDT 5 = 500MS
system_sleep(); / / sommeil
DDRB| = B00011010 ; La valeur 1 et 3 en sortie
PORTB & = B11110111 ; PB3 faible.
}

Réglage timer chien de garde
C’est spécifique à la ATTiny85 (+ tiny45, & tiny25) et ne sera pas compiler pour ATMega328 etc..
0 = 16ms, 1 = 32ms, 2 = 64ms, 3 = 128ms, 4 = 250 ms, 5 = 500ms
6 = 1 sec, 7 = 2 sec, 8 = 4 s, 9 = 8sec
void setup_watchdog (int période) {}

valeur d’octet ;
Si période (période > 9) = 9 ;
valeur = période & B111 ;
Si value| (période > 7) = (1 << 5) ;
value| = (1 << WDCE) ;

MCUSR & = ~ (1 << WDRF) ;
démarrer le cycle d’horloge-4-séquence chronométrée
WDTCR | = (1 << WDCE) | (1 << WDE) ;
Définissez la nouvelle valeur de délai d’attente de chien de garde
WDTCR = valeur ;
WDTCR | = _BV(WDIE) ;
}

mettre le système en état de veille
système se réveille wtchdog est expiré
void system_sleep() {}
CBI(ADCSRA,Aden) ;                    commutateur analogique/Digitalconverter OFF

set_sleep_mode(SLEEP_MODE_PWR_DOWN) ; mode "veille" est défini ici
sleep_enable() ;

sleep_mode() ;                        Système dort ici

sleep_disable() ;                     Système continue l’exécution ici watchdog expiré
SBI(ADCSRA,Aden) ;                    commutateur analogique-Digitalconverter ON
PRR & = B11111110 ; claire ADC disable bit en puissance réduction Reg
}