Windmesser über Thinkspeak auslesen

Hallo ,erstmal Danke für die Aufnahme in das Forum.
Mein Name ist Andre bin 52 Jahre, als Beruf Kunststoff,Kautschuk, Verfahrensmechaniker.
In meiner Freizeit betreibe ich RC Modellbau und etwas Arduino.

Zu meinem Problem (Wunsch) ,ich habe über ein ESP8266 mir ein Außenfühler gemacht ,den ich über Thinkspeak abrufen kann .Funktioniert auch.

Dann habe ich mir die Datei vom Volkswindmesser (Schubert gehäuse) runter geladen, Programmiert Installiert, Funktioniert auch.

Jetzt kommts wer möchte mir unter die Arme greifen , beide Sketch zu Vereinen vom Windmesser bräuchte ich nur die momentane Kmh.
Vielen Dank im voraus. Wer helfen möchte dem Lade ich die zwei Dateien dann hoch.
Andre Benner

Ihr Beitrag wurde an seinen aktuellen Speicherort verschoben, da er besser geeignet ist.

Einfach hier hochtackern.

In der IDE auf BEARBEITEN - FÜR FORUM KOPIEREN und dann hier einfügen.

beide.


// Anzahl Spalten des Display (20)
#define LCD_WIDTH 20

// Anzahl Zeilen des Display (4)
#define LCD_HEIGHT 4

// Pin für Reed-Kontakt, Digital-2 für Interrupt 0
#define REEDPIN 2

// Hardware-Interrupt für den Reed-Pin
#define REEDINTERRUPT 0

// Umfang in mm wurde im Windkanal mit dem Volkswindmesser ermittelt als Referenz
#define RADUMFANG 2200

// LED Balken 
#define led05 11                 // LED connected to digital pin 11
#define led10 10                 // LED connected to digital pin 10
#define led15 9                  // LED connected to digital pin 9
#define led20 8                  // LED connected to digital pin 8
#define led25 7                  // LED connected to digital pin 7
#define led30 6                  // LED connected to digital pin 6


#define ledalarm 13              // LED ALARM 

#define resetmaxpin 4           // reset max Pin (button)
#define resetalarmpin 5         // reset Alarm Pin (button)

#include <Wire.h> 
#include <LiquidCrystal_I2C.h> //NewLiquidCrystal - https://bitbucket.org/fmalpartida/new-liquidcrystal/downloads/
LiquidCrystal_I2C lcd(0x27,20,4);  // (LCD2004) Set the LCD I2C address
//LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE); // Addr, En, Rw, Rs, d4, d5, d6, d7, backlighpin, polarity

void setup()
  {
  lcd.init();                      // initialize the lcd 
  //lcd.begin(20,4);
  lcd.clear();
  lcd.backlight();


   lcd.begin(LCD_WIDTH, LCD_HEIGHT);  // initialize the lcd 

    lcd.setCursor ( 0, 0 );        // erste Zeile mit Alarm
    lcd.print ("Res 1Max 2Alarm A:");
    lcd.setCursor ( 0, 1 );        // zweite Zeile
    lcd.print (" Andre s Anemometer  ");
            
  //Switch on the backlight
  //pinMode ( BACKLIGHT_PIN, OUTPUT );
  //digitalWrite ( BACKLIGHT_PIN, HIGH );
 
  pinMode(REEDPIN, INPUT_PULLUP); // Reedkontakt direkt und ohne Widerstand angeschlossen 
  attachInterrupt(REEDINTERRUPT, reedISR, FALLING);
  Serial.begin(115200);
  pinMode(led05, OUTPUT);
  pinMode(led10, OUTPUT);
  pinMode(led15, OUTPUT);
  pinMode(led20, OUTPUT);
  pinMode(led25, OUTPUT);
  pinMode(led30, OUTPUT);
  pinMode(resetmaxpin, INPUT_PULLUP); // Resetmax Taster direkt und ohne Widerstand angeschlossen (gegen ground)
  pinMode(resetalarmpin, INPUT_PULLUP); // Resetalarm Taster direkt und ohne Widerstand angeschlossen (gegen ground)
}

float ms2; //globale Variable Speed in m/s
float msmax = 0;  //Maximalwert
unsigned long umin; // U/min

int alarm; // Alarmgrenze in m/s (meter/sekunde)


