microcontrôleur basse consommation très léger avec mémoire?

J'ai construit quelques projets en utilisant Arduino. Pour un nouveau projet, je veux enregistrer la température de la surface de la peau en fonction du temps (juste peut-être quelques fois par jour) et éventuellement d'autres informations faciles à obtenir telles que la tension.

J'ai besoin de tout rendre aussi petit et léger que possible (car il s'agirait de mesurer la température de la peau d'un petit mammifère), c'est-à-dire en dessous de 5g, plus léger si possible, idéalement 3g, y compris la batterie, afin qu'il ne dérange pas le 50- 100g animal de trop.

J'ai lu qu'il pourrait être possible de changer l'arduino pro mini pour utiliser moins de courant en se débarrassant du régulateur de tension? mais peut-être est-il plus judicieux de changer complètement et d'apprendre à programmer un autre type de microcontrôleur que quelqu'un pourrait recommander? Il devrait être possible de le faire fonctionner directement à partir d'une pile bouton légère ou d'une batterie légère similaire. (Je ne sais pas non plus comment trouver une batterie 3.3V légère pour l'arduino pro mini, je suppose qu'elles existent mais je ne peux trouver que des batteries 3V jusqu'à présent). S'il a une mémoire intégrée pour enregistrer la température toutes les quelques heures, ce qui pourrait être téléchargé plus tard, ce serait idéal (je serais également intéressé si quelqu'un avait des recommandations pour la mémoire). Je sais qu'il est possible d'acheter un "Ibutton"

J'ai fabriqué un petit localisateur de torche qui utilisait un ATtiny85 alimenté par une pile bouton (CR2032). Cela ressemble à ceci:

Autre côté:

Cela pèse actuellement 5,9 g. Le support de batterie pèse 1,6 g, vous pouvez donc économiser cela en fabriquant un support plus léger (peut-être un peu de plastique pour l'isolation et à souder directement à la batterie). Le support de puce pèse au moins 0,5 g, vous pouvez donc également l'enregistrer en le soudant aux broches du processeur. Nous sommes donc tombés à 3,8 g.

L'ATtiny85 possède 512 octets d'EEPROM que vous pouvez utiliser pour enregistrer les lectures. Je ne suis pas sûr d'une horloge si vous essayez de gagner du poids, mais si vous la démarrez à une heure connue, vous pouvez avoir une estimation raisonnable du temps en utilisant la millis()fonction pour trouver des millisecondes depuis le démarrage.

J'en ai fait une autre il y a un moment qui fait clignoter une LED toutes les deux secondes:

C'est pareil. Le processeur est là (à l'envers sous le support de puce) et la batterie est en dessous. Cela pèse 6g. La batterie a duré quelques années, et cela fait clignoter une LED toutes les deux secondes!

Au lieu de la LED, vous pourriez avoir une thermistance pour lire la température.

Vous pouvez le programmer pour prendre une lecture toutes les quelques heures et l'enregistrer dans l'EEPROM. Ensuite, lorsque vous y êtes invité (par exemple en joignant quelques broches), il peut sortir les lectures vers une autre broche (via série).

Vous pourriez économiser plus de poids en utilisant des appareils SMD (montés en surface), et peut-être en utilisant une petite carte de circuit imprimé, vous pourriez vous maquiller.

Code

Le code de mon localisateur de torche est ci-dessous. Il est intéressant de noter qu'il dort la plupart du temps. Il dort également pendant l'échantillonnage ADC. Bien que dans mon cas, je mesure une LDR (résistance dépendante de la lumière), le code de mesure d'une thermistance serait similaire. Il vous suffit de faire quelques calculs à la fin pour transformer la lecture en température.

// 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 

Je suggère personnellement un ATtiny 45/85. C'est à peu près un petit AVR avec 5 GPIO. Vous pouvez le programmer avec l'IDE Arduino et utiliser l'Arduino comme FAI. Si vous pouvez concevoir votre propre PCB personnalisé, une version SMD de l'ATtiny est petite, basse et compacte. Le circuit total pour faire la fonction ATtiny est également minime.

De plus, à une faible vitesse d'horloge (0-4 MHz), vous pouvez alimenter l'ATtiny à une tension aussi faible que 1,8 V. Vous pourriez probablement même le faire fonctionner à 1,5 V, mais ce n'est pas totalement recommandé. Si vous voulez être en sécurité, une pile bouton de 3 V sera petite, plate et peut durer probablement plusieurs années. Il est également un peu plus sûr que les lipos qui présentent de nombreux risques, surtout si vous le montez sur un animal que vous ne pouvez pas vraiment contrôler.

Je recommanderais également des composants SMD si possible. Il permet à tous les composants d'être plus bas et ne blesse ni n'égratigne la peau de la personne / de l'animal que vous surveillez.