Feuchtigkeitsmessung am Attiny - Übertragung mittels 433MHZ

[Daniel G. (dgrone)]

Guten Tag,
ich habe in letzter Zeit ein paar Experimente an einem Attiny85 gemacht.

Mein Plan ist, dass ich Feuchtigkeitswerte von meinen Pflanzen übertrage 
mittels einen RF433 MHZ Sender.

Zudem soll noch der Akkuwert und der Temperaturwert (jeweils 10 Bit 
Werte) übertragen werden.

So, das ganze funktioniert auch schon mit den übertragen und empfangen 
der Werte. Nur ich bin mir nicht sicher, ob mein Schaltplan "ausgereift" 
ist.

Zudem soll es auch Stromgünstig laufen (Knopfzelle im Blumentopf von 3V 
nur ~1x im Jahr wechseln).


Ich bräuchte ein paar Experten, die über meinen Schaltplan gucken.

Kurze Erklärung:
- PC0 ist ein Ausgang, der alle ca. 10 Min aktiv ist. Gibt 3V aus, 
wartet ca 200ms und sendet die Werte über das 433MHZ Modul.
- PB1 ist der digitale Ausgang für das 433MHZ Modul
- PB2 ist mein "roher" 10Bit Temperaturwert. Wird beim Empfangen des 
Wertes umgerechnet.
- PB3 ist mein Feuchtigketiswert (10 Bit). Ein Wiederstand geht auf GND 
und zwei Drähte werden in der Erde einen bestimmten Widerstand haben.
- PB4 ist mein Akkuwert - da bin ich mir unschlüssig, ob das so gemacht 
wird.

Code usw. werde ich später auf mein Blog dafür auch veröffentlichen. Ich 
bin nämlich kein Elektrioniker sondern Informatiker. Daher weiß ich, 
dass der Code richtig sein sollte ;-)

Danke und viele Grüße!

[Jojo S. (Gast)]

funktioniert das Messen der Akkuspannung so wirklich? Ich denke da fehlt 
ein Widerstand für einen Spannungsteiler. Wenn du den ADC so einstellst 
das Vref=VCC ist dann misst du immer 100 %. Die Referenz sollte also auf 
2,56 V oder sogar 1,1 V eingestellt werden und der Spannungsteiler so 
berechnet werden das die max. Eingangsspannung unter der Ref liegt.
Dann findest du hier im Forum noch einen alternativen Feuchtesensor der 
kapazitiv arbeitet, halt also den Vorteil das da keine Kontakte 
korrodieren können.
In deinem Schaltplan fehlt sonst nur noch ein 100 nF Keramikkondensator 
zwischen VCC und GND.

[Daniel G. (dgrone)]

Hallo,
beim Akkuwert habe ich auch noch Probleme. Wie kann ich die 
Referenzspannung denn für den IC einstellen? Bekommt er seine 
Referenzspannung von NRES? Oder vom 3V (von PB0) ein Widerstand nach 
PB4?

Den Kondensator könnte ich noch einbauen. Danke.
Werde mir noch den kapazitiven Sensor hier im Forum angucken.


Am Strom kann man nicht sparen, wenn man beim Attiny85 auf "internal 
1MHZ Clock" programmiert und dann ca. alle 10min oder mehr, oder?

Oder wäre ein Zeitgeber IC, wie der NE555 noch Stromgünstiger?

Gruß

[spess53 (Gast)]

Hi

Da der Sensor mit Gleichspannung läuft ist (auf Dauer) mit Elektrolyse 
zu rechnen.

MfG Spess

[Daniel G. (dgrone)]

jup, darum auch den Tip von Jojo.. Kapazitiven Sensor

[dansam (Gast)]

Hallo,
wäre es vielleicht möglich mal in den Code reinzuschauen?
Schlagen uns seit Wochen damit rum einen Funkschalter zu bauen mit 
jeweils einem Attiny85 an jedem Ende. Das Ganze soll einen Code senden 
und am anderen Ende empfangen. Wenn der Code mit dem einprogrammierten 
übereinstimmt soll der Schalter ausgelöst werden. Sowas gibts auch schon 
massig, aber alles für Arduino. Hatten bisher keinen Erfolg was 
umzuschreiben und unsere eigenen mühsamen Versuche hatten nur eine 
geringe Erfolgsrate von 10% oder so.
Wäre wirklich hilfreich da mal was funktionierendes zu sehen. :)
MFG D.S.

[Uwe B. (boerge)]

MoinMoin,