volatile byte reedCountSum;
volatile long reedMillisSum;

unsigned long lastReedMillis;

void reedISR()
{
  if (millis()-lastReedMillis>=5)   // 25ms entspricht max. 40 Umdrehungen pro Sekunde (bei Volkswindmesser reichen 2ms Entprellzeit aus)
  {
    reedCountSum++;                 // eine Radumdrehung zählen
    reedMillisSum+=millis()-lastReedMillis;   // Zeit addieren
    lastReedMillis=millis();       // Zeit merken
  }
}

unsigned long gesamtUmdrehungen = 0; //4545300;

void tachoAnzeige()
{
  byte umdrehungen;
  unsigned long zeit;
  float kph, kilometer, ms;
  char buffer[10];
  noInterrupts();            // Interrupts sperren
    umdrehungen=reedCountSum;// Zählvariable umkopieren
    reedCountSum=0;          // Zählvariable auf 0 zurücksetzen
    zeit=reedMillisSum;      // Zeitzähler umkopieren
    reedMillisSum=0;         // Zeitzähler auf 0 zurücksetzen
  interrupts();              // Interrupts wieder zulassen
    gesamtUmdrehungen+= umdrehungen; // Aufsummieren aller Radumdrehungen
    kilometer=(float)gesamtUmdrehungen*(float)RADUMFANG/1000000.0; // Kilometerzähler 

  if (umdrehungen>0){
    kph=float(RADUMFANG)*(float)umdrehungen/(float)zeit*3.6;  
    ms=float(RADUMFANG)*(float)umdrehungen/(float)zeit;  
    umin=umdrehungen*60000/zeit;  }
  else {
    kph=0.0;      //Null setzen wenn keine Umdrehung gefunden wurde
    umin = 0; }   //Null setzen wenn keine Umdrehung gefunden wurde
    
    
    // ms = kph/3.6; //aus km/h mach m/s - kmh/3.6
    ms2 = ms; //variable ms in ms2 global kopieren

    //LCD Ausgabe -- Kilometerzähler hier deaktiviert
    //lcd.setCursor(0, 2);
    //dtostrf(kilometer,8,3,buffer);
    //lcd.print(buffer);
    //Serial.println(buffer);
    //lcd.print(" km MAX:");
    //dtostrf(msmax,4,1,buffer);
    //lcd.print(buffer);
    // Serial.println(buffer);

    //LCD Ausgabe -- U/min und Maximalwert
    lcd.setCursor(0, 2);
    sprintf(buffer,"%4i U/min ",umin);    // mit Nullen - sprintf(buffer,"%04i U/min ",umin); 4-Stellen Lagerichtig :-).
    lcd.print(buffer);
    dtostrf(msmax,5,2,buffer);            // Insgesamt 5 Stellen 12.45 (Dezimalpunkt ist auch eine Stelle)
    lcd.print(buffer);
    lcd.print(" Mkm");
     
    //LCD Ausgabe -- km/h
    lcd.setCursor(0, 3);
    dtostrf(kph,5,1,buffer);
    lcd.print(buffer);
    // Serial.println(buffer);
    lcd.setCursor(5, 3);
    lcd.print(" km/h ");

    //LCD Ausgabe -- m/s
    dtostrf(ms,5,2,buffer);
    lcd.print(buffer);
    // Serial.println(buffer);
    lcd.setCursor(16, 3);
    lcd.print(" m/s");

    //maximalwert speichern
    //Km/h anzeigen
    if (ms2*3.6 > msmax) {
    msmax = ms2*3.6;   }
   // Serial.println(msmax);

    //umin 0 setzen wenn ms2 0 ist.
   // if (ms2 == 0.0) {
   // umin = 0;  }

   //Serial.println(gesamtUmdrehungen);
  

    //LED Balken Ansteuerung
    if (kph >= 5) {
    digitalWrite(led05, HIGH);  } 
    else {
    digitalWrite(led05, LOW);  }
    if (kph >= 10) {
    digitalWrite(led10, HIGH);  } 
    else {
    digitalWrite(led10, LOW);  }
    if (kph >= 15) {
    digitalWrite(led15, HIGH);  } 
    else {
    digitalWrite(led15, LOW);  }
    if (kph >= 20) {
    digitalWrite(led20, HIGH);  } 
    else {
    digitalWrite(led20, LOW);  }
    if (kph >= 25) {
    digitalWrite(led25, HIGH);  }
    else {
    digitalWrite(led25, LOW);  }
    if (kph >= 30) {
    digitalWrite(led30, HIGH);  } 
    else {
    digitalWrite(led30, LOW);  }
  }

