microcontrolador muy ligero de baja potencia con memoria?

9

He construido un par de proyectos usando arduino. Para un nuevo proyecto, quiero registrar la temperatura de la superficie de la piel frente al tiempo (solo unas pocas veces al día) y posiblemente otra información fácil de obtener, como el voltaje.

Necesito hacer todo lo más pequeño y liviano posible (ya que mediría la temperatura de la piel de un mamífero pequeño), es decir, por debajo de 5 g, más ligero si es posible, idealmente 3 g, incluida la batería, para que no altere los 50 100 g de animal demasiado.

¿Leí que podría ser posible cambiar el arduino pro mini para usar menos corriente al deshacerse del regulador de voltaje? ¿Pero quizás es más sensato cambiar por completo y aprender a programar otro tipo de microcontrolador que alguien pueda recomendar? Tendría que ser posible operarlo directamente desde una celda de monedas liviana o una batería liviana similar. (Tampoco estoy seguro de cómo encontrar una batería ligera de 3.3V para el arduino pro mini, supongo que existen, pero hasta ahora solo puedo encontrar baterías de 3V). Si tiene memoria integrada para ahorrar temperatura cada pocas horas, que podría descargarse más tarde, sería ideal (también me interesaría si alguien tiene recomendaciones para la memoria). Sé que es posible comprar un "Ibutton"

SH
fuente
... lo siento, mi pregunta real es: ¿Podría alguien recomendarme un microcontrolador ligero de baja potencia adecuado, o crees que debería continuar con arduino e intentar adaptarlo? ¡Cualquier ayuda es muy apreciada!
SH
Podría usar un ATmega328 a 8MHz, alimentado con dos baterías de 1.5V en serie. Luego, podría continuar usando las bibliotecas Arduino e IDE.
jfpoilpret
@jfpoilpret, 2AA sería demasiado pesado, creo. Una celda de moneda 2032 de 3V podría ser mejor.
Dat Ha
2
Dependiendo de cómo lo programe, un ATmega328 o un ATtiny84 u 85 pueden tener un consumo de corriente muy ligero y funcionar con una celda de litio CR2032 durante bastante tiempo. Sin embargo, reducir el consumo de energía de un circuito (ATmel o cualquier otro) puede volverse bastante complicado.
jfpoilpret

Respuestas:

15

Creé un pequeño localizador de antorchas que usaba un ATtiny85 alimentado por una celda de botón (CR2032). Se parece a esto:

Localizador de antorchas

Otro lado:

Otro lado

Que actualmente pesa 5,9 g. El soporte de la batería pesa 1,6 g, por lo que podría ahorrarlo haciendo un soporte más liviano (tal vez un poco de plástico para aislar y soldar directamente a la batería). El zócalo del chip pesa al menos 0,5 g, por lo que también puede guardarlo soldando a los pines del procesador. Así que hemos bajado a 3.8g.

El ATtiny85 tiene 512 bytes de EEPROM que puede usar para registrar lecturas. No estoy seguro acerca de un reloj si está tratando de ahorrar peso, pero si lo inicia a una hora conocida, podría tener una estimación razonable del tiempo utilizando la millis()función para encontrar milisegundos desde el inicio.

Hice otro hace un tiempo que parpadea un LED cada dos segundos:

LED intermitente

Eso es similar El procesador está allí (boca abajo debajo del zócalo del chip) y la batería está debajo. Eso pesa 6 g. ¡La batería ha durado un par de años, y eso parpadea un LED cada dos segundos!

En lugar del LED, podría tener un termistor para leer la temperatura.

Puede programarlo para tomar una lectura cada pocas horas y guardarlo en EEPROM. Luego, cuando se le indique (por ejemplo, uniendo un par de pines), podría enviar las lecturas a otro pin (a través de serie).

Podría ahorrar más peso usando dispositivos SMD (montados en la superficie), y quizás usando una pequeña placa de circuito que podría inventar.


Código

El código para mi localizador de antorchas está abajo. Es interesante el hecho de que duerme la mayor parte del tiempo. También duerme durante el muestreo de ADC. Aunque en mi caso estoy midiendo un LDR (resistencia dependiente de la luz), el código para medir un termistor sería similar. Solo necesita hacer algunos cálculos al final para convertir la lectura en temperatura.

// ATtiny85 torch detector
// Author: Nick Gammon
// Date: 25 February 2015

// ATMEL ATTINY 25/45/85 / ARDUINO
// Pin 1 is /RESET
//
//                  +-\/-+
// Ain0 (D 5) PB5  1|    |8  Vcc
// Ain3 (D 3) PB3  2|    |7  PB2 (D 2) Ain1 
// Ain2 (D 4) PB4  3|    |6  PB1 (D 1) pwm1
//            GND  4|    |5  PB0 (D 0) pwm0
//                  +----+

/*

  Pin 2 (PB3) <-- LDR (GL5539) --> Pin 7 (PB2) <----> 56 k <----> Gnd

  Pin 5 (PB0) <---- LED ---> 100 R <-----> Gnd

*/


#include <avr/sleep.h>    // Sleep Modes
#include <avr/power.h>    // Power management
#include <avr/wdt.h>      // Watchdog timer

const byte LED = 0;          // pin 5 
const byte LDR_ENABLE = 3;   // pin 2
const byte LDR_READ = 1;     // Ain1 (PB2) pin 7
const int LIGHT_THRESHOLD = 200;  // Flash LED when darker than this

 // when ADC completed, take an interrupt 
EMPTY_INTERRUPT (ADC_vect);