Daniel Gronewold schrieb:
> beim Akkuwert habe ich auch noch Probleme.
>
...zum Thema messen der Akku-Spannung schaue dir mal das Manual der MCU 
an. Auch bei einem Attiny85 sollte es funktionieren, dass man die Höhe 
der Versorgungsspannung indirekt über die Bandgap-Spannung ermitteln 
kann.

Ich habe dieses Verfahren auch für eine meiner Funkbrücken verwendet:

http://bralug.de/wiki/RFM12-Funkbr%C3%BCcke#Versorgungsspannung_Sender_ermitteln

Grüße Uwe

[Daniel G. (dgrone)]

Hallo,
ich habe die Arduino-Software genommen. Du brauchst das Board dazu 
nicht!
Die Software lässt sich leicht installieren (bei mir Win7 x86). Spielt 
aber keine Rolle, da es für fast alle Betriebssysteme ein Treiber gibt.
Das AMTEL Studio war mir zu aufgeblasen. Ich wollte ja nur den Attiny 
programmieren.

Schritte:
- Software herunterladen (momentan 1.0.6): 
http://arduino.cc/en/Main/Software
- Treiber (Jungo-USB) installieren für das Programmierboard (Bei mir 
Diamex All-AVR Programmer / ERFOS-ISP-2): 
http://sourceforge.net/projects/libusb-win32/
- Nun nur noch den verwendeten Microkontroller raussuchen (bei Arduino 
unter Tools -> Board) auswählbar: http://highlowtech.org/?p=1695 
(Anleitung befolgen)

fertig!

Hier mein Code:

#include <avr/sleep.h>

//clear bit macro
#ifndef cbi
#define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit))
#endif

//set bit macro
#ifndef sbi
#define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit))
#endif

int groni_code = 817;     // Buchstaben 'HAG'
int nPulseLength = 101;    // Definiert von DG
unsigned long m_w = 1;
unsigned long m_z = 2; 

int watchdog_counter = 10; // hauptsache hoch, damit beim ersten mal ausgeführt wird 
int first_wait = 0;

#define PIN_STROM 0
#define PIN_SEND 1


#define PIN_FEUCHT 3
#define ANALOG_FEUCHT 3

#define PIN_TEMP 2
#define ANALOG_TEMP 1

#define PIN_AKKU 4
#define ANALOG_AKKU 2


#define IC_CODE 255         // 0-FF -> 255 ICs möglich!
#define WAIT_TO_SEND 600    // in Sekunden
#define WAIT_DELAY_FIRST 50 // in ms
#define WAIT_DELAY_END 20   // in ms


void transmit(int nHighPulses, int nLowPulses) {
  digitalWrite(PIN_SEND, HIGH);
  delayMicroseconds(nPulseLength * nHighPulses);
  digitalWrite(PIN_SEND, LOW);
  delayMicroseconds(nPulseLength * nLowPulses);
}


unsigned long getRandom()
{
    m_z = 36969L * (m_z & 65535L) + (m_z >> 16);
    m_w = 18000L * (m_w & 65535L) + (m_w >> 16);
    return (m_z << 16) + m_w;  /* 32-bit result */
} 

void setup() {
    // Set up FAST PWM 
  TCCR0A = 2<<COM0A0 | 2<<COM0B0 | 3<<WGM00;  // Set control register A for Timer 0
  TCCR0B = 0<<WGM02 | 1<<CS00;  // Set control register B for Timer 0
  TCCR1 = 0<<PWM1A | 0<<COM1A0 | 1<<CS10;  // Set control register for Timer 1
  GTCCR = 1<<PWM1B | 2<<COM1B0;  // General control register for Timer 1
  
  pinMode(PIN_STROM, OUTPUT);
  pinMode(PIN_AKKU, INPUT);
  pinMode(PIN_TEMP, INPUT);
  pinMode(PIN_FEUCHT, INPUT);
  pinMode(PIN_SEND, OUTPUT);
  
  setup_watchdog(6);        // approximately 1 seconds sleep
}

void system_sleep() {
  cbi(ADCSRA,ADEN);                    // switch Analog to Digitalconverter OFF
  set_sleep_mode(SLEEP_MODE_PWR_DOWN); // sleep mode is set here
  sleep_enable();
  sleep_mode();                        // System actually sleeps here
  sleep_disable();                     // System continues execution here when watchdog timed out   
  sbi(ADCSRA,ADEN);                    // switch Analog to Digitalconverter ON
  

}