unsigned long interval;           // update LCD/LED interval (milliseconds)
unsigned long previousMillis = 0; 
unsigned long intervalalarm = 200;           // update Alarm Anzeige interval (milliseconds)
unsigned long previousMillisalarm = 0; 

unsigned long currentMillis;

int potpin = 0;  // analog pin used to connect the potentiometer
int val;    // variable to read the value from the analog pin

void loop()
{
  
  //Auswerteintervall nach Drehzahl anpassen
  if (ms2 < 1) {
    interval = 4000;  }
  if (ms2 >= 1 && ms2 < 2) {
    interval = 2100;  }  
  if (ms2 >= 2 && ms2 < 3) {
    interval = 1100;  } 
  if (ms2 >= 3 && ms2 < 4) {
    interval = 800;  } 
  if (ms2 >= 4 && ms2 < 6 ) {
    interval = 600;  }   
  if (ms2 > 6) {
    interval = 400;  }  

  
  // Anzeige wird nach dem eingestellten inteval aktualisiert
  currentMillis = millis();
  if (currentMillis - previousMillis >= interval)
  {
    tachoAnzeige();
    previousMillis = currentMillis;
  }
    
  // Alaramzeige wird nach dem eingestellten interval aktualisiert
  if (currentMillis - previousMillisalarm >= intervalalarm)
  {
    val = analogRead(potpin);            // reads the value of the potentiometer (value between 0 and 1023)
    alarm = map(val, 0, 1023, 0, 30);     // scalieren der Potistellung (0-30m/s)
  
    lcd.setCursor(18, 0);
    if(alarm < 10) lcd.print("0"); // ein leerzeichen  oder auch Zahl Nullf(zahl <10) print(" "); // ein leerzeichen  oder auch Zahl Null
    lcd.print(alarm);
    
     //Alarm LED einschalten wenn Wind > Alarmwert
    if (ms2 > alarm) {
    digitalWrite(ledalarm, HIGH);
    lcd.setCursor(0, 1);
    lcd.print("**** A L A R M !****");    }

   previousMillisalarm = currentMillis;
  }


    // Alarm LED zurücksetzen wenn Wind >5ms oder resetbutton gedrückt wird
    // if (ms2 < 2 && digitalRead(ledalarm) == HIGH || digitalRead(resetmaxpin) == LOW)
    if (digitalRead(resetalarmpin) == LOW) {
    digitalWrite(ledalarm, LOW);
    lcd.setCursor(0, 1);
    lcd.print (" Andre s Anemometer ");
    }  
    
    //Unterdrückung der ersten 10 Umdrehungen oder reset Button gedrückt zum resetten der Maximalwertes
    if (gesamtUmdrehungen < 10 || digitalRead(resetmaxpin) == LOW ) {  
    msmax = 0;  }
        
    //gesamtUmdrehungen resetten bevor Display überlauf
    if (gesamtUmdrehungen > 4545430) {
    gesamtUmdrehungen = 0;  }
  
}
    


//char buffer[7];
//sprintf(buffer,"%4imA",zahl);
//print buffer;

//mit Nullen

//char buffer[7];
//sprintf(buffer,"%04imA",zahl);
//print buffer;

Danke schon mal im voraus.

Hier ist der Sketch meine Polnischen Kollegen.

#include <OneWire.h>

//Prosty przykład implementacji ESP8266 z termometrem DS18B20 x2
//Wysyłka pomiarów na serwery Thingspeak
//avrland.it

#include <ESP8266WiFi.h>
#include <OneWire.h>


//USTAWIENIA
OneWire  ds(2);  // numer pinu do którego podpięto czujnik
const char* ssid     = ""; //<- SSID Twojej sieci
const char* password = ""; //<- Hasło do Twojej sieci
const char* host = "api.thingspeak.com"; //adres ThingSpeak
const String api_key = ""; //klucz API
//KONIEC USTAWIEŃ