// Take an ADC reading in sleep mode (ADC)
float getReading (byte port)
  {
  power_adc_enable() ;
  ADCSRA = bit (ADEN) | bit (ADIF);  // enable ADC, turn off any pending interrupt

  // set a2d prescale factor to 128
  // 8 MHz / 128 = 62.5 KHz, inside the desired 50-200 KHz range.

  ADCSRA |= bit (ADPS0) | bit (ADPS1) | bit (ADPS2); 

  if (port >= A0)
    port -= A0;

#if defined(__AVR_ATtiny85__)  
  ADMUX = (port & 0x07);  // AVcc   
#else   
  ADMUX = bit (REFS0) | (port & 0x07);  // AVcc   
#endif

  noInterrupts ();
  set_sleep_mode (SLEEP_MODE_ADC);    // sleep during sample
  sleep_enable();  

  // start the conversion
  ADCSRA |= bit (ADSC) | bit (ADIE);
  interrupts ();
  sleep_cpu ();     
  sleep_disable ();

  // reading should be done, but better make sure
  // maybe the timer interrupt fired 

  // ADSC is cleared when the conversion finishes
  while (bit_is_set (ADCSRA, ADSC))
    { }

  byte low  = ADCL;
  byte high = ADCH;

  ADCSRA = 0;  // disable ADC
  power_adc_disable();

  return (high << 8) | low;

  }  // end of getReading

// watchdog interrupt
ISR (WDT_vect) 
{
   wdt_disable();  // disable watchdog
}  // end of WDT_vect

#if defined(__AVR_ATtiny85__)  
  #define watchdogRegister WDTCR
#else
  #define watchdogRegister WDTCSR
#endif

void setup ()
  {
  wdt_reset();  
  pinMode (LED, OUTPUT);
  pinMode (LDR_ENABLE, OUTPUT);
  ADCSRA = 0;            // turn off ADC
  power_all_disable ();  // power off ADC, Timer 0 and 1, serial interface
  }  // end of setup

void loop ()
  {
  // power up the LDR, take a reading
  digitalWrite (LDR_ENABLE, HIGH);
  int value = getReading (LDR_READ);
  // power off the LDR
  digitalWrite (LDR_ENABLE, LOW);

  // if it's dark, flash the LED for 2 mS
  if (value < LIGHT_THRESHOLD)
    {
    power_timer0_enable ();
    delay (1);  // let timer reach a known point
    digitalWrite (LED, HIGH);
    delay (2); 
    digitalWrite (LED, LOW);
    power_timer0_disable ();
    }

  goToSleep ();
  }  // end of loop

void goToSleep ()
  {
  set_sleep_mode (SLEEP_MODE_PWR_DOWN);
  noInterrupts ();       // timed sequence coming up

  // pat the dog
  wdt_reset();  

  // clear various "reset" flags
  MCUSR = 0;     
  // allow changes, disable reset, clear existing interrupt
  watchdogRegister = bit (WDCE) | bit (WDE) | bit (WDIF);
  // set interrupt mode and an interval (WDE must be changed from 1 to 0 here)
  watchdogRegister = bit (WDIE) | bit (WDP2) | bit (WDP1) | bit (WDP0);    // set WDIE, and 2 seconds delay

  sleep_enable ();       // ready to sleep
  interrupts ();         // interrupts are required now
  sleep_cpu ();          // sleep                
  sleep_disable ();      // precaution
  }  // end of goToSleep 
Nick Gammon
fuente
para su "cosa" de led intermitente, ¿no sería mejor usar un chip temporizador 555? Creo que usar un ATtiny es un desperdicio.
Dat Ha
2
Iba por un bajo consumo de energía. El procesador duerme la mayor parte del tiempo y luego parpadea el LED durante aproximadamente un milisegundo.
Nick Gammon
¡Gracias! parece posible usar esto, tendrá que intentar aprender a configurarlo y programarlo.
SH
Re “En lugar del LED, podría tener un termistor para leer la temperatura”, uno podría leer el canal 15 del ADC, el sensor de temperatura incorporado. [Sin embargo, no es muy sensible o preciso.]
James Waldby - jwpat7
Su buscador de antorchas es una maravillosa pieza de diseño y la estimación del consumo de energía que hizo está muy en el espíritu del espíritu de "ingeniero tanto como lo necesita" de Ardunio. Todo esto calentó los berberechos de mi corazón (donde sea que estén).
cjs
8

Yo personalmente sugeriría un ATtiny 45/85. Es más o menos un AVR pequeño con 5 GPIO. Puede programarlo con Arduino IDE y usar Arduino como ISP. Si puede diseñar su propia PCB personalizada, una versión SMD del ATtiny es pequeña, baja y compacta. El circuito total para hacer que la función ATtiny también sea mínimo.

ingrese la descripción de la imagen aquí

Además, a una velocidad de reloj baja (0-4MHz), puede alimentar el ATtiny a un voltaje tan bajo como 1.8V. Probablemente incluso podría ejecutarlo a 1.5V, pero esto no es totalmente recomendable. Si desea estar seguro, una celda de moneda de 3V será pequeña, plana y puede durar probablemente muchos años. También es un poco más seguro en comparación con los lipos que tienen muchos riesgos, especialmente si lo montas en un animal que realmente no puedes controlar.

ingrese la descripción de la imagen aquí

También recomendaría componentes SMD si es posible. Permite que todos los componentes estén más bajos y no daña ni raspa la piel de la persona / animal que está monitoreando.

Dat Ha
fuente
¡Parece que ambos tuvimos la misma idea!
Nick Gammon
¡¡Gracias!! esto se ve genial, realmente aprecio la ayuda! Intentaré aprender los conceptos básicos sobre cómo configurar el microcontrolador, etc. desde el primer circuito y, una vez que lo haga funcionar, probablemente cambie a los componentes SMD como sugirió. Creo de manera realista que tendré que hacer eso para hacerlo lo suficientemente pequeño.
SH