microcontrollore a bassa potenza molto leggero con memoria?

Ho creato un paio di progetti usando Arduino. Per un nuovo progetto voglio registrare la temperatura della superficie della pelle rispetto al tempo (forse solo poche volte al giorno) e probabilmente altre informazioni facili da ottenere come la tensione.

Ho bisogno di rendere tutto il più piccolo e leggero possibile (poiché misurerebbe la temperatura della pelle su un piccolo mammifero), cioè inferiore a 5 g, se possibile più leggero, idealmente 3 g, compresa la batteria, in modo da non alterare il 50- 100 g di animali in eccesso.

Ho letto che potrebbe essere possibile cambiare arduino pro mini per utilizzare meno corrente eliminando il regolatore di tensione? ma forse è più sensato cambiare completamente e imparare a programmare un altro tipo di microcontrollore che qualcuno potrebbe raccomandare? Dovrebbe essere possibile gestirlo direttamente da una pila a bottone leggera o una batteria leggera simile. (Non sono nemmeno sicuro di come trovare una batteria leggera da 3,3 V per arduino pro mini, suppongo che esistano, ma finora riesco a trovare solo batterie da 3 V). Se ha memoria integrata per risparmiare la temperatura ogni poche ore che potrebbe essere scaricato in seguito sarebbe l'ideale (sarei anche interessato se qualcuno avesse consigli per la memoria). So che è possibile acquistare un "Ibutton"

Ho creato un piccolo localizzatore di torce che utilizzava un ATtiny85 alimentato da una cella a bottone (CR2032). Sembra così:

L'altra parte:

Che attualmente pesa 5,9 g. Il portabatteria pesa 1,6 g in modo da poterlo risparmiare creando un supporto più leggero (forse un po 'di plastica per l'isolamento e saldando direttamente alla batteria). Il socket del chip pesa almeno 0,5 g, quindi è possibile risparmiare anche saldando ai pin del processore. Quindi siamo scesi a 3,8 g.

ATtiny85 ha 512 byte di EEPROM che è possibile utilizzare per registrare le letture. Non sono sicuro di un orologio se stai cercando di risparmiare peso, ma se lo avvii in un momento noto, potresti avere una stima ragionevole del tempo utilizzando la millis()funzione per trovare i miliisecondi dall'avvio.

Ne ho fatto un altro poco fa che fa lampeggiare un LED ogni paio di secondi:

Questo è simile Il processore è lì (sottosopra sotto la presa del chip) e la batteria è sotto. Pesa 6g. La batteria è durata un paio d'anni e questo lampeggia un LED ogni paio di secondi!

Invece del LED potresti avere un termistore per leggere la temperatura.

Potresti programmarlo per prendere una lettura ogni poche ore e salvarlo su EEPROM. Quindi, quando richiesto (ad es. Unendo un paio di pin), potrebbe emettere le letture su un altro pin (via seriale).

Puoi risparmiare più peso usando i dispositivi SMD (montati in superficie) e forse usando un piccolo circuito potresti essere truccato.

Codice

Il codice per il mio localizzatore di torce è sotto. Di interesse è il fatto che dorme la maggior parte del tempo. Dorme anche durante il campionamento ADC. Anche se nel mio caso sto misurando un LDR (resistore dipendente dalla luce), il codice per misurare un termistore sarebbe simile. Hai solo bisogno di fare alcuni calcoli alla fine per trasformare la lettura in una 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 

Personalmente suggerirei un ATtiny 45/85. È praticamente un piccolo AVR con 5 GPIO. È possibile programmarlo con l'IDE Arduino e utilizzare Arduino come ISP. Se puoi progettare il tuo PCB personalizzato, una versione SMD di ATtiny è piccola, bassa e compatta. Anche il circuito totale per rendere la funzione ATtiny è minimo.

Inoltre, a una bassa velocità di clock (0-4 MHz), è possibile alimentare l'ATtiny con una tensione inferiore a 1,8 V. Probabilmente potresti anche eseguirlo a 1,5 V, ma questo non è del tutto raccomandato. Se vuoi essere sicuro, una cella a bottone da 3V sarà piccola, piatta e può durare probabilmente molti anni. È anche un po 'più sicuro rispetto ai lipos che hanno molti rischi, specialmente se lo monti su un animale che non puoi davvero controllare.

Consiglierei anche i componenti SMD, se possibile. Consente a tutti i componenti di essere più bassi e non ferisce né strappa la pelle della persona / animale che si sta monitorando.