Une horloge de surveillance externe est une béquille pour les développeurs pauvres qui ne peuvent pas développer un programme fonctionnant correctement pour les microcontrôleurs ou un circuit fonctionnant de manière stable.
De plus, le WDT intégré est disponible dans la plupart des microcontrôleurs modernes.
Mais il y a des moments où vous devez gérer une carte ou un module fini avec certains problèmes.
J'ai fait mon premier WDT pour faire face aux
blocages rares, mais toujours présents de l'ESP8266. De plus, la réinitialisation logicielle n'a pas été enregistrée à ce moment-là et l'armoire ESP ne voulait pas se reconnecter au WiFi. Déformer l'alimentation avec un WDT externe a résolu le problème.
Le deuxième problème est survenu avec le
contrôleur Elecrow ATMEGA 32u4 A9G GSM . Ici, il y avait très rarement des gels de la carte SIM. (Soit dit en passant, le même problème se produit avec les modems USB 3G et 4G). Pour lutter contre ce gel, vous devez déformer l'alimentation du SIM-ke. Et il semble que même le modem GSM ait une conclusion à cela, mais cette fonctionnalité n'est pas incluse dans les circuits de l'appareil. Et pour atteindre une fiabilité maximale, j'ai de nouveau dû me tourner vers un chien de garde externe.
Je n'ai pas répété le circuit sur la minuterie 555. Trop de défauts, elle a révélé:
- Grandes dimensions et beaucoup de cerclage
- Réglage non pratique du temps de réponse avec une résistance d'accord
- Temps de réinitialisation assez long (décharge du condensateur requise)
- Eh bien, le blocage potentiel de MK avec un faible niveau à la sortie de la minuterie, lorsque la minuterie cesse de fonctionner.
- Et je n'ai pas trouvé de projets OpenSource sur Internet qui répondaient pleinement à mes exigences.
Conditions requises pour le nouveau WDT
- Faible coût de l'appareil, facilité de fabrication et petites dimensions
- Contrôle du changement périodique du niveau logique 0/1 en entrée
- Réglage simple du temps de réponse (en option, choix d'intervalles prédéfinis)
Développement du fer
Le
microcontrôleur ATtiny13 a été choisi comme microcircuit principal. Ses capacités étaient plus que suffisantes pour ma tâche. Et le prix, compte tenu de la réduction des éléments de cerclage, est presque le même que celui de 555 microcircuits.
Cinq conclusions MK (RESET a décidé de ne pas toucher) ont été distribuées comme suit:
- Sortie minuterie
- Réinitialiser l'entrée
- Les trois conclusions restantes sont les temps de réponse.
Pour la commutation de puissance, un MOSFET à canal P est utilisé. Tout boîtier compatible convient, mais il est conseillé de le prendre avec le soi-disant "niveau de contrôle logique" - c'est-à-dire qu'il s'ouvre complètement à partir d'une basse tension de 3-5V: IRLML2502, AO3415, etc. Malgré sa petite taille, ce transistor est capable de contrôler une charge de 4A. Si vous devez commuter autre chose, vous pouvez directement connecter un relais 5V à cette sortie.
La LED s'allume lorsque la minuterie est activée et que l'unité principale est éteinte.
Le connecteur principal pour la connexion à la carte microcontrôleur a quatre sorties
- Bus commun
- Entrée - réinitialisation de la minuterie
- Sortie + 5V (contrôlée par minuterie)
- Entrée + 5V
Deux connecteurs - le programmateur ICSP et les cavaliers d'alimentation ne peuvent pas être installés sur la carte. Flashez à l'avance le microcontrôleur dans le programmateur et réglez le temps de réponse avec un cavalier constant.
Liste des pièces
Fabrication
Les planches se sont avérées petites - 18 × 22 mm. J'étale deux options:
Pour la fabrication simple face par LUT:
Et pour commander à l'usine avec un design amélioré et des transitions entre les parties. (Je vais commander des chinois, à l'occasion)
La technologie domestique donne quelque chose comme ce prototype.
Firmware
Pour le firmware, j'ai utilisé un programmateur maison basé sur Arduino Nano
J'ai programmé dans
l'IDE Arduino avec le support installé pour
Attiny13 - MicroCore . La dernière version de l'IDE a eu des problèmes avec le programmeur ArduinoISP, mais cela a bien fonctionné dans la version de l'Arduino IDE 1.6.13. L'équipe amicale arduino.cc n'avait pas envie de
comprendre ce qui avait été
gâché là- bas)))
Tinku réglé pour fonctionner à partir d'un résonateur interne avec une fréquence de 1,2 MHz. Le programme est simple - nous configurons les entrées / sorties, lisons PB2 -PB4 et déterminons le temps de réponse, réglons la minuterie et passons en mode IDLE. En fonction de l'interruption du temporisateur, nous déterminons l'état de l'entrée de commande. Si l'état est passé à l'inverse, réinitialisez le compteur. Si le compteur lit dépasse le temps de réponse défini, nous déformons la puissance de sortie.
#define F_CPU 1200000UL #include <avr/io.h> #include <util/delay.h> #include <avr/interrupt.h> boolean pb1_state; volatile uint16_t pb1_count; // TIMER0 ISR(TIM0_OVF_vect){ pb1_count++; } int main(){ // PB0 DDRB |= (1 << PB0); // pinMode(PB0, OUTPUT); PORTB &= ~(1 << PB0); // digitalWrite(PB0, LOW);} // PB1 DDRB &= ~(1 << PB1); // pinMode(PB1, INPUT_PULLUP); PORTB |= (1 << PB1); // PB2 DDRB &= ~(1 << PB2); // pinMode(PB2, INPUT_PULLUP); PORTB |= (1 << PB2); // PB3 DDRB &= ~(1 << PB3); // pinMode(PB3, INPUT_PULLUP); PORTB |= (1 << PB3); // PB4 DDRB &= ~(1 << PB4); // pinMode(PB4, INPUT_PULLUP); PORTB |= (1 << PB4); // PB2,PB3,PB4 ( ) (, = TM/4 ) uint16_t TM = 0; bool pb2 = false; bool pb3 = false; bool pb4 = false; if( PINB & (1 << PINB2) )pb2 = true; if( PINB & (1 << PINB3) )pb3 = true; if( PINB & (1 << PINB4) )pb4 = true; if( pb2 == true && pb3 == true && pb4 == true )TM = 4; // 1 else if( pb2 == false && pb3 == true && pb4 == true )TM = 8; // 2 else if( pb2 == true && pb3 == false && pb4 == true )TM = 20; // 5 else if( pb2 == false && pb3 == false && pb4 == true )TM = 40; // 10 else if( pb2 == true && pb3 == true && pb4 == false )TM = 80; // 20 else if( pb2 == false && pb3 == true && pb4 == false )TM = 120; // 30 else if( pb2 == true && pb3 == false && pb4 == false )TM = 240; // 60 else if( pb2 == false && pb3 == false && pb4 == false )TM = 480; // 120 pb1_count = 0; pb1_state = false; // ADC PRR = (1<<PRADC); // shut down ADC // TIMSK0 = (1<<TOIE0); // TIMER0 TCCR0B = (1<<CS02) | (1<<CS00); // 1/1024 // MCUCR &= ~(1<<SM1); // idle mode MCUCR &= ~(1<<SM0); // idle mode MCUCR |= (1<<SE); sei(); while(1) { // asm("sleep"); // TIMSK0 &= ~ (1<<TOIE0); // TIMER0 // PB1 bool pb1 = false; if( PINB & (1 << PINB1) )pb1 = true; // , if( pb1 != pb1_state )pb1_count = 0; pb1_state = pb1; // if( pb1_count >= TM ){ PORTB |= (1 << PB0); // digitalWrite(PB0, HIGH);} _delay_ms(1000); // PORTB &= ~(1 << PB0); // digitalWrite(PB0, LOW);} pb1_count = 0; // } TIMSK0 = (1<<TOIE0); // TIMER0 sei(); } return 0; }
Tout le code tient dans 340 octets - exactement un tiers d'un kilo-octet de mémoire tinky. Le fonctionnement de la minuterie est vérifié simplement - en fonction du temps d'installation - la LED s'allume périodiquement pendant 1 seconde. A ce moment, la tension de sortie Vout 5V disparaît. Si le contact «entrée» est fermé à la masse avec une fréquence de 1 seconde, la réinitialisation n'est pas effectuée et la LED ne s'allume pas.
La gestion du WDT dans le programme principal est la suivante
#define PIN_WDT 5
C'est tout. Tous les fichiers source, circuits et cartes de circuits imprimés peuvent être téléchargés depuis
Github