void loop() {
  int wait_send;
  int fs_in = 0;
  int temp_in = 0;
  int paritaet = 0;
  int akku_in = 0;
  int i = 0;
    
  // wenn man den Akku reinsteckt, soll der Attiny für 1min in 10 Sekunden schritten senden
  // danach normal
  if(first_wait < 7) {
    wait_send = 10; // alle 10 sekunden;
  } else {
    wait_send = WAIT_TO_SEND;
  }
  
  if(watchdog_counter >= wait_send) {
  
    digitalWrite(PIN_STROM, HIGH);   // Spannung an 
    delay(WAIT_DELAY_FIRST); // - danach ein Delay zum einpendeln
    
    akku_in = analogRead(ANALOG_AKKU);
    temp_in = analogRead(ANALOG_TEMP);
    fs_in = analogRead(ANALOG_FEUCHT);
    
    transmit(1, 0); // Start
    
    transmit(1, 3); // Damit der Receiver weiß, wie lang eine '0' ist
    transmit(3, 1); // Damit der Receiver weiß, wie lang eine '1' ist
    
    for(i = 9; i >= 0; i--) { // 9 Bits takes the 'groni_code'
      if(((groni_code >> i) & 1)) {
        transmit(3, 1);
        paritaet = (paritaet+1) % 2; // Parität ausrechnen.. Im Anschluss mitsenden
      } else {
        transmit(1, 3);
      }
    }
    
    if(paritaet) {
        transmit(3, 1);
    } else {
        transmit(1, 3);
    }
    paritaet = 0;
    
    for(i = 7; i >= 0; i--) { // 8 Bits takes the 'ic-code'
      if(((IC_CODE >> i) & 1)) {
        transmit(3, 1);
        paritaet = (paritaet+1) % 2;
      } else {
        transmit(1, 3);
      }
      
    }
    
    if(paritaet) {
        transmit(3, 1);
    } else {
        transmit(1, 3);
    }
    paritaet = 0; 
    
    for(i = 9; i >= 0; i--) { // 10 Bits takes the 'feucht_sensor'
      if(((fs_in >> i) & 1)) {
        transmit(3, 1);
        paritaet = (paritaet+1) % 2;
      } else {
        transmit(1, 3);
      }
    } 
    
    if(paritaet) {
        transmit(3, 1);
    } else {
        transmit(1, 3);
    }
    paritaet = 0;
    
    for(i = 9; i >= 0; i--) { // 10 Bits takes the 'tempeartatur_sensor'
      if(((temp_in >> i) & 1)) {
        transmit(3, 1);
        paritaet = (paritaet+1) % 2;
      } else {
        transmit(1, 3);
      }
    }
    
    if(paritaet) {
        transmit(3, 1);
    } else {
        transmit(1, 3);
    }
    paritaet = 0;
    
    
    for(i = 9; i >= 0; i--) { // 10 Bits takes the 'akku_sensor'
      if(((akku_in >> i) & 1)) {
        transmit(3, 1);
        paritaet = (paritaet+1) % 2;
      } else {
        transmit(1, 3);
      }
    } 
    
    if(paritaet) {
        transmit(3, 1);
    } else {
        transmit(1, 3);
    }
    paritaet = 0;
    //transmit(0,99); // sendSync muss ungerade sein!
    
    
    delay(WAIT_DELAY_END);            // - danach ein Delay, falls er nochwas macht
    digitalWrite(PIN_STROM, LOW);     // Spannung aus
    
    watchdog_counter = 0;
    first_wait++;
    
  }
  //delay(WAIT_TO_SEND+((int)getRandom()%100)); // falls 2 ICs gleichzeitig senden.. Das muss nicht sein
  system_sleep(); 
  
}

// 0=16ms, 1=32ms,2=64ms,3=128ms,4=250ms,5=500ms
// 6=1 sec,7=2 sec, 8=4 sec, 9= 8sec
void setup_watchdog(int ii) {

  byte bb;
  int ww;
  if (ii > 9 ) ii=9;
  bb=ii & 7;
  if (ii > 7) bb|= (1<<5);
  bb|= (1<<WDCE);
  ww=bb;

  MCUSR &= ~(1<<WDRF);
  // start timed sequence
  WDTCR |= (1<<WDCE) | (1<<WDE);
  // set new watchdog timeout value
  WDTCR = bb;
  WDTCR |= _BV(WDIE);
}

ISR(WDT_vect) {
  watchdog_counter++;
}

Ich werde aber eventuell die Ansteuerung mit VirtuelWire.h machen, da es 
anscheinend zuverlässiger funktioniert.

Gruß!