//ZMIENNE DLA POMIARÓW
byte i;
byte present = 0;
byte type_s;
byte data[12];
byte addr[8];
float celsius;
float kanal1, kanal2, kanal3, kanal4, kanal5, kanal6, kanal7, kanal8; //zmienne przechowywujące wartość pomiaru
byte czujnik1[8], czujnik2[8], czujnik3[8], czujnik4[8], czujnik5[8], czujnik6[8], czujnik7[8], czujnik8[8]; //zmienne na potrzeby przechowywania adresów obecnych czujników 
//KONIEC ZMIENNYCH DLA POMIARÓW


void setup() {
  Serial.begin(115200);
  delay(10);
  Serial.println();
  Serial.println("Termometr DS18B20 IoT @ Thingspeak");
  Serial.println();
  Serial.print("Lacze do ");
  Serial.println(ssid);
  WiFi.mode(WIFI_STA); //we don't want to broadcast SSID so we put ESP8266 to standalone mode
  WiFi.begin(ssid, password);
  
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  Serial.println("");
  Serial.println("WiFi polaczone");  
  Serial.println("Adres IP: ");
  Serial.println(WiFi.localIP());
  /*
   * Sekwencja uzyskiwania adresów czujników
   */
  ds.search(czujnik1);
  ds.search(czujnik2);
  ds.search(czujnik3);
  ds.search(czujnik4);
  ds.search(czujnik5);
  ds.search(czujnik6);
  ds.search(czujnik7);
  ds.search(czujnik8);
  Serial.print("ROM czujnik pierwszy =");
  for( i = 0; i < 8; i++) {
    Serial.write(' ');
    Serial.print(czujnik1[i], HEX);
  }
  Serial.println("");
  Serial.print("ROM czujnik drugi =");
   for( i = 0; i < 8; i++) {
    Serial.write(' ');
    Serial.print(czujnik2[i], HEX);
  }
  Serial.println("");
  Serial.print("ROM czujnik trzeci =");
   for( i = 0; i < 8; i++) {
    Serial.write(' ');
    Serial.print(czujnik3[i], HEX);
  }
  Serial.println("");
  Serial.print("ROM czujnik czwarty =");
   for( i = 0; i < 8; i++) {
    Serial.write(' ');
    Serial.print(czujnik4[i], HEX);
  }
  Serial.println("");
  Serial.print("ROM czujnik piaty =");
   for( i = 0; i < 8; i++) {
    Serial.write(' ');
    Serial.print(czujnik5[i], HEX);
  }
  Serial.println("");
  Serial.print("ROM czujnik szosty =");
   for( i = 0; i < 8; i++) {
    Serial.write(' ');
    Serial.print(czujnik6[i], HEX);
  }
  Serial.println("");
  Serial.print("ROM czujnik siodmy =");
   for( i = 0; i < 8; i++) {
    Serial.write(' ');
    Serial.print(czujnik7[i], HEX);
  }
  Serial.println("");
  Serial.print("ROM czujnik osmy =");
   for( i = 0; i < 8; i++) {
    Serial.write(' ');
    Serial.print(czujnik8[i], HEX);
  }
  Serial.println("");
}
/*##############
*  PĘTLA GŁÓWNA
*/
void loop() {
    kanal1 = pomiar(czujnik1); //zmierz temperature na pierwszym czujniku
    kanal2 = pomiar(czujnik2); //zmierz temperature na drugim czujniku
    kanal3 = pomiar(czujnik3); //zmierz temperature na trzecim czujniku
    kanal4 = pomiar(czujnik4); //zmierz temperature na czwartym czujniku
    kanal5 = pomiar(czujnik5); //zmierz temperature na piatym czujniku
    kanal6 = pomiar(czujnik6); //zmierz temperature na szostym czujniku
    kanal7 = pomiar(czujnik7); //zmierz temperature na siodmym czujniku
    kanal8 = pomiar(czujnik8); //zmierz temperature na osmym czujniku
    wyslij_pomiar(kanal1, kanal2, kanal3, kanal4, kanal5, kanal6, kanal7, kanal8, api_key); //wyslij pomiar
}

