Batterie Funk Windmesser, Barometer über Arduino

[Helikiller]

Suche Krampfhaft
- Step-Up Converter von 3V auf 3.3V (z.B. hier : http://www.aliexpress.com/store/product ... 09053.html)

Gibt es eine Alternative??

Ich würde sonst auch ein Arduino Pro Mini 5V nehmen und dann Stepdown von 5V auf 3,3V für BMP180 Modul

[spot]

Ich habe gesehen, dass das BMP180 auch mit 5V laufen sollte, da dort ein Spannungsregler verbaut ist. Der kleine Step-Up kostet ja nicht viel. Ich habe gleich 2 genommen und scheinbar war das eine gute Idee

Dein Link geht nicht, meinst Du sowas : http://www.aliexpress.com/item/2pcs-min ... 42417.html

Kannst auch selbst einen bauen, da gibt es coole Chips von Max oder Linar Devices : http://www.linear.com/product/LTC3525

Kannst ja auch Step-Down machen und dafür 2 Lithium Batterien nehmen, oder halt 4 AA oder dann sogar 4 AAA. Wenn Du einen Step-Down verbaust musst Du nur zur Spannungsmessung einen Spannungsteiler bauen.

Den 5V würd ich sonst nicht nehmen, da der halt einfach mehr Strom braucht (und glaub nur in 16MHz verfügbar ist).

[spot]

Code (1.1) und Doku Update.

[spot]

Bin mit den China Step-Up Dingern nicht glücklich und habe mir nun mal welche bei Sparkfun geordert. Schreibe dann wie die sich verhalten.

Hat das schon jemand nachgebaut?

Auf der Empfängerseite sitzt nun ein NRF24 mit SMA Antenne. Seither gab es keine Kommunikationsausfälle mehr, vorher gab es ab und zu (sehr selten) mal Kommunikationsprobleme (kein Empfang während 5-30 min).

[Helikiller]

Auf der Empfängerseite sitzt nun ein NRF24 mit SMA Antenne. Seither gab es keine Kommunikationsausfälle mehr, vorher gab es ab und zu (sehr selten) mal Kommunikationsprobleme (kein Empfang während 5-30 min).

Hi spot!
Das NRF24 mit SMA Antenne ist es wie Dieses hier NRF24L01, est ist aber kein NRF24L01+?
Funktioniert es trotzdem?
http://www.amazon.de/NRF24L01-Wireless- ... YQWWFQ1X05

LG Helikiller

[spot]

Das scheint auch ein "+" Modul zu sein. Du musst auf dem Chip lesen. Zumindest auf den Bildern auf AMAZON ist es ein "+".

Wenn es kein "+" ist geht der 250kbs Modus nicht, was unglücklich ist , da dieser Modus viel empfindlicher (10db) als der 1Mbps.

[Helikiller]

Moin Moin!
So langsam kommt Bewegung in meinem Nachbau von Spot.
Gestern Abend zum ersten mal Verbindung zwischen Adurino Pro Mini zum Adurino Mega 2560.
Es dauert ca 2 Min. bis die ersten Daten gesendet werden, aber eine Aktuallisierung der Werte kommt nicht.
Wo ist der Fehler

[spot]

Am besten schliesst Du den Sender an den Computer an und schaust Dir was die Konsole rausgibt. Alle 5 Minuten sollte ein update kommen, was Du auch am seriellen Printout sehen solltest. Wenn es initial schon mal geklappt hat sieht es gut aus, dass schon mal die Funkmodule funktionieren und auch richtig konfiguriert sind. Hast Du Code angepasst? Falls ja kannst Du den mal posten?

[Helikiller]

Aussenstation:

Code: Alles auswählen

/* ===================================================================================================================
   Der folgende Code wurde fuer einen Arduino Pro Mini mit 3.3V geschrieben. Mit einigen Anpassungen
   sollte der Code auch auf anderen Arduino Boards laufen.
   !! ACHTUNG : Versuche den Code (Interrupthandling des Windmessers im Zusammenspiel mit dem Stromsparmodus)
                auf einem Arduino MEGA 2560 zu testen schlugen fehl. Ich vermute ein anderes IRQ Handling auf dem MEGA

   Hilfreiche Links zum Thema Stromsparmodus :
   - http://donalmorrissey.blogspot.ch/2010/04/putting-arduino-diecimila-to-sleep-part.html
   - http://forum.arduino.cc/index.php?topic=199576.0

   Der vorliegende Code ist Open Source nach GPL

   Hardware Voraussetzungen / verwendete Hardware:
   - ELTAKO Windmesser WS
   - Arduino Mini Pro 3.3V -> http://www.arduino.cc/en/Main/ArduinoBoardProMini
   - NRF24L01 Funkmodul
   - BMP180 Luftdruck Modul
   - BH1750 Lichtintensitaets Messer
   - 3.3V Step-Up Converter (Anschluss von 2x 1.5V AA Batterien ueber einen Step Up Converter von 0.8 - 3V -> 3.3V
==================================================================================================================*/

#include <SPI.h>
#include "nRF24L01.h"
#include "RF24.h"
#include "printf.h"
#include <avr/sleep.h>
#include <avr/power.h>
#include <avr/wdt.h>
#include <Wire.h>        // Comes with Arduino IDE
#include <AS_BH1750.h>  //für I2C-Luxmeter 
#include <SFE_BMP180.h> //für I2C-Barometer
#include <OneWire.h>   //für Temperatursensoren DS18B20

// Programm Konstanten
// Serial Uebertragungsrate
const uint32_t BAUD = 57600;

// Hoehe der Mess-Station damit der Druck auf Meereshoehe normalisiert werden kann.
const uint16_t ALTITUDE = 56;

// Ab welcher Windboen Geschwindigkeit soll eine Funkuebertragung stattfinden?
const uint16_t MAX_WIND_GUST = 25;

// Alle n Sekunden wird eine regulaere AVG Wind Messung uebertragen, zusammen mit allen anderen Werten
const uint32_t WIND_INTERVALL = 300;

// Interrupt welcher fuer den Windsensor verwendet wird. !ACHTUNG Haengt vom Input Pin ab!
const uint16_t WIND_INT = 0;

// Input Pin fuer den Windsensor. !ACHTUNG der Pin muss Interrupt faehig sein -> Siehe Arduino Doku
const uint16_t WIND_CONN_PIN = 2;

// Wieviele Regulaere Datenuebertragungen muessen zwischen zwei Boen Windwarnungen vergehen. WIND_GUST_HOLDOFF x WIND_INTERVALL
const uint16_t WIND_GUST_HOLDOFF = 3;

// Analog Input Pin fuer die Batterie Spannungsmessung
const uint16_t BATTERY_PIN = 0;

// Analog Input Pin fuer die SOLAR Spannungsmessung
const uint16_t SOLAR_PIN = 1;

// Digitaler Output Pin fuer die Stromversorgung des NRF Moduls
const uint16_t NRF_POWER = 10;

// Digitaler Output Pin fuer die Stromversorgung des BMP Drucksensors
const uint16_t BMP_POWER = 4;

// AD-Converter Controll Register Zwischenspeicher, damit der ADC waehrend dem Sleep deaktiviert werden kann.
byte adcsra;

// Zaehler ab wann wieder Windboeen Warnungen uebertragen werden.
unsigned long nextWindGustTx = 0;

// Aktuelle Uebertragungsnummer
unsigned long txNumber = 0;
// Timeout Multiplikator fuer die Watchdog Timeouts. Wird in Setup() gesetzt und muss zum verwendeten Watchdog Timeout passen.
uint32_t WDT_TIMEOUT;

// Instanzen fuer die ueber I2C Angeschlossenen Sensoren
// BMP180 Sensor angeschlossen ueber I2C (SDA/SCL Pins A4/A5) -> 3.3 Volt Stromversorgung!
// BH1750 Sensor angeschlossen ueber I2C (SDA/SCL Pins A4/A5) -> 3.3 Volt Stromversorgung!
SFE_BMP180 Barometer;
AS_BH1750 LightSensor;

// Variablen zur Windmessung. Werte welche innerhalb der InterruptServiceRoutinen (ISR) veraendert werden muessen volatile markiert werden.
// Zaehler der Windsensor Impulse waehrend dem regulaeren Messintervall
volatile uint32_t windCount = 0L;

// Zaehler der Windsensor Impulse waehrend dem Watchdog -> Boen
volatile uint32_t windGustCount = 0L;
// Marker welcher Interrupt ausgeloest hat. TRUE = Watchdog / FALSE = WindSensor
volatile boolean WDT_INT;

// Globale Variable fuer die Max Windboen waehrend der Messperiode
float maxWind;
// Anzahl durchgefuehrter Boen Messungen
unsigned int windCounter;

// NRF24 Variablen zur Funkuebertragung
// NRF24 Modul benoetigt den SPI Bus (Pins auf Mini Pro 11-MOSI / 12-MISO / 13-SCK) plus 2 Pins. Hier 7 und 8. IRQ wird nicht benoetigt.
RF24 radio(8, 9);
uint8_t PIPE_NAME[7] = {"NET"};

void setup()
{
  Serial.begin(BAUD);
  printf_begin();
  // Power to NRF24;
  pinMode(NRF_POWER, OUTPUT);
  pinMode(BMP_POWER, OUTPUT);
  digitalWrite(NRF_POWER, true);
  digitalWrite(BMP_POWER, false);
  delay(2000);
  Serial.println("Setup V1.1 - 2015-05-13");
  Serial.println("Baro Sensor Initialisiert");
  //LightSensor.begin();
  Serial.println("Licht Sensor Initialisiert");
  pinMode(WIND_CONN_PIN, INPUT_PULLUP);
  Serial.println("Wind Sensor Input Pin Initialisiert");
  radio.begin();
  radio.openWritingPipe(PIPE_NAME);
  radio.stopListening();
  radio.enableDynamicPayloads();
  radio.setDataRate(RF24_250KBPS);
  radio.printDetails();
  Serial.println("Funkuebertragung NET Initialisiert");
  windCount = 0;
  windGustCount = 0;
  windCounter = 1;
  WDT_TIMEOUT = 4000L;
  setup_watchdog();
  Serial.println("Watchdog Initialisiert");
  adcsra = ADCSRA;  // ACD ausschalten
  ADCSRA = 0;
  radio.powerDown();
  delay(1000);
}

// Watchdog Vorbereiten und zu verwendenden Timeout einstellen.
void setup_watchdog(void) {
  wdt_reset();
  MCUSR &= ~bit(WDRF);
  WDTCSR |= bit(WDCE) | bit(WDE);
  WDTCSR = bit (WDIE) | bit(WDP3) ; /* Bit 3 = 4.0 Sekunden */
}

/* Interrupt Service Routinen. Hier wird der Schlafmodus des Arduino unterbrochen wenn ein solcher ausgeloest wird */

// Interrupt Service Routine fuer den Watchdog.
ISR(WDT_vect)
{
  detachInterrupt(WIND_INT);
  // Nun soll ein Wind Interrupt nicht mehr registriert werden, da der Erfassungstimer sowieso abgelaufen ist
  WDT_INT = true;
  // Do Nothing
}

// Interrupt Service Routine fuer den Windmesser
void windUp() {
  // Zuerst den Interrupt aufhalten, damit Schalterprellen nicht zu mehrfachen Aufrufen fuehrt.
  detachInterrupt(WIND_INT);
  windCount++;
  windGustCount++;
  WDT_INT = false;
}

/* Ende der ISR Methoden */

// Windgeschwindigkeit aus der Anzahl Impulse und der vergangenen Zeit berechnen
float calcWind(uint32_t count, uint32_t time) {
  // Bei sehr tiefen Geschwindigkeiten ist die Formel ungenau, deshalb muss im Schnitt mindestens
  // 1u/sec erfasst worden sein. Die Erfassunglimite liegt somit bei 3km/h
  if (Serial) {
    Serial.print("Messzeit = ");
    Serial.print(time);
    Serial.print("sec / Impulse = ");
    Serial.print(count);
  }
  if (count <= time / 2) {
    if (Serial)
      Serial.println(". Zu wenige Impulse, gebe 0 kmh zurueck");
    return 0.0;
  }
  float windSpeedAlt = (count / time + 2) / ( 3.0) * 3.6;
  return windSpeedAlt;
}

// Stromspar Modus verwenden
void enterSleep(void)
{
  // Serial Comm flushen, da es sonst zu Stoerungen auf der Seriellen Schnittstelle kommt
  Serial.flush();
  Serial.end();
  // Keine Interrupts mehr zulassen bis kurz vor dem Sleep
  noInterrupts();
  if (WDT_INT) // Wenn es ein Watchdog Timeout war, dann RESET auf dem Watchdog.
    setup_watchdog(); // Reset Watchdog.
  // Interrupt Flag fuer Interrupt 0 loeschen und Wind Interrupt wieder anhaengen
  EIFR = bit(INTF0);
  attachInterrupt(WIND_INT, windUp, FALLING);
  // Sleep Modus einstellen. Max Stromersparnis bei POWER DOWN
  set_sleep_mode(SLEEP_MODE_PWR_DOWN);
  sleep_enable();
  // Option hier noch Brown-Out Check ausschalten
  // Interrupts wieder zulassen. !! Nachfolgender Befehl ist noch vor Interrupts geschtzt und muss nun den yP schlafen legen !!
  interrupts();
  sleep_mode();
  // Nach dem Aufwachen geht es hier weiter. Als erstes Serielle Kommunikation wieder ermoeglichen.
  Serial.begin(57600);
  sleep_disable();
}

// Aktueller Barometer Druck normalisiert auf Meeresniveau holen
float getSeaLevelPress() {
  SFE_BMP180 pressure;
  // BMP Sensor initialisieren
  pressure.begin();
  char status;
  double T, P;
  // Als erstes muss die Temperatur bestimmt und gelesen werden
  status = pressure.startTemperature();
  if (status != 0)
  {
    delay(status);
    status = pressure.getTemperature(T);
    if (status != 0)
    {
      delay(status);
      // Nun kann der aktuelle Druck ausgelesen werden mit der hoechsten Genauigkeit
      status = pressure.startPressure(3);
      if (status != 0)
      {
        delay(status);
        status = pressure.getPressure(P, T);
        if (status != 0)
        {
          // Strom zum Drucksensor unterbrechen, da der eingebaute Spannungsregler ziemlich viel Strom brauch (min 8mA).
          digitalWrite(BMP_POWER, false);
          // Nun wird der gemessene Druck noch auf Meereshoehe "normalisiert"
          return pressure.sealevel(P, ALTITUDE);
        }
      }
    }
  }
  if (Serial)
    Serial.println("Fehler bei der Bestimmung des aktuellen Luftdrucks");
}

// Uebertragen der Daten
void transmit(float maxWind, float avgWind, float pressure, uint16_t light, float battery, float solar) {
  if (Serial) {
    Serial.print("Baro=");
    Serial.print(pressure, 2);
    Serial.print("hPa / Max Wind=");
    Serial.print(maxWind, 2);
    Serial.print("kmh / Avg Wind=");
    Serial.print(avgWind, 2);
    Serial.print("kmh / Light=");
    Serial.print(light);
    Serial.print("lux / Battery=");
    Serial.print(battery);
    Serial.println("Volt / Solar");
    Serial.print(solar);
    Serial.print("Volt");
    Serial.print("Start NRF Transmission");
  }
  radio.powerUp();
  radio.stopListening();
  radio.openWritingPipe(PIPE_NAME);
  uint16_t data[] = {maxWind * 10, avgWind * 10, pressure * 10, battery * 10, solar * 10, light};
  radio.write(&data, sizeof(data));
  //radio.txStandBy();
  radio.powerDown();
}

// Auslesen des Lichtsensors
uint16_t getLight() {
  //  LightSensor.SetMode(OneTime_H_resolution_Mode);
  return 0;//LightSensor.GetLightIntensity();
}

void collectAndTrasmit() {
  powerUpAux();
  // Alle Messwerte bestimmen
  float pressure = getSeaLevelPress();
  float avgWind = calcWind(windCount, windCounter * (WDT_TIMEOUT / 1000));
  uint16_t light = getLight();
  float battery = getBatteryVoltage();
  float solar = getSolarVoltage();
  // Messwerte Uebertragen
  transmit(maxWind, avgWind, pressure, light, battery, solar);
  txNumber++;
  // Alle Messvariablen zuruecksetzen
  windCounter = 0L;
  windGustCount = 0L;
  windCount = 1;
  maxWind = 0L;
  powerDownAux();
  
}
// Strom zu den Elementen leiten welche beim Transmit ausgelesen werden resp Baugruppen des Arduino mit Strom versorgen (ADC)
void powerUpAux() {
  digitalWrite(BMP_POWER, true);
  ADCSRA = adcsra; // ACD Wiedereinschalten
  // Delay damit alle Elemente einen stabilen Stand erreicht haben (z.B. BMP180 bentigt mindestens 10ms Power vor dem ersten auslesen).
  delay(50);
}

// Zur normalen Windmessung nicht bentigte Baugruppen und Elemente ausschalten
void powerDownAux() {
  digitalWrite(BMP_POWER, false);
  adcsra = ADCSRA; // ACD Zustand Speichern
  ADCSRA = 0; // und ADC Ausschalten da der Stromverbrauch des ADC sehr hoch ist
}

// Verbleibende Batteriespannung auslesen
float getBatteryVoltage() {
  int bat = analogRead(BATTERY_PIN); // Level Messen
  return bat / 1024.0 * 3.3; // Spannung normalisieren auf AnalogRef Level. Hier 3.3 Volt (Arduino Pro Mini 3.3V)
}
// Solarspannung auslesen
float getSolarVoltage() {
  int sol = analogRead(SOLAR_PIN); // Level Messen
  return sol / 1024.0 * 5.5; // Spannung max 5.5Volt
}

// Main Loop
void loop()
{
  if (WDT_INT) { // Falls dies ein Watchdog Timeout war
    // Boen Wind waehrend der Messperiode bestimmen.
    float tempMaxWind = calcWind(windGustCount, WDT_TIMEOUT / 1000);
    // Falls neue Boenspitze in dieser Messperiode den Max Wert neu setzen
    if (tempMaxWind > maxWind)
      maxWind = tempMaxWind;
    // Boenzaehler reset
    windGustCount = 0;
    // Wenn es eine Windboe gab welche ueber der Alarm Schwelle lag und es schon laenger keine solche Meldung mehr gab
    if (maxWind > MAX_WIND_GUST && nextWindGustTx < txNumber) {
      // Bei der Alarm Meldung sind alle Werte ausser dem Boenwert = 0
      transmit(maxWind, 0, 0, 0, 0, 0);
      // Die naechste Boen Alarmmeldung darf erst nach WIND_GUST_HOLDOFF regulaeren Uebermittlungen stattfinden
      nextWindGustTx = txNumber +  WIND_GUST_HOLDOFF + 1;
    }
    // Falls der regulaere Messintervall abgelaufen ist
    if (WIND_INTERVALL / (WDT_TIMEOUT / 1000) <= windCounter) {
      // Alle Werte auslesen und die Daten uebertragen
      collectAndTrasmit();
    }
    // Regulaerer Messintervall noch nicht abgelaufen also nur Durchlaufzaehler erhoehen.
    else {
      windCounter++;
    }
  } else {
    // Bei einem Windmesser Interrupt noch etwas warten, damit Schalterprellen nicht gleich wieder einen IRQ ausloesst.
    // Dies passt fuer meinen ELTAKO Windmesser WS, andere Reedkontakt basierte Windmesser bentigen ggf andere Werte
    delayMicroseconds(200);
  }
  // Verarbeitung Fertig, CPU wieder schlafen legen.
  enterSleep();
}

Receiver:

Code: Alles auswählen

#include <SPI.h>
#include "nRF24L01.h"
#include "RF24.h"
#include "printf.h"

RF24 radio (7,6);
const int num_reps = 100;
uint8_t PIPE_NAME[7] = {"NET"};

void setup()
{
  Serial.begin(57600);
  delay(3000);
  printf_begin();
  radio.begin();
  radio.openReadingPipe(1, PIPE_NAME);
  radio.startListening();
  radio.enableDynamicPayloads();
  radio.setDataRate(RF24_250KBPS);
  radio.printDetails();
  Serial.println("NET Initialisiert");
  Serial.println("57600 BAUD Initialisiert");
  delay(3000);
}

void loop()
{
  if (radio.available())
    readRadio();
  delay(5000);
}

void readRadio() {
  uint16_t data[6];
  radio.read(&data, 10);
  float maxWind = float(data[0]) / 10;
  float avgWind = float(data[1]) / 10;
  float pressure = float(data[2]) / 10;
  float battery = float(data[3]) / 10;
  float solar = float(data[4]) / 10;
  uint16_t light = data[5];
  Serial.print("Maximaler Wind: ");
  Serial.print(maxWind);
  Serial.print(" km/h / ");
  Serial.print("Durchschnittlicher Wind: ");
  Serial.print(avgWind);
  Serial.print(" km/h / ");
  Serial.print("Barometer: ");
  Serial.print(pressure);
  Serial.print(" hPa / ");
  Serial.print("Batteriespannung: ");
  Serial.print(battery);
  Serial.println(" V / ");
  Serial.print("Solarspannung: ");
  Serial.print(solar);
  Serial.println(" V");
}

Als nächstes möchte ich den Receiver mit einem Homeduino verbinden, bzw. einbinden.

[spot]

Auf die Schnelle habe ich 2 Dinge gesehen:

1. Du Empfängst "nur" 10 Byte überträgst aber 12 Byte.
2. Ich glaube nicht, dass Du mit einem 3.3 V Arduino eine Spannung von 5.5V messen kannst.