Universal Watchdog en ATtiny13

Un temporizador de vigilancia externo es una muleta para los desarrolladores pobres que no pueden desarrollar un programa que funcione correctamente para microcontroladores o un circuito de funcionamiento estable.

Además, el WDT incorporado está disponible en la mayoría de los microcontroladores modernos.

Pero hay momentos en los que tiene que lidiar con una placa o módulo terminado con ciertos problemas. Hice mi primer WDT para lidiar con los raros, pero a veces todavía se producen bloqueos del ESP8266. Además, el restablecimiento parcial no se guardó en ese momento y el gabinete ESP no quería volver a conectarse a WiFi. Distorsionar el poder con un WDT externo resolvió el problema.

El segundo problema surgió con el controlador GSM Elecrow ATMEGA 32u4 A9G . Aquí, rara vez se producían bloqueos de la tarjeta SIM. (Por cierto, el mismo problema ocurre con los módems USB 3G y 4G). Para combatir esta congelación, debe distorsionar el poder de la SIM-ke. Y parece que incluso el módem GSM tiene una conclusión para esto, pero esta característica no está incluida en los circuitos del dispositivo. Y para lograr la máxima fiabilidad, nuevamente tuve que recurrir a un perro guardián externo.

No repetí el circuito en el temporizador 555. Demasiados defectos que ella reveló:

• Grandes dimensiones y bastante flejado.
• Ajuste incómodo del tiempo de respuesta con una resistencia de sintonización
• Tiempo de reinicio bastante largo (se requiere descarga de condensador)
• Bueno, la caída potencial de MK con un nivel bajo en la salida del temporizador, cuando el temporizador simplemente deja de funcionar.
• Y no encontré proyectos de OpenSource en Internet que cumplieran plenamente mis requisitos.

Requisitos para el nuevo WDT

• Bajo costo del dispositivo, facilidad de fabricación y pequeñas dimensiones.
• Control de cambio periódico de nivel lógico 0/1 en la entrada
• Ajuste simple del tiempo de respuesta (como opción, una opción de intervalos predefinidos)

Desarrollo de hierro

El microcontrolador ATtiny13 fue elegido como el microcircuito principal. Sus capacidades eran más que suficientes para mi tarea. Y el precio, teniendo en cuenta la reducción de los elementos de flejado, es casi el mismo que el del microcircuito 555.



Cinco conclusiones MK (RESET decidió no tocar) se distribuyeron de la siguiente manera:

1. Salida del temporizador
2. Restablecer entrada
3. Las tres conclusiones restantes son los tiempos de respuesta.

Para cambiar la potencia, se utiliza un MOSFET de canal P. Cualquier caso compatible es adecuado, pero es aconsejable tomarlo con el llamado "nivel de control lógico", es decir, se abre completamente desde un bajo voltaje de 3-5V: IRLML2502, AO3415, etc. A pesar de su pequeño tamaño, este transistor puede controlar una carga de 4A. Si necesita cambiar algo más, puede conectar directamente un relé de 5V a esta salida.

El LED se ilumina cuando se activa el temporizador y se apaga la unidad principal.

El conector principal para conectar a la placa del microcontrolador tiene cuatro salidas

1. Autobús común
2. Entrada - restablecer temporizador
3. Salida de + 5V (controlada por temporizador)
4. Entrada + 5 V

Dos conectores: el programador ICSP y los puentes de alimentación no se pueden instalar en la placa. Actualice el microcontrolador en el programador con anticipación y configure el tiempo de respuesta con un puente constante.

Lista de partes

• MK Attiny13-SSU ~ $ 0.3 (con la compra de 10 piezas)
• Canal P MOSFET IRLML5203 - $ 0.09 (pedido 50 piezas ) o MOSFET AO3415 - $ 0.05
• 1K SMD1206 Resistencia
• Resistencia 470 SMD1206
• 1206 LED de cualquier color
• Conectores PLS-6, PLS-3 y PLS-4R (PLD-3 y PLS-4R) - normalmente cortados de peines largos

Fabricación

Las tablas resultaron ser pequeñas: 18 × 22 mm. Difundo dos opciones:

Para fabricación de una sola cara por LUT:





Y para ordenar en la fábrica con un diseño mejorado y transiciones entre las partes. (Ordenaré de los chinos, en ocasiones)





La tecnología del hogar ofrece algo como este prototipo.

Firmware

Para el firmware utilicé un programador casero basado en Arduino Nano



Lo programé en Arduino IDE con soporte instalado para Attiny13 - MicroCore . La última versión del IDE tenía problemas con el programador ArduinoISP, pero funcionó bien en la versión del Arduino IDE 1.6.13. El equipo amistoso arduino.cc no tenía el deseo de descubrir qué estaba mal allí)))



Tinku sintonizado para funcionar desde un resonador interno con una frecuencia de 1.2 MHz. El programa es simple: configuramos las entradas / salidas, leemos PB2-PB4 y determinamos el tiempo de respuesta, configuramos el temporizador y pasamos al modo inactivo. Según la interrupción del temporizador, determinamos el estado de la entrada de control. Si el estado ha cambiado a lo contrario, reinicie el contador. Si las lecturas del contador excedieron el tiempo de respuesta establecido, distorsionamos la potencia de salida.

#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; } 

Todo el código cabe en 340 bytes, exactamente un tercio de kilobyte de memoria pequeña. El funcionamiento del temporizador se verifica simplemente, dependiendo del tiempo de instalación, el LED se ilumina periódicamente durante 1 segundo. En este momento, el voltaje de salida Vout 5V desaparece. Si el contacto de "entrada" se cierra a tierra con una frecuencia de 1 segundo, el restablecimiento no se realiza y el LED no se enciende.

La gestión de WDT en el programa principal es

 #define PIN_WDT 5 //GPIO ,   WDT bool WDT_flag = false; //    void WDT_begin(){ pinMode(PIN_WDT,OUTPUT); digitalWrite(PIN_WDT,WDT_FLAG); } //   (   1    WDT,  ) void WDT_reset(){ if( WDT_flag)WDT_flag = false; else WDT_flag = true; digitalWrite(PIN_WDT,WDT_FLAG); } 

Eso es todo Todos los archivos fuente, circuitos y placas de circuitos se pueden descargar desde
Github