/*
 * Wysyłka pomiaru do Thingspeak
 * field1 - wartość na pierwszy wykres
 * field2 - wartość na drugi wykres
 * field3 - wartość na trzeci wykres
 * field4 - wartość na czwarty wykres
 * field5 - wartość na piaty wykres
 * field6 - wartość na szosty wykres
 * field7 - wartość na siodmy wykres
 * field8 - wartość na osmy wykres
 * api_key - klucz api
 */
void wyslij_pomiar(float field1, float field2, float field3, float field4, float field5, float field6, float field7, float field8, String api_key){
    Serial.print("Laczymy do: ");
    Serial.println(host);
    // Use WiFiClient class to create TCP connections
    WiFiClient client;
    const int httpPort = 80;
    if (!client.connect(host, httpPort)) {
    Serial.println("connection failed");
    //return 0;
    }
    String url = "/update?key=" + api_key + "&field1="; //<- TU WKLEJ KOD DO API
    url += (String)field1;
    url+= "&field2=" + (String)field2;
    url+= "&field3=" + (String)field3;
    url+= "&field4=" + (String)field4;
    url+= "&field5=" + (String)field5;
    url+= "&field6=" + (String)field6;
    url+= "&field7=" + (String)field7;
    url+= "&field8=" + (String)field8;
    Serial.print("Requesting URL: ");
    Serial.println(url);
    
    // This will send the request to the server
    client.print(String("GET ") + url + " HTTP/1.1\r\n" +
             "Host: " + host + "\r\n" + 
             "Connection: close\r\n\r\n");
    delay(10);
    
    // Read all the lines of the reply from server and print them to Serial
    while(client.available()){
         String line = client.readStringUntil('\r');
         Serial.print(line);
    }
    
    Serial.println();
    Serial.println("##############################");
    Serial.println("KONIEC POMIARU");
    Serial.println("##############################");
    delay(3000);
}
/*
 * POMIAR DS18B20
 * 
 * adres - 8 bitowy adres czujnika
 */
float pomiar(byte adres[8]){ 
  ds.reset();
  ds.select(adres);
  ds.write(0x44, 1);        // start conversion, with parasite power on at the end
  
  delay(1000);     // maybe 750ms is enough, maybe not
  // we might do a ds.depower() here, but the reset will take care of it.
  
  present = ds.reset();
  ds.select(adres);    
  ds.write(0xBE);         // Read Scratchpad

  Serial.print("  Data = ");
  Serial.print(present, HEX);
  Serial.print(" ");
  for ( i = 0; i < 9; i++) {           // we need 9 bytes
    data[i] = ds.read();
    Serial.print(data[i], HEX);
    Serial.print(" ");
  }
  Serial.print(" CRC=");
  Serial.print(OneWire::crc8(data, 8), HEX);
  Serial.println();

  // Convert the data to actual temperature
  // because the result is a 16 bit signed integer, it should
  // be stored to an "int16_t" type, which is always 16 bits
  // even when compiled on a 32 bit processor.
  int16_t raw = (data[1] << 8) | data[0];
  if (type_s) {
    raw = raw << 3; // 9 bit resolution default
    if (data[7] == 0x10) {
      // "count remain" gives full 12 bit resolution
      raw = (raw & 0xFFF0) + 12 - data[6];
    }
  } else {
    byte cfg = (data[4] & 0x60);
    // at lower res, the low bits are undefined, so let's zero them
    if (cfg == 0x00) raw = raw & ~7;  // 9 bit resolution, 93.75 ms
    else if (cfg == 0x20) raw = raw & ~3; // 10 bit res, 187.5 ms
    else if (cfg == 0x40) raw = raw & ~1; // 11 bit res, 375 ms
    //// default is 12 bit resolution, 750 ms conversion time
  }
  celsius = (float)raw / 17.56;
  Serial.print("  Temperature  = ");
  Serial.println(celsius);
  return celsius;
}

Dieser Funktioniert auch. Wer kann mir in diesen Sketch den Anemometer Sketch einfügen,ich bräuchte dort nur die KMh. Das ich diese über Think Speak auslesen kann.

#include <DHT.h>  // Including library for dht
 
#include <ESP8266WiFi.h>
 
String apiKey = "";     //  Enter your Write API key from ThingSpeak
 
const char *ssid =  "";     // replace with your wifi ssid and wpa2 key
const char *pass =  "";
const char* server = "api.thingspeak.com";
 
#define DHTPIN 0          //pin where the dht11 is connected
 
DHT dht(DHTPIN, DHT11);
 
WiFiClient client;
 
void setup() 
{
       Serial.begin(115200);
       delay(10);
       dht.begin();
 
       Serial.println("Connecting to ");
       Serial.println(ssid);
 
 
       WiFi.begin(ssid, pass);
 
      while (WiFi.status() != WL_CONNECTED) 
     {
            delay(500);
            Serial.print(".");
     }
      Serial.println("");
      Serial.println("WiFi connected");
 
}
 
void loop() 
{
  
      float h = dht.readHumidity();
      float t = dht.readTemperature();
      
              if (isnan(h) || isnan(t)) 
                 {
                     Serial.println("Failed to read from DHT sensor!");
                      return;
                 }
 
                         if (client.connect(server,80))   //   "184.106.153.149" or api.thingspeak.com
                      {  
                            
                             String postStr = apiKey;
                             postStr +="&field1=";
                             postStr += String(t-4.5);
                             postStr +="&field2=";
                             postStr += String(h+6);
                             postStr += "\r\n\r\n";
 
                             client.print("POST /update HTTP/1.1\n");
                             client.print("Host: api.thingspeak.com\n");
                             client.print("Connection: close\n");
                             client.print("X-THINGSPEAKAPIKEY: "+apiKey+"\n");
                             client.print("Content-Type: application/x-www-form-urlencoded\n");
                             client.print("Content-Length: ");
                             client.print(postStr.length());
                             client.print("\n\n");
                             client.print(postStr);
 
                             Serial.print("Temperature: ");
                             Serial.print(t);
                             Serial.print(" degrees Celcius, Humidity: ");
                             Serial.print(h);
                             Serial.println("%. Send to Thingspeak.");
                        }
          client.stop();
 
          Serial.println("Waiting...");
  
  // thingspeak needs minimum 15 sec delay between updates
  delay(1000);
}

Sooo..
Ich habe hier eine Meldung des Kompilers:

130:37: warning: format '%i' expects argument of type 'int', but argument 3 has type 'long unsigned int' [-Wformat=]
     sprintf(buffer,"%4i U/min ",umin);    // mit Nullen - sprintf(buffer,"%04i U/min ",umin); 4-Stellen Lagerichtig :-).
                                     ^
95:14: warning: variable 'kilometer' set but not used [-Wunused-but-set-variable]
   float kph, kilometer, ms;
              ^~~~~~~~~

warning: 'ms' may be used uninitialized in this function [-Wmaybe-uninitialized]
   dtostrf(ms, 5, 2, buffer);
          ^

Da passt was nicht.

defines sind kontraproduktiv.
was sich nicht verändern kann: const.
Und dann verwendest das auch nicht:

Da ist noch viel Spielraum, bis erstmal einer gebaut ist.
Na mal sehen - ich schau mal drauf, was geht.

Ich habe den Windmesser am laufen mit 20x4 Display funktioniert auch . Ich möchte nur die umrechnung mit ausgabe KMH in den anderen Sketch integrieren um es auf Think Speak zusehen.

Dann kann ich Dir nicht helfen.
Das die Ausgabe funktioniert bestreite ich nicht, aber wenn ich etwas baue, soll es fehlerfrei sein.
Das Grundgerüst ist es nicht - Ich hätte das anders gemacht. Insbesondere auch die Zuweisung der Variablen von oben nach unten.

Meiner angesetzt:

// Anzahl Spalten des Display (20)
const byte LCD_WIDTH = 20;
// Anzahl Zeilen des Display (4)
const byte LCD_HEIGHT = 4;

#include <Wire.h>
#include <LiquidCrystal_I2C.h> //NewLiquidCrystal - https://bitbucket.org/fmalpartida/new-liquidcrystal/downloads/
LiquidCrystal_I2C lcd(0x27, LCD_WIDTH, LCD_HEIGHT); // (LCD2004) Set the LCD I2C address
//LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE); // Addr, En, Rw, Rs, d4, d5, d6, d7, backlighpin, polarity


// Pin für Reed-Kontakt, Digital-2 für Interrupt 0
const byte REEDPIN = 2;

// Hardware-Interrupt für den Reed-Pin
const byte REEDINTERRUPT = 0;

// Umfang in mm wurde im Windkanal mit dem Volkswindmesser ermittelt als Referenz
const unsigned int RADUMFANG = 2200;

// LED Balken
const byte led05 = 11;                // LED connected to digital pin 11
const byte led10 = 10;               // LED connected to digital pin 10
const byte led15 = 9;                // LED connected to digital pin 9
const byte led20 = 8;                // LED connected to digital pin 8
const byte led25 = 7;                // LED connected to digital pin 7
const byte led30 = 6;                // LED connected to digital pin 6


const byte ledalarm = 13;            // LED ALARM

const byte resetmaxpin = 4;         // reset max Pin (button)
const byte resetalarmpin = 5;       // reset Alarm Pin (button)

unsigned long interval;           // update LCD/LED interval (milliseconds)
unsigned long previousMillis = 0;
unsigned long intervalalarm = 200;           // update Alarm Anzeige interval (milliseconds)
unsigned long previousMillisalarm = 0;

unsigned long currentMillis;

const byte potpin = A0;  // analog pin used to connect the potentiometer
int val;    // variable to read the value from the analog pin

float ms2; //globale Variable Speed in m/s
float msmax = 0;  //Maximalwert
unsigned long umin; // U/min

int alarm; // Alarmgrenze in m/s (meter/sekunde)


volatile byte reedCountSum;
volatile long reedMillisSum;

unsigned long lastReedMillis;

unsigned long gesamtUmdrehungen = 0; //4545300;

void setup()
{

Und da ist noch ganz viel weiteres Kürzungs- und Sortierpotential.

Wenn Dir reicht was Du hast, muss sich jemand anders das ansehen. Ich kann damit nicht arbeiten.

Du hast zumindest meinen Hinweis auf Deine Passwörter beherzigt.
Na denn.

Den kompleten Sketch habe ich bei Schubert Gehäuse runter geladen.Da ich nicht Programieren kann.

Für die Nachwelt:
Der Sketch stammt von:

http://www.schubert-gehaeuse.de/media/files/Volkswindmesser.zip

Das Unternehmen benutzt kein https.

http://www.schubert-gehaeuse.de/anemometer.html

Das ist tatsächlich schon so gebaut.
Schade.

[edit]:
Die Forensoftware versucht den Inhalt der Links wiederzugeben. Um zu vermeiden, das "unsichere Verbindung" aktiviert wird, sind die Seiten in codetags gepackt.
[/edit]

Hallo ich habe noch nicht aufgegeben ,vieleicht möchte mir einer Helfen ,mein Windmesser auf Thinkspeak zubekommen.

#include <OneWire.h>
//#include <DallasTemperature.h>
//#include "ThingSpeak.h"
#include <ESP8266WiFi.h>

#define UPM 0
#define Temp 2

OneWire ds(2);
//DallasTemperature DS18B20(&oneWire);

char temperaturStr[6];
uint8_t Upm_Pin = 0;
const int m_time = 5; //Messzeit für Upm
float Upm;
int UPM_ct;

unsigned long ThingspeakLastLogTime = 0;
unsigned long SensorenLetzteAktualisierung; // Hilfsvariable für Zeitmessung
int ThingspeakSampleTime = 30000; // Die schnellste Sample Time ist 15s ich empfehle
// 60s zu verwenden oder 300 Sekunden
int SensorenSampleTime = 1; // Zeit in s für Aktualisierung der

WiFiClient client;
int status = WL_IDLE_STATUS;

unsigned long myChannelNumber = ; // ThingSpeak Kanal Nummer
const char * myWriteAPIKey = ""; // ThingSpeak API Key

char ssid = ""; // Wlan SSID (name)
char pass = ""; // Wlan Passwort

void setup() {
WiFi.begin(ssid, pass); // Wlan Aktivieren und mit definiertem Netzwerk verbinden
ThingSpeak.begin(client); // ThingSpeak Client starten
Serial.begin(115200);
DS18B20.begin();
}

float getTemperatur() {
float temp;
do {
DS18B20.requestTemperatures();
temp = DS18B20.getTempCByIndex(0);
delay(100);
}
while (temp == 85.0 || temp == (-127.0));
return temp;
}

void loop() {
meassure_UPM();

float temperatur = getTemperatur();
dtostrf(temperatur, 2, 2, temperaturStr);

Serial.print(" Upm: ");
Serial.print(Upm);
Serial.print(" Temp: ");
Serial.println(temperaturStr);

ThingSpeak.setField(0, Upm);
ThingSpeak.setField(2, temperaturStr);
ThingSpeak.writeFields(myChannelNumber, myWriteAPIKey);

}

void meassure_UPM() {
UPM_ct = 0;
attachInterrupt(digitalPinToInterrupt(Upm_Pin), IntCallback, RISING);
delay(1000 * m_time);
Upm = (float)UPM_ct * (float)m_time * 2.4 ;
}

void IntCallback() {
UPM_ct ++;
}

Moin,

geh mal in Dein Post, markiere den Code komplett und drücke dann auf den Button </>
Sonst ist das nicht verwertbar.
Danke

#include <OneWire.h>
//#include <DallasTemperature.h>
//#include "ThingSpeak.h"
#include <ESP8266WiFi.h>

#define UPM 0
#define Temp 2

OneWire  ds(2);
//DallasTemperature DS18B20(&oneWire);

char temperaturStr[6];
uint8_t Upm_Pin = 0;
const int m_time = 5;     //Messzeit für Upm
float Upm;
int UPM_ct;

unsigned long ThingspeakLastLogTime = 0;
unsigned long SensorenLetzteAktualisierung;   // Hilfsvariable für Zeitmessung
int ThingspeakSampleTime = 30000;             // Die schnellste Sample Time ist 15s ich empfehle
                                              // 60s zu verwenden oder 300 Sekunden
int SensorenSampleTime = 1;                   // Zeit in s für Aktualisierung der

WiFiClient  client;
int status = WL_IDLE_STATUS;

unsigned long myChannelNumber = ;          //  ThingSpeak Kanal Nummer
const char * myWriteAPIKey = "";               //  ThingSpeak API Key

char ssid[] = "";      //  Wlan SSID (name)
char pass[] = "";     // Wlan Passwort

void setup() {
  WiFi.begin(ssid, pass);       // Wlan Aktivieren und mit definiertem Netzwerk verbinden
  ThingSpeak.begin(client);   // ThingSpeak Client starten
  Serial.begin(115200);
  DS18B20.begin();
}

float getTemperatur() {
  float temp;
   do {
    DS18B20.requestTemperatures();
    temp = DS18B20.getTempCByIndex(0);
    delay(100);
   }
   while (temp == 85.0 || temp == (-127.0));
  return temp;
}

void loop() {
  meassure_UPM();

  float temperatur = getTemperatur();
  dtostrf(temperatur, 2, 2, temperaturStr);

  Serial.print(" Upm: ");
  Serial.print(Upm);
  Serial.print(" Temp: ");
  Serial.println(temperaturStr);

  ThingSpeak.setField(0, Upm);
  ThingSpeak.setField(2, temperaturStr);
 ThingSpeak.writeFields(myChannelNumber, myWriteAPIKey);
  
}

void meassure_UPM() {
  UPM_ct = 0;
  attachInterrupt(digitalPinToInterrupt(Upm_Pin), IntCallback, RISING);
  delay(1000 * m_time);
  Upm = (float)UPM_ct * (float)m_time * 2.4 ;
}

void IntCallback() {
  UPM_ct ++;
}

Lässt TS das zu? Da können doch nur 1 Meldung je 15 Sekunden abgekippt werden.

Somit musst Du den Code an der Stelle aufteilen, damit Du nicht ausgesperrt bist.

Besser so,ich bin da nicht so gut drin soory.
Versuche jetzt fast 2 Monaten das hinzubekommen, aber immer irgendwelche Fehlermeldungen.
Bitte um Hilfe, das es funktioniert.

Und wie teile ich ihn auf ,habe keine Ahnung.

Dann erstmal Grundlagen lernen - DATEI - BEISPIELE - und dort wenigstens DIGITAL - Blink without delay().

Das versenden dann in einen solch geschaffenen Block verschieben.

Also zum Blinken bekomme ich ihn. Kann sogar Temperatur an Thinkspeak senden und über Handy anzeigen lassen.
Aber ich bekomme den Windmesser nicht eingefügt.
Trotzdem Danke für die Unterstützung, ich wollte keine Bachelor Arbeit darüber schreiben ,sondern nur die Daten auf mein Handy schicken.