Production photovoltaïque et surplus…

Publié le 24 octobre 2023 par daniel

Depuis le 28/09/2023, je suis équipé d’une centrale photovoltaïque de 3KWc….

L’achat s’est plutôt bien passé mais la revente du surplus qui doit rentabiliser la bête, se fait attendre…

Alors plutôt que d’injecter gratuitement le surplus, l’idée m’est venue d’en utiliser une partie pour mon vieux chauffe eau électrique…

Je suis connecté au Linky par un petit module ESP8266 qui envoie les données à mon serveur Domoticz

Je peux ainsi suivre consommation et production en direct ou presque…

En mode historique le Linky donne 2 informations:
IINST intensité instantanée
PAPP puissance apparante

PAPP est nul en cas d’injection mais pas IINST

Donc quand PAPP est nul est que IINST est supérieur à mon talon de consommation+ la consommation dudit chauffe eau, je décide de l’alimenter sinon on coupe….

Comme le chauffe eau est télécommandable par Domoticz via une prise RF 433 Chacon, cela n’a pas été difficile

    WiFiClient client;
    HTTPClient http; 
    Serial.print("[HTTP] begin...\n");
    // get data from linky
    http.begin(client, "http://192.168.1.61");//c'est le module esp8266 pour la transmission des données

    Serial.print("[HTTP] GET...\n");
    // start connection and send HTTP header
    int httpCode = http.GET();
    if (httpCode > 0) {
      // HTTP header has been send and Server response header has been handled
      Serial.printf("[HTTP] GET... code: %d\n", httpCode);

      // file found at server
      if (httpCode == HTTP_CODE_OK) {
        //la requete HTTP du module relié au linky est succesfull
        String s = http.getString();
        Serial.println(s);//résultat de la requête HTTP
        //on va chercher PAPP**********************************************************
        for (int p = 1; p < s.length(); p++)
          if ((s[p] == 'P') && (s[p + 1] == 'A') && (s[p + 2] == 'P')) {
            String papp = s.substring(p, p + 10);
            Serial.println("Trouvé:" + papp);
            int valPapp = papp.substring(5, 10).toInt();
            Serial.println(valPapp);
            sendToDomoticz(String(2892), String(valPapp));
            if (valPapp < 10) {//valPAPP <10 ,de la puissance est disponible
              digitalWrite(greenPin, HIGH);
              digitalWrite(redPin, LOW);
              digitalWrite(bluePin, LOW);
              delay(1000);
              //on va chercher IINST*************************************************
              for (int p = 1; p < s.length(); p++)
                if ((s[p] == 'I') && (s[p + 1] == 'I') && (s[p + 2] == 'N')) {
                  String iinst = s.substring(p, p + 9);
                  Serial.println("Trouvé:" + iinst);
                  int valIinst = iinst.substring(6, 9).toInt();
                  Serial.println(iinst);
                  if ((valIinst >= 4)) { si puissance >880 W on peut envoyer au chauffe eau
                    digitalWrite(bluePin, HIGH);
                    Serial.println("Allumage du chauffe-eau");
                    sendCommandeToDomotiz("http://192.168.1.13:8080/json.htm?type=command&param=switchlight&idx=2503&switchcmd=On");
                  } else {
                    Serial.println("Extinction du chauffe-eau");
                    sendCommandeToDomotiz("http://192.168.1.13:8080/json.htm?type=command&param=switchlight&idx=2503&switchcmd=Off");
                  }
                }
            } else {
              Serial.println("Extinction du chauffe-eau");
              sendCommandeToDomotiz("http://192.168.1.13:8080/json.htm?type=command&param=switchlight&idx=2503&switchcmd=Off");
              if (valPapp > 1000) {//valPAPP >1000 rouge
                digitalWrite(bluePin, LOW);
                digitalWrite(greenPin, LOW);
                digitalWrite(redPin, HIGH);
              } else {//valPAPP >10 et <1000 rouge+vert
                digitalWrite(bluePin, LOW);
                digitalWrite(greenPin, HIGH);
                digitalWrite(redPin, HIGH);
              }
            }
          }
      }
      Serial.println();
      Serial.print("[HTTP] connection closed or file end.\n");

    } else {
      Serial.printf("[HTTP] GET... failed, error: %s\n", http.errorToString(httpCode).c_str());
      ESP.restart();
    }

    http.end();
  }

WiFiClient client;

HTTPClient http;

Serial.print("[HTTP] begin...\n");

// get data from linky

http.begin(client, "http://192.168.1.61");//c'est le module esp8266 pour la transmission des données

Serial.print("[HTTP] GET...\n");

// start connection and send HTTP header

int httpCode = http.GET();

if (httpCode > 0) {

// HTTP header has been send and Server response header has been handled

Serial.printf("[HTTP] GET... code: %d\n", httpCode);

// file found at server

if (httpCode == HTTP_CODE_OK) {

//la requete HTTP du module relié au linky est succesfull

String s = http.getString();

Serial.println(s);//résultat de la requête HTTP

//on va chercher PAPP**********************************************************

for (int p = 1; p < s.length(); p++)

if ((s[p] == 'P') && (s[p + 1] == 'A') && (s[p + 2] == 'P')) {

String papp = s.substring(p, p + 10);

Serial.println("Trouvé:" + papp);

int valPapp = papp.substring(5, 10).toInt();

Serial.println(valPapp);

sendToDomoticz(String(2892), String(valPapp));

if (valPapp < 10) {//valPAPP <10 ,de la puissance est disponible

digitalWrite(greenPin, HIGH);

digitalWrite(redPin, LOW);

digitalWrite(bluePin, LOW);

delay(1000);

//on va chercher IINST*************************************************

for (int p = 1; p < s.length(); p++)

if ((s[p] == 'I') && (s[p + 1] == 'I') && (s[p + 2] == 'N')) {

String iinst = s.substring(p, p + 9);

Serial.println("Trouvé:" + iinst);

int valIinst = iinst.substring(6, 9).toInt();

Serial.println(iinst);

if ((valIinst >= 4)) { si puissance >880 W on peut envoyer au chauffe eau

digitalWrite(bluePin, HIGH);

Serial.println("Allumage du chauffe-eau");

sendCommandeToDomotiz("http://192.168.1.13:8080/json.htm?type=command&param=switchlight&idx=2503&switchcmd=On");

} else {

Serial.println("Extinction du chauffe-eau");

sendCommandeToDomotiz("http://192.168.1.13:8080/json.htm?type=command&param=switchlight&idx=2503&switchcmd=Off");

}

} else {

Serial.println("Extinction du chauffe-eau");

sendCommandeToDomotiz("http://192.168.1.13:8080/json.htm?type=command&param=switchlight&idx=2503&switchcmd=Off");

if (valPapp > 1000) {//valPAPP >1000 rouge

digitalWrite(bluePin, LOW);

digitalWrite(greenPin, LOW);

digitalWrite(redPin, HIGH);

} else {//valPAPP >10 et <1000 rouge+vert

digitalWrite(bluePin, LOW);

digitalWrite(greenPin, HIGH);

digitalWrite(redPin, HIGH);

}

Serial.println();

Serial.print("[HTTP] connection closed or file end.\n");

} else {

Serial.printf("[HTTP] GET... failed, error: %s\n", http.errorToString(httpCode).c_str());

ESP.restart();

}

http.end();

}

Publié dans Non classé | Laisser un commentaire

Mon Serveur Domoticz…

Publié le 20 juin 2021 par daniel

Fonctionnalités en liaison avec RFLINK ( sur arduino):
1- asservissement arrosage
2- asservissement veilleuse de nuit
3- publication WebCams
4- surveillance ouverture portes, fenêtres et boite aux lettres
5- automatisation on/off alarme HA500
6- gestion du pluviomètre WH0351

7- Ajouter il y quelques mois: la consommation électrique avec la TeleInfo du compteur LinkyEn détail:

Publié dans Non classé | Laisser un commentaire

Solveur de Rubik’s cube

Publié le 23 juillet 2020 par daniel

Il est içi
c’est une applet, il faut donc autoriser java…
et un navigateur compatible...(la dernière version de FireFox ne l’est plus)
Pour les navigateurs non compatibles essayer ce lien… et exécuter le jnlp.

On peut saisir un cube, on choisit la couleur par le centre d’une face….

Un petite démo ? (rb3.avi) ou http://youtu.be/yRePknD7zQI

La méthode utilisée est « the Two-Phase Algorithm »
trouvée ici dans un premier temps et ici pour les dernières versions

Mais, ça n’a pas suffit…
Quand j’ai trouvé ce machin sur Internet,il m’en a fallu un absolument:

Super!…
Bon, je n’ai rien inventé, tout provient de la:
http://mindcuber.com/index.html

mais quel plaisir !

Publié dans Uncategorized | Laisser un commentaire

Traceurs 2D

Publié le 29 juillet 2019 par daniel

Traceurs 2D

Et 1 (avec ces jolies petites choses…)

et 2 (avec des vieux moteurs de lecteur de disquette 5 pouces)

et 3 (mécaniques de 2 vieux scanners, bonne précision mais très lents..)

voila un moment que je m’intéresse à ces choses là et nombreux sont les tutos sur internet… du miniCNC avec des lecteurs CD au graveur laser pro, par exemple un des premiers à m’inspirer

https://www.instructables.com/Mini-CNC-Plotter-Arduino-Based/

mais j’ai eu des problèmes avec les lineTo ou gotoXY ou drawXY ou…etc

en effet souvent les tracés ne se raccordaient pas ou des problèmes apparaissaient lors du traçage, les procédures de tracé de segment n’étaient en effet pas correctes quand il fallait convertir des mm de distance en pas moteur….on demande de tracer 11,47 mm avec des système moteurs-poulies ( de récupération) dont la résolution ne dépasse pas 0,4 mm, forcément des erreurs apparaissent…et s’accumulent…

La première solution a été de ne pas oublier, à la fin du tracé de préciser l’endroit ou on a abouti, ce n’est pas parce qu’on veut aller à un endroit qu’on s’y retrouve (problème de résolution…)

Voici donc ma procédure:

void gotoXYmm(float x, float y) {
 if (x &lt; 0) x = 0;
 if (y &lt; 0) y = 0; if (x &gt; Xmax) x = Xmax;
 if (y &gt; Ymax) y = Ymax;
 int dxpas, dypas;
 dxpas = int((x - Xpos) * StepsPerMillimeterX);
 dypas = int((y - Ypos) * StepsPerMillimeterY);
 Serial.println("gotoXYmm dxpas=" + String(dxpas) + " dypas=" + String(dypas));
 if (dxpas == 0) {
  moveY(dypas);
  Ypas = Ypas + dypas;
 }
 else if (dypas == 0) {
  moveX(dxpas);
  Xpas = Xpas + dxpas;
 }
else {
  gotoXpasYpas(0, 0, dxpas, dypas);
  Xpas = Xpas + dxpas;
  Ypas = Ypas + dypas;
}
Xpos = Xpas / StepsPerMillimeterX;
Ypos = Ypas / StepsPerMillimeterY;
montrePosition();
}

void gotoXYmm(float x, float y) {

if (x < 0) x = 0;

if (y < 0) y = 0; if (x > Xmax) x = Xmax;

if (y > Ymax) y = Ymax;

int dxpas, dypas;

dxpas = int((x - Xpos) * StepsPerMillimeterX);

dypas = int((y - Ypos) * StepsPerMillimeterY);

Serial.println("gotoXYmm dxpas=" + String(dxpas) + " dypas=" + String(dypas));

if (dxpas == 0) {

moveY(dypas);

Ypas = Ypas + dypas;

}

else if (dypas == 0) {

moveX(dxpas);

Xpas = Xpas + dxpas;

}

else {

gotoXpasYpas(0, 0, dxpas, dypas);

Xpas = Xpas + dxpas;

Ypas = Ypas + dypas;

}

Xpos = Xpas / StepsPerMillimeterX;

Ypos = Ypas / StepsPerMillimeterY;

montrePosition();

}

ce sont les dernières lignes Xpos=… et Ypos=… qui rétablissent la situation…

Ceci a réglé pas mal de problème mais certains subsistaient dans l’implémentation de l’algorithme de Bresenham pour le tracé de segment en pas moteur, celle qui suit à régler tous les problèmes et en prime elle est la plus courte…:

void gotoXpasYpas(int x0, int y0, int x1, int y1) {
  int dx = abs(x1 - x0), sx = x0 < x1 ? 1 : -1;
  int dy = abs(y1 - y0), sy = y0 < y1 ? 1 : -1;
  int err = (dx > dy ? dx : -dy) / 2, e2;
  for (;;) {
    //setPixel(x0,y0);
    //Serial.println("je suis la, x0:" + String(x0) + " y0:" + String(y0));
    if (x0 == x1 && y0 == y1) break;
    e2 = err;
    if (e2 > -dx) {
      err -= dy;
      x0 += sx;
      moveX(sx); delay(10);
    }
    if (e2 < dy) {
      err += dx;
      y0 += sy;
      moveY(sy); delay(10);
    }
  }
}

void gotoXpasYpas(int x0, int y0, int x1, int y1) {

int dx = abs(x1 - x0), sx = x0 < x1 ? 1 : -1;

int dy = abs(y1 - y0), sy = y0 < y1 ? 1 : -1;

int err = (dx > dy ? dx : -dy) / 2, e2;

for (;;) {

//setPixel(x0,y0);

//Serial.println("je suis la, x0:" + String(x0) + " y0:" + String(y0));

if (x0 == x1 && y0 == y1) break;

e2 = err;

if (e2 > -dx) {

err -= dy;

x0 += sx;

moveX(sx); delay(10);

}

if (e2 < dy) {

err += dx;

y0 += sy;

moveY(sy); delay(10);

}

et voila c’est super…

F-Engrave

https://www.scorchworks.com/Fengrave/fengrave.html

Je cherchais une solution pour plotter du texte, celle-ci fonctionne à merveilleJ’ai remplacé le scanner le plus lent par un moteur 100 pas programmé en 1/2pas et une petite poulie pour obtenir , sur cet axe, une résolution de 0.15 mm/pas, ce n’est pas si mal…

Sur l’autre axe, avec le vieux scanner, j’ai deux fois mieux

Publié dans Non classé | Laisser un commentaire

Pluviomètre WH0531 (à finir…)

Publié le 29 juillet 2019 par daniel

Après avoir bien joué avec le pluviométre1… , j’ai acheté ce WH0531
et je ne le regrette pas… pour environ 20 euros il fait le boulot…

Le problème est que le capteur ne communique qu’avec l’afficheur et moi je souhaitais récupérer les données pour enrichir ma BD…
En fouillant un peu je suis tombé sur ce site:
https://lucsmall.com/2012/04/27/weather-station-hacking-part-1/

et c’était parti pour une passerelle RF433-Internet adaptée à ce pluviomètre…

Quelques modifications pour intercepter complétement les paquets envoyés par le WH0531

/*
Updated code for receiving data from WH2 weather station
This code implements timeouts to make decoding more robust
Decodes received packets and writes a summary of each packet to the Arduino's
serial port
Created by Luc Small on 19 July 2013.
Released into the public domain.
*/

// Read data from 433MHz receiver on digital pin 2
#define RF_IN 2
// For better efficiency, the port is read directly
// the following two lines should be changed appropriately
// if the line above is changed.
#define RF_IN_RAW PIND2
#define RF_IN_PIN PIND

// Port that is hooked to LED to indicate a packet has been received
#define LED_PACKET A2

#define COUNTER_RATE 3200-1 // 16,000,000Hz / 3200 = 5000 interrupts per second, ie. 200us between interrupts
// 1 is indicated by 500uS pulse
// wh2_accept from 2 = 400us to 3 = 600us
#define IS_HI_PULSE(interval) (interval &gt;= 2 &amp;&amp; interval &lt;= 3)
// 0 is indicated by ~1500us pulse
// wh2_accept from 7 = 1400us to 8 = 1600us
#define IS_LOW_PULSE(interval) (interval &gt;= 7 &amp;&amp; interval &lt;= 8)
// worst case packet length
// 6 bytes x 8 bits x (1.5 + 1) = 120ms; 120ms = 200us x 600
#define HAS_TIMED_OUT(interval) (interval &gt; 600)
// we expect 1ms of idle time between pulses
// so if our pulse hasn't arrived by 1.2ms, reset the wh2_packet_state machine
// 6 x 200us = 1.2ms
#define IDLE_HAS_TIMED_OUT(interval) (interval &gt; 6)
// our expected pulse should arrive after 1ms
// we'll wh2_accept it if it arrives after
// 4 x 200us = 800us
#define IDLE_PERIOD_DONE(interval) (interval &gt;= 4)
// Shorthand for tests
//#define RF_HI (digitalRead(RF_IN) == HIGH)
//#define RF_LOW (digitalRead(RF_IN) == LOW)
#define RF_HI (bit_is_set(RF_IN_PIN, RF_IN_RAW))
#define RF_LOW (bit_is_clear(RF_IN_PIN, RF_IN_RAW))

// wh2_flags
#define GOT_PULSE 0x01
#define LOGIC_HI 0x02
volatile byte wh2_flags = 0;
volatile byte wh2_packet_state = 0;
volatile int wh2_timeout = 0;
#define nbp 7 //la modification la plus importante !...
byte wh2_packet[nbp];
byte wh2_calculated_crc;

ISR(TIMER1_COMPA_vect)
{
static byte sampling_state = 0;
static byte count;
static boolean was_low = false;

switch (sampling_state) {
case 0: // waiting
wh2_packet_state = 0;
if (RF_HI) {
if (was_low) {
count = 0;
sampling_state = 1;
was_low = false;
}
} else {
was_low = true;
}
break;
case 1: // acquiring first pulse
count++;
// end of first pulse
if (RF_LOW) {
if (IS_HI_PULSE(count)) {
wh2_flags = GOT_PULSE | LOGIC_HI;
sampling_state = 2;
count = 0;
} else if (IS_LOW_PULSE(count)) {
wh2_flags = GOT_PULSE; // logic low
sampling_state = 2;
count = 0;
} else {
sampling_state = 0;
}
}
break;
case 2: // observe 1ms of idle time
count++;
if (RF_HI) {
if (IDLE_HAS_TIMED_OUT(count)) {
sampling_state = 0;
} else if (IDLE_PERIOD_DONE(count)) {
sampling_state = 1;
count = 0;
}
}
break;
}

if (wh2_timeout &gt; 0) {
wh2_timeout++;
if (HAS_TIMED_OUT(wh2_timeout)) {
wh2_packet_state = 0;
wh2_timeout = 0;
}
}
}

void setup() {
Serial.begin(9600);
Serial.println("BetterWH2");

pinMode(LED_PACKET, OUTPUT);
pinMode(RF_IN, INPUT);

TCCR1A = 0x00;
TCCR1B = 0x09;
TCCR1C = 0x00;
OCR1A = COUNTER_RATE;
TIMSK1 = 0x02;

// enable interrupts
sei();
}

void loop() {
static unsigned long old = 0, packet_count = 0, bad_count = 0, average_interval;
unsigned long spacing, now;
byte i;

if (wh2_flags) {
if (wh2_accept()) {
// calculate the CRC
wh2_calculate_crc();

now = millis();
spacing = now - old;
old = now;
packet_count++;
average_interval = now / packet_count;
if (!wh2_valid()) {
bad_count++;
}

// flash green led to say got packet
digitalWrite(LED_PACKET, HIGH);
delay(100);
digitalWrite(LED_PACKET, LOW);

Serial.print(packet_count, DEC);
Serial.print(" | ");
Serial.print(bad_count, DEC);
Serial.print(" | ");
/* Serial.print(spacing, DEC);
Serial.print(" | ");
Serial.print(average_interval, DEC);
Serial.print(" | ");*/

for (i = 0; i &lt; nbp; i++) {
Serial.print("0x");
Serial.print(wh2_packet[i], HEX);
Serial.print("/");
Serial.print(wh2_packet[i], DEC);
Serial.print(" ");
}
for (i = 0; i &lt; nbp; i++) {
// Serial.print(wh2_packet[i], BIN);
Serial.print(ByteToBin(wh2_packet[i]));
if (i&lt;(nbp-1)) Serial.print("-");
}
Serial.print(" SensorID:0x");
Serial.print(wh2_sensor_id(), HEX);
Serial.print(" T:");
Serial.print(wh2_temperature(), DEC);
Serial.print(" R:");
Serial.print(wh2_rain(), DEC);
Serial.print((wh2_valid() ? " OK." : " BAD."));
Serial.println();
}
wh2_flags = 0x00;
}
}


// processes new pulse
boolean wh2_accept()
{
static byte packet_no, bit_no, history;

// reset if in initial wh2_packet_state
if (wh2_packet_state == 0) {
// should history be 0, does it matter?
history = 0xFF;
wh2_packet_state = 1;
// enable wh2_timeout
wh2_timeout = 1;
} // fall thru to wh2_packet_state one

// acquire preamble
if (wh2_packet_state == 1) {
// shift history right and store new value
history &lt;&lt;= 1;
// store a 1 if required (right shift along will store a 0)
if (wh2_flags &amp; LOGIC_HI) {
history |= 0x01;
}
// check if we have a valid start of frame
// xxxxx110
if ((history &amp; B00000111) == B00000110) {
// need to clear packet, and counters
packet_no = 0;
// start at 1 becuase only need to acquire 7 bits for first packet byte.
bit_no = 1;
wh2_packet[0] = wh2_packet[1] = wh2_packet[2] = wh2_packet[3] = wh2_packet[4] = 0;
// we've acquired the preamble
wh2_packet_state = 2;
}
return false;
}
// acquire packet
if (wh2_packet_state == 2) {

wh2_packet[packet_no] &lt;&lt;= 1;
if (wh2_flags &amp; LOGIC_HI) {
wh2_packet[packet_no] |= 0x01;
}

bit_no ++;
if (bit_no &gt; 7) {
bit_no = 0;
packet_no ++;
}

if (packet_no &gt; (nbp - 1)) {
// start the sampling process from scratch
wh2_packet_state = 0;
// clear wh2_timeout
wh2_timeout = 0;
return true;
}
}
return false;
}


void wh2_calculate_crc()
{
wh2_calculated_crc = crc8(wh2_packet, nbp-1);
}

bool wh2_valid()
{
return (wh2_calculated_crc == wh2_packet[nbp-1]);
}

int wh2_sensor_id()
{
return (wh2_packet[0] &lt;&lt; 4) + (wh2_packet[1] &gt;&gt; 4);
}

int wh2_rain()
{
return wh2_packet[3] + 256 * wh2_packet[4];
}

/* Temperature in deci-degrees. e.g. 251 = 25.1 */
int wh2_temperature()
{
int temperature;
temperature = ((wh2_packet[1] &amp; B00000111) &lt;&lt; 8) + wh2_packet[2] - 400;
// make negative
if (wh2_packet[1] &amp; B00001000) {
temperature = -temperature;
}
return temperature;
}

uint8_t crc8( uint8_t *addr, uint8_t len)
{
uint8_t crc = 0;

// Indicated changes are from reference CRC-8 function in OneWire library
while (len--) {
uint8_t inbyte = *addr++;
for (uint8_t i = 8; i; i--) {
uint8_t mix = (crc ^ inbyte) &amp; 0x80; // changed from &amp; 0x01
crc &lt;&lt;= 1; // changed from right shift
if (mix) crc ^= 0x31;// changed from 0x8C;
inbyte &lt;&lt;= 1; // changed from right shift
}
}
return crc;
}
String ByteToBin(byte b) {
String r = "";
for (int j = 0; j &lt; 8; j++) {
if (bitRead(b, j) == 1) r = "1" + r;
else r = "0" + r;
}
return r;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

Updated code for receiving data from WH2 weather station

This code implements timeouts to make decoding more robust

Decodes received packets and writes a summary of each packet to the Arduino's

serial port

Created by Luc Small on 19 July 2013.

Released into the public domain.

// Read data from 433MHz receiver on digital pin 2

#define RF_IN 2

// For better efficiency, the port is read directly

// the following two lines should be changed appropriately

// if the line above is changed.

#define RF_IN_RAW PIND2

#define RF_IN_PIN PIND

// Port that is hooked to LED to indicate a packet has been received

#define LED_PACKET A2

#define COUNTER_RATE 3200-1 // 16,000,000Hz / 3200 = 5000 interrupts per second, ie. 200us between interrupts

// 1 is indicated by 500uS pulse

// wh2_accept from 2 = 400us to 3 = 600us

#define IS_HI_PULSE(interval) (interval >= 2 && interval <= 3)

// 0 is indicated by ~1500us pulse

// wh2_accept from 7 = 1400us to 8 = 1600us

#define IS_LOW_PULSE(interval) (interval >= 7 && interval <= 8)

// worst case packet length

// 6 bytes x 8 bits x (1.5 + 1) = 120ms; 120ms = 200us x 600

#define HAS_TIMED_OUT(interval) (interval > 600)

// we expect 1ms of idle time between pulses

// so if our pulse hasn't arrived by 1.2ms, reset the wh2_packet_state machine

// 6 x 200us = 1.2ms

#define IDLE_HAS_TIMED_OUT(interval) (interval > 6)

// our expected pulse should arrive after 1ms

// we'll wh2_accept it if it arrives after

// 4 x 200us = 800us

#define IDLE_PERIOD_DONE(interval) (interval >= 4)

// Shorthand for tests

//#define RF_HI (digitalRead(RF_IN) == HIGH)

//#define RF_LOW (digitalRead(RF_IN) == LOW)

#define RF_HI (bit_is_set(RF_IN_PIN, RF_IN_RAW))

#define RF_LOW (bit_is_clear(RF_IN_PIN, RF_IN_RAW))

// wh2_flags

#define GOT_PULSE 0x01

#define LOGIC_HI 0x02

volatile byte wh2_flags = 0;

volatile byte wh2_packet_state = 0;

volatile int wh2_timeout = 0;

#define nbp 7 //la modification la plus importante !...

byte wh2_packet[nbp];

byte wh2_calculated_crc;

ISR(TIMER1_COMPA_vect)

{

static byte sampling_state = 0;

static byte count;

static boolean was_low = false;

switch (sampling_state) {

case 0: // waiting

wh2_packet_state = 0;

if (RF_HI) {

if (was_low) {

count = 0;

sampling_state = 1;

was_low = false;

}

} else {

was_low = true;

}

break;

case 1: // acquiring first pulse

count++;

// end of first pulse

if (RF_LOW) {

if (IS_HI_PULSE(count)) {

wh2_flags = GOT_PULSE | LOGIC_HI;

sampling_state = 2;

count = 0;

} else if (IS_LOW_PULSE(count)) {

wh2_flags = GOT_PULSE; // logic low

sampling_state = 2;

count = 0;

} else {

sampling_state = 0;

}

break;

case 2: // observe 1ms of idle time

count++;

if (RF_HI) {

if (IDLE_HAS_TIMED_OUT(count)) {

sampling_state = 0;

} else if (IDLE_PERIOD_DONE(count)) {

sampling_state = 1;

count = 0;

}

break;

}

if (wh2_timeout > 0) {

wh2_timeout++;

if (HAS_TIMED_OUT(wh2_timeout)) {

wh2_packet_state = 0;

wh2_timeout = 0;

}

void setup() {

Serial.begin(9600);

Serial.println("BetterWH2");

pinMode(LED_PACKET, OUTPUT);

pinMode(RF_IN, INPUT);

TCCR1A = 0x00;

TCCR1B = 0x09;

TCCR1C = 0x00;

OCR1A = COUNTER_RATE;

TIMSK1 = 0x02;

// enable interrupts

sei();

}

void loop() {

static unsigned long old = 0, packet_count = 0, bad_count = 0, average_interval;

unsigned long spacing, now;

byte i;

if (wh2_flags) {

if (wh2_accept()) {

// calculate the CRC

wh2_calculate_crc();

now = millis();

spacing = now - old;

old = now;

packet_count++;

average_interval = now / packet_count;

if (!wh2_valid()) {

bad_count++;

}

// flash green led to say got packet

digitalWrite(LED_PACKET, HIGH);

delay(100);

digitalWrite(LED_PACKET, LOW);

Serial.print(packet_count, DEC);

Serial.print(" | ");

Serial.print(bad_count, DEC);

Serial.print(" | ");

/* Serial.print(spacing, DEC);

Serial.print(" | ");

Serial.print(average_interval, DEC);

Serial.print(" | ");*/

for (i = 0; i < nbp; i++) {

Serial.print("0x");

Serial.print(wh2_packet[i], HEX);

Serial.print("/");

Serial.print(wh2_packet[i], DEC);

Serial.print(" ");

}

for (i = 0; i < nbp; i++) {

// Serial.print(wh2_packet[i], BIN);

Serial.print(ByteToBin(wh2_packet[i]));

if (i<(nbp-1)) Serial.print("-");

}

Serial.print(" SensorID:0x");

Serial.print(wh2_sensor_id(), HEX);

Serial.print(" T:");

Serial.print(wh2_temperature(), DEC);

Serial.print(" R:");

Serial.print(wh2_rain(), DEC);

Serial.print((wh2_valid() ? " OK." : " BAD."));

Serial.println();

}

wh2_flags = 0x00;

}

// processes new pulse

boolean wh2_accept()

{

static byte packet_no, bit_no, history;

// reset if in initial wh2_packet_state

if (wh2_packet_state == 0) {

// should history be 0, does it matter?

history = 0xFF;

wh2_packet_state = 1;

// enable wh2_timeout

wh2_timeout = 1;

} // fall thru to wh2_packet_state one

// acquire preamble

if (wh2_packet_state == 1) {

// shift history right and store new value

history <<= 1;

// store a 1 if required (right shift along will store a 0)

if (wh2_flags & LOGIC_HI) {

history |= 0x01;

}

// check if we have a valid start of frame

// xxxxx110

if ((history & B00000111) == B00000110) {

// need to clear packet, and counters

packet_no = 0;

// start at 1 becuase only need to acquire 7 bits for first packet byte.

bit_no = 1;

wh2_packet[0] = wh2_packet[1] = wh2_packet[2] = wh2_packet[3] = wh2_packet[4] = 0;

// we've acquired the preamble

wh2_packet_state = 2;

}

return false;

}

// acquire packet

if (wh2_packet_state == 2) {

wh2_packet[packet_no] <<= 1;

if (wh2_flags & LOGIC_HI) {

wh2_packet[packet_no] |= 0x01;

}

bit_no ++;

if (bit_no > 7) {

bit_no = 0;

packet_no ++;

}

if (packet_no > (nbp - 1)) {

// start the sampling process from scratch

wh2_packet_state = 0;

// clear wh2_timeout

wh2_timeout = 0;

return true;

}

return false;

}

void wh2_calculate_crc()

{

wh2_calculated_crc = crc8(wh2_packet, nbp-1);

}

bool wh2_valid()

{

return (wh2_calculated_crc == wh2_packet[nbp-1]);

}

int wh2_sensor_id()

{

return (wh2_packet[0] << 4) + (wh2_packet[1] >> 4);

}

int wh2_rain()

{

return wh2_packet[3] + 256 * wh2_packet[4];

}

/* Temperature in deci-degrees. e.g. 251 = 25.1 */

int wh2_temperature()

{

int temperature;

temperature = ((wh2_packet[1] & B00000111) << 8) + wh2_packet[2] - 400;

// make negative

if (wh2_packet[1] & B00001000) {

temperature = -temperature;

}

return temperature;

}

uint8_t crc8( uint8_t *addr, uint8_t len)

{

uint8_t crc = 0;

// Indicated changes are from reference CRC-8 function in OneWire library

while (len--) {

uint8_t inbyte = *addr++;

for (uint8_t i = 8; i; i--) {

uint8_t mix = (crc ^ inbyte) & 0x80; // changed from & 0x01

crc <<= 1; // changed from right shift

if (mix) crc ^= 0x31;// changed from 0x8C;

inbyte <<= 1; // changed from right shift

}

return crc;

}

String ByteToBin(byte b) {

String r = "";

for (int j = 0; j < 8; j++) {

if (bitRead(b, j) == 1) r = "1" + r;

else r = "0" + r;

}

return r;

}

Résultat: Il intercepte les paquets destinés à l’afficheur et envoie sur ma BD internet uniquement les données RAIN (R:octets 4 et 5), BD consultable içi.

Un module similaire permet d’asservir mon arrosage automatique…

Publié dans Non classé | Laisser un commentaire

Pluviomètre 1

Publié le 29 juillet 2019 par daniel

Il y a longtemps que j’y pensais…Il est enfin la…

Grace à ma dernière acquisition et à ThingIverse

j’ai pu réalisé ceci

en ajoutant puis

puis encore et et …

#include <ESP8266WiFi.h>
#include <ESP8266HTTPClient.h>

const int interruptPin = 0; //GPIO 0=D3 (Flash Button)
const int LED = 2; //On board blue LED
volatile byte compteur = 0;
volatile boolean change = true;
const char* ssid = "ZEOP-d751a3";
const char* password = "xxxxxx";
WiFiServer server(80);
unsigned long debut;
boolean ledOnOff = true;
int i = 0;

void setup() {
  Serial.begin(115200);
  //digitalWrite(LED, LOW); //LED on
  Serial.print("Connecting to ");
  Serial.println(ssid);
  WiFi.hostname("PLUVIOMETRE");
  WiFi.begin(ssid, password);
  while ((WiFi.status() != WL_CONNECTED) && (i++ < 100)) {
    if (ledOnOff) digitalWrite(LED, LOW); //LED on
    else digitalWrite(LED, HIGH);
    ledOnOff = !ledOnOff;
    delay(500);
    Serial.print("." + String(i));
  }
  Serial.println("");
  Serial.println("WiFi connected");
  // Start the server
  server.begin();
  Serial.println("Server started");

  // Print the IP address
  Serial.print("Use this URL to connect: ");
  Serial.print("http://");
  Serial.print(WiFi.localIP());
  Serial.println("/");

  pinMode(LED, OUTPUT);
  pinMode(interruptPin, INPUT_PULLUP);
  //digitalWrite(LED, HIGH);
  attachInterrupt(digitalPinToInterrupt(interruptPin), handleInterrupt, FALLING);
  debut = millis();
  Serial.println(debut);
  digitalWrite(LED, HIGH); //LED off
}

void loop() {
  if (change) {
    digitalWrite(LED, LOW); //LED on
    Serial.println(compteur);
    change = false;
    delay(100);//evite les rebonds?
    attachInterrupt(digitalPinToInterrupt(interruptPin), handleInterrupt, FALLING);
  }
  if (i++ > 100) {
    digitalWrite(LED, LOW); //LED on
    delay(10);
    digitalWrite(LED, HIGH);
    i=0;
  }
  delay(10);
  gereClientWifi();

  if ((millis() - debut) > (1000 * 60)) {
    Serial.println("Faut sauvegarder " + String(compteur));
    SendToPluviometre();
    compteur = 0;
    debut = millis();
  }
}
void SendToPluviometre() {
  //***************************************************************
  if (compteur > 0) {
    String c = String(compteur);
    String data = "?ticks=" + c;
    HTTPClient http;

    Serial.print("[HTTP] begin...\n");

    http.begin("http://www.daniel974.fr/pluviometre/xxxxxx.php" + data); //HTTP

    Serial.print("[HTTP] GET...\n");
    Serial.print("http://www.daniel974.fr/pluviometre/xxxxxx.php"); Serial.print(data); Serial.print("\n");
    // start connection and send HTTP header
    int httpCode = http.GET();

    // httpCode will be negative on error
    if (httpCode > 0) {
      // HTTP header has been send and Server response header has been handled
      Serial.printf("[HTTP] GET... code: %d\n", httpCode);

      // file found at server
      if (httpCode == HTTP_CODE_OK) {
        String payload = http.getString();
        Serial.println(payload);
      }
    } else {
      Serial.printf("[HTTP] GET... failed, error: %s\n", http.errorToString(httpCode).c_str());
    }
    http.end();
  }
}
//This program get executed when interrupt is occures i.e.change of input state
void handleInterrupt() {
  detachInterrupt(digitalPinToInterrupt(interruptPin));
  compteur++;
  change = true;
}

void gereClientWifi() {
  // Check if a client has connected
  WiFiClient client = server.available();
  if (!client) {
    return;
  }

  // Wait until the client sends some data
  Serial.println("new client");
  while (!client.available()) {
    delay(1);
  }

  // Read the first line of the request
  String request = client.readStringUntil('\r');
  Serial.println(request);
  client.flush();

  // Return the response
  client.println("HTTP/1.1 200 OK");
  client.println("Content-Type: text/html");
  client.println(""); //  do not forget this one
  client.println("<!DOCTYPE HTML>");
  client.println("<html>");
  client.println("<head><meta http-equiv=\"refresh\" content=\"10\"></head>");
  client.println("<center><h1>Pluviometre<hr>Nombre de basculements: ");
  client.println(compteur);
  client.println("</h1><br>");
  client.println("</html>");

  delay(1);
  Serial.println("Client disonnected");
  Serial.println("");
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

#include <ESP8266WiFi.h>

#include <ESP8266HTTPClient.h>

const int interruptPin = 0; //GPIO 0=D3 (Flash Button)

const int LED = 2; //On board blue LED

volatile byte compteur = 0;

volatile boolean change = true;

const char* ssid = "ZEOP-d751a3";

const char* password = "xxxxxx";

WiFiServer server(80);

unsigned long debut;

boolean ledOnOff = true;

int i = 0;

void setup() {

Serial.begin(115200);

//digitalWrite(LED, LOW); //LED on

Serial.print("Connecting to ");

Serial.println(ssid);

WiFi.hostname("PLUVIOMETRE");

WiFi.begin(ssid, password);

while ((WiFi.status() != WL_CONNECTED) && (i++ < 100)) {

if (ledOnOff) digitalWrite(LED, LOW); //LED on

else digitalWrite(LED, HIGH);

ledOnOff = !ledOnOff;

delay(500);

Serial.print("." + String(i));

}

Serial.println("");

Serial.println("WiFi connected");

// Start the server

server.begin();

Serial.println("Server started");

// Print the IP address

Serial.print("Use this URL to connect: ");

Serial.print("http://");

Serial.print(WiFi.localIP());

Serial.println("/");

pinMode(LED, OUTPUT);

pinMode(interruptPin, INPUT_PULLUP);

//digitalWrite(LED, HIGH);

attachInterrupt(digitalPinToInterrupt(interruptPin), handleInterrupt, FALLING);

debut = millis();

Serial.println(debut);

digitalWrite(LED, HIGH); //LED off

}

void loop() {

if (change) {

digitalWrite(LED, LOW); //LED on

Serial.println(compteur);

change = false;

delay(100);//evite les rebonds?

attachInterrupt(digitalPinToInterrupt(interruptPin), handleInterrupt, FALLING);

}

if (i++ > 100) {

digitalWrite(LED, LOW); //LED on

delay(10);

digitalWrite(LED, HIGH);

i=0;

}

delay(10);

gereClientWifi();

if ((millis() - debut) > (1000 * 60)) {

Serial.println("Faut sauvegarder " + String(compteur));

SendToPluviometre();

compteur = 0;

debut = millis();

}

void SendToPluviometre() {

//***************************************************************

if (compteur > 0) {

String c = String(compteur);

String data = "?ticks=" + c;

HTTPClient http;

Serial.print("[HTTP] begin...\n");

http.begin("http://www.daniel974.fr/pluviometre/xxxxxx.php" + data); //HTTP

Serial.print("[HTTP] GET...\n");

Serial.print("http://www.daniel974.fr/pluviometre/xxxxxx.php"); Serial.print(data); Serial.print("\n");

// start connection and send HTTP header

int httpCode = http.GET();

// httpCode will be negative on error

if (httpCode > 0) {

// HTTP header has been send and Server response header has been handled

Serial.printf("[HTTP] GET... code: %d\n", httpCode);

// file found at server

if (httpCode == HTTP_CODE_OK) {

String payload = http.getString();

Serial.println(payload);

}

} else {

Serial.printf("[HTTP] GET... failed, error: %s\n", http.errorToString(httpCode).c_str());

}

http.end();

}

//This program get executed when interrupt is occures i.e.change of input state

void handleInterrupt() {

detachInterrupt(digitalPinToInterrupt(interruptPin));

compteur++;

change = true;

}

void gereClientWifi() {

// Check if a client has connected

WiFiClient client = server.available();

if (!client) {

return;

}

// Wait until the client sends some data

Serial.println("new client");

while (!client.available()) {

delay(1);

}

// Read the first line of the request

String request = client.readStringUntil('\r');

Serial.println(request);

client.flush();

// Return the response

client.println("HTTP/1.1 200 OK");

client.println("Content-Type: text/html");

client.println(""); // do not forget this one

client.println("<!DOCTYPE HTML>");

client.println("<html>");

client.println("<head><meta http-equiv=\"refresh\" content=\"10\"></head>");

client.println("<center><h1>Pluviometre<hr>Nombre de basculements: ");

client.println(compteur);

client.println("</h1> ");

client.println("</html>");

delay(1);

Serial.println("Client disonnected");

Serial.println("");

}

J’ai obtenu

qui donne cela:

(un tick c’est environ 1 mm de pluie, mais je vais changer(augmenter) l’entonnoir…)

Publié dans Non classé | Laisser un commentaire

Sniffer RF433 MHz et télécommandes 433MHz (à finir…)

Publié le 28 juillet 2019 par daniel

J’avais essayé il y a déjà longtemps les émetteurs et le récepteurs RF433 des sites chinois avec l’Arduino , et j’avais été enthousiasmé par la facilité de cloner les télécommandes bon marché eu utilisant la libraire RC-Switch…

par exemple :
http://anothermaker.xyz/iot/domotique-arduino-nano-raspberry-pi-partie1-rf433mhz-4995

Mais j’ai été très vite déçu, en effet de nombreuses télécommandes n’étaient pas identifiées pas ce moyen…( j’apprends ce jour que cette bibliothèque à évolué avec 29 protocoles supplémentaires…., dont les DiO…, super…on continue quand même)

J’ai donc entrepris de me passer de cette Library pourtant excellente…
Pour cela j’ai revu le sniffer433 en utilisant la numérisation rapide….

#define DATA A0
#define NbEchantillons 1250

// Defines for setting A2D register bits
#define a2dBitClr(bit) (_SFR_BYTE(ADCSRA) &= ~_BV(bit))
#define a2dBitSet(bit) (_SFR_BYTE(ADCSRA) |= _BV(bit))

const int maxCompteur = NbEchantillons; //500 pour le grapheur....
byte code[NbEchantillons];
volatile int compteur = 0;
const byte ledPin = 13;
byte action = 1, nbemission = 0;
unsigned long debut = 0, fin = 0;

// Set A2D register clock division factor, enabling faster sampling
void a2dSetup(int factor){ //de 2 à 7....4 environ 16µs, 5 environ 30µs, 6 environ 60 µs, 7-->110µs (par mesure....){
if (factor & 1) a2dBitSet(ADPS0);
else a2dBitClr(ADPS0);
if (factor & 2) a2dBitSet(ADPS1);
else a2dBitClr(ADPS1);
if (factor & 4) a2dBitSet(ADPS2);
else a2dBitClr(ADPS2);
}
void setup() {
  Serial.begin(256000);
  pinMode(DATA, INPUT);
  digitalWrite(ledPin, LOW);
  a2dSetup(4); //de 2 à 7....4 environ 16µs, 5 environ 30µs, 6 environ 57 µs, 7-->110µs (par mesure....)
}

void loop() {
  compteur = 0;
  debut = micros();
  while (compteur < maxCompteur) code[compteur++] = analogRead(DATA);
  fin = micros();
  digitalWrite(ledPin, HIGH);
  for (int i = 0; i < maxCompteur; i++) {
    Serial.print(code[i]);
    Serial.print(",");
  }
  Serial.print("Fin-duree:" + String(fin - debut) + ",");
  digitalWrite(ledPin, LOW);
  while ((!digitalRead(6)) and (!digitalRead(8)));
  delay(20);
}

#define DATA A0

#define NbEchantillons 1250

// Defines for setting A2D register bits

#define a2dBitClr(bit) (_SFR_BYTE(ADCSRA) &= ~_BV(bit))

#define a2dBitSet(bit) (_SFR_BYTE(ADCSRA) |= _BV(bit))

const int maxCompteur = NbEchantillons; //500 pour le grapheur....

byte code[NbEchantillons];

volatile int compteur = 0;

const byte ledPin = 13;

byte action = 1, nbemission = 0;

unsigned long debut = 0, fin = 0;

// Set A2D register clock division factor, enabling faster sampling

void a2dSetup(int factor){ //de 2 à 7....4 environ 16µs, 5 environ 30µs, 6 environ 60 µs, 7-->110µs (par mesure....){

if (factor & 1) a2dBitSet(ADPS0);

else a2dBitClr(ADPS0);

if (factor & 2) a2dBitSet(ADPS1);

else a2dBitClr(ADPS1);

if (factor & 4) a2dBitSet(ADPS2);

else a2dBitClr(ADPS2);

}

void setup() {

Serial.begin(256000);

pinMode(DATA, INPUT);

digitalWrite(ledPin, LOW);

a2dSetup(4); //de 2 à 7....4 environ 16µs, 5 environ 30µs, 6 environ 57 µs, 7-->110µs (par mesure....)

}

void loop() {

compteur = 0;

debut = micros();

while (compteur < maxCompteur) code[compteur++] = analogRead(DATA);

fin = micros();

digitalWrite(ledPin, HIGH);

for (int i = 0; i < maxCompteur; i++) {

Serial.print(code[i]);

Serial.print(",");

}

Serial.print("Fin-duree:" + String(fin - debut) + ",");

digitalWrite(ledPin, LOW);

while ((!digitalRead(6)) and (!digitalRead(8)));

delay(20);

}

il envoie les données capturées à un moniteur graphique écrit avec Delphi, celui de l’arduino étant limité à 500 données…

Pour le bouton on d’une télécommande, le signal est le suivant:

On y voit des barres fines et des barres plus épaisses séparées par des blancs, on suggère rapidement des 0 et des 1, soit « 0001010100010101010101110 »
En fait la dernière barre fine est le début du signal….suivi d’un grand blanc ce qui constitue l’entête de synchronisation

On peut obtenir davantage de détails en jouant sue le paramètre ‘factor’ de la procédure a2dSetup (configuration du convertisseur analogique numérique) avec un paramètre à 4 on obtient une donnée toutes les 16 µs…(environ…)

Le moniteur graphique permet de mesurer les périodes…

Ici en moyenne une mesure toutes les 9,54µs (factor mis à 3), 8 périodes (bits) 1086 mesures soit un bit 9,54*1086/8=1295 µs et donc un pulse (état H ou b) à 323,75 µs

L’analyse complète donne:
1-Entete de 32 ‘pulses’: Hbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
2-Bit 0: 4 pulses Hbbb
3-Bit 1: 4 pulses HHHb
4-durée d’un état (pulse): 323 µs

On peut ainsi simuler la télécommande physique par un programme:

Telecommande On/Off

///Telecommande bureau.

const byte ledPin = 13;
const String btnMarche = "000101010001010101010111";
const String btnArret = "000101010001010101010100";

#define dureePulse 350 //325 marche aussi....

unsigned long debut;

void EnvoyerBit(int H, int L) {//entete:1-31, 0:1-3, 1:3-1
debut = micros();
digitalWrite (10, HIGH);
while ((micros() - debut) < (dureePulse * H));
digitalWrite(10, LOW);
while ((micros() - debut) < ( dureePulse * (L + H)));
}

void EnvoyerCode(String btn) {
for (int j = 1; j < 10; j++) {
EnvoyerBit(1, 31);// Synchro 1-31: 1 pulse H, 31 pulse L
for (int i = 0; i < btn.length(); i++) {
if (btn[i] == '1') EnvoyerBit(3, 1);//Envoyer 1: 3 pulse H, 1 pulse L
else EnvoyerBit( 1, 3); //Envoyer 0: 1 pulse H, 3 pulse L
} } }

void setup() {
pinMode (10, OUTPUT);
pinMode(ledPin, OUTPUT);
delay(500);
}

void loop() {
digitalWrite(ledPin, HIGH);
EnvoyerCode(btnMarche);
delay(5000);
digitalWrite(ledPin, LOW);
EnvoyerCode(btnArret);
delay(5000);
}

///Telecommande bureau.

const byte ledPin = 13;

const String btnMarche = "000101010001010101010111";

const String btnArret = "000101010001010101010100";

#define dureePulse 350 //325 marche aussi....

unsigned long debut;

void EnvoyerBit(int H, int L) {//entete:1-31, 0:1-3, 1:3-1

debut = micros();

digitalWrite (10, HIGH);

while ((micros() - debut) < (dureePulse * H));

digitalWrite(10, LOW);

while ((micros() - debut) < ( dureePulse * (L + H)));

}

void EnvoyerCode(String btn) {

for (int j = 1; j < 10; j++) {

EnvoyerBit(1, 31);// Synchro 1-31: 1 pulse H, 31 pulse L

for (int i = 0; i < btn.length(); i++) {

if (btn[i] == '1') EnvoyerBit(3, 1);//Envoyer 1: 3 pulse H, 1 pulse L

else EnvoyerBit( 1, 3); //Envoyer 0: 1 pulse H, 3 pulse L

} } }

void setup() {

pinMode (10, OUTPUT);

pinMode(ledPin, OUTPUT);

delay(500);

}

void loop() {

digitalWrite(ledPin, HIGH);

EnvoyerCode(btnMarche);

delay(5000);

digitalWrite(ledPin, LOW);

EnvoyerCode(btnArret);

delay(5000);

}

PS: pour les télécommande DiO, une solution est ici:
http://charleslabs.fr/fr/project-Contrôle+de+prises+DiO+avec+Arduino
marche très bien
Finalement j’utilise RC-Switch avec tous ses protocoles….

Sniffer433-1 Télécharger

Version Simplifiée avec esp32

les timers de l’esp32 permettent une version plus claire

//**************** sniffer avec timers esp32 *********************
hw_timer_t * timerMesures = NULL;
hw_timer_t * timerLed = NULL;

int led = 2;
int touche = 17;
int RX433 = 33;

volatile byte state = LOW;
#define nbmesures 4000
volatile int mesures[nbmesures];
volatile int i = 0;
boolean debug = true;
portMUX_TYPE timerMux = portMUX_INITIALIZER_UNLOCKED;
long debut;
int interMesures = 52;

void IRAM_ATTR onTimerMesures() {
  portENTER_CRITICAL_ISR(&amp;timerMux);
  mesures[i] = digitalRead(RX433);
  i++;
  if (i &gt; nbmesures) {
    i = 0;
    timerAlarmDisable(timerMesures);
  }
  portEXIT_CRITICAL_ISR(&amp;timerMux);
}

void IRAM_ATTR onTimerLed() {
  state = !state;
  digitalWrite(led, state);
}

void setup() {
  Serial.begin(115200);

  pinMode(led, OUTPUT);
  pinMode(touche, INPUT);
  pinMode(RX433, INPUT);

  /* Use 1 &amp; 2 timers of 4 */
  /* 1 tick take 1/(80MHZ/80) = 1us so we set divider 80 and count up */
  timerMesures = timerBegin(0, 80, true);
  timerLed = timerBegin(1, 80, true);

  /* Attach onTimer function to our timer */
  timerAttachInterrupt(timerMesures, &amp;onTimerMesures, true);
  timerAttachInterrupt(timerLed, &amp;onTimerLed, true);
  /* Set alarm to call onTimer function every second 1 tick is 1us
    =&gt; 1 second is 1000000us */
  /* Repeat the alarm (third parameter) */
  timerAlarmWrite(timerMesures, interMesures, true);//une mesure toutes les interMesure µs
  timerAlarmWrite(timerLed, 1000000, true);
  /* Start an alarm */
  timerAlarmEnable(timerMesures);
  timerAlarmEnable(timerLed);
  if (debug) Serial.println("start timer");
}

void loop() {
  if (i &gt;= nbmesures) {
    Serial.print("Durée des mesures: " + String(millis() - debut));
    Serial.println(" attendu :" + String(nbmesures * interMesures / 1000));
    if (debug) Serial.println();
    int cas = 2;
    int nbcas = 1;
    cas = mesures[0];
    if (debug) Serial.println("**************** les mesures avec comptage ***********************************");
    for (int j = 1; j &lt; nbmesures; j++) {
      if (mesures[j] == cas) {
        nbcas++;
      }
      else {
        if (debug) Serial.println(" (" + String(cas) + ":" + String(nbcas) + ") ");
        cas = mesures[j];
        nbcas = 1;
      }
      Serial.print(mesures[j]);
      if ((nbcas % 100) == 0) Serial.println();
    }
    if (debug) Serial.println(" (" + String(cas) + ":" + String(nbcas) + ") ");
    // fin des mesures ********************************************
    // for (int u = 0; u &lt; nbmesures; u++) mesures[u] = 0;
    if (debug) Serial.println("Touche en attente... ");//pour lancer une nouvelle série de mesures
    while (digitalRead(touche) == HIGH) {
      delay(100);
    }
    if (debug) Serial.println();
    i = 0;
    debut = millis();
    timerAlarmEnable(timerMesures);
  }
}

//**************** sniffer avec timers esp32 *********************

hw_timer_t * timerMesures = NULL;

hw_timer_t * timerLed = NULL;

int led = 2;

int touche = 17;

int RX433 = 33;

volatile byte state = LOW;

#define nbmesures 4000

volatile int mesures[nbmesures];

volatile int i = 0;

boolean debug = true;

portMUX_TYPE timerMux = portMUX_INITIALIZER_UNLOCKED;

long debut;

int interMesures = 52;

void IRAM_ATTR onTimerMesures() {

portENTER_CRITICAL_ISR(&timerMux);

mesures[i] = digitalRead(RX433);

i++;

if (i > nbmesures) {

i = 0;

timerAlarmDisable(timerMesures);

}

portEXIT_CRITICAL_ISR(&timerMux);

}

void IRAM_ATTR onTimerLed() {

state = !state;

digitalWrite(led, state);

}

void setup() {

Serial.begin(115200);

pinMode(led, OUTPUT);

pinMode(touche, INPUT);

pinMode(RX433, INPUT);

/* Use 1 & 2 timers of 4 */

/* 1 tick take 1/(80MHZ/80) = 1us so we set divider 80 and count up */

timerMesures = timerBegin(0, 80, true);

timerLed = timerBegin(1, 80, true);

/* Attach onTimer function to our timer */

timerAttachInterrupt(timerMesures, &onTimerMesures, true);

timerAttachInterrupt(timerLed, &onTimerLed, true);

/* Set alarm to call onTimer function every second 1 tick is 1us

=> 1 second is 1000000us */

/* Repeat the alarm (third parameter) */

timerAlarmWrite(timerMesures, interMesures, true);//une mesure toutes les interMesure µs

timerAlarmWrite(timerLed, 1000000, true);

/* Start an alarm */

timerAlarmEnable(timerMesures);

timerAlarmEnable(timerLed);

if (debug) Serial.println("start timer");

}

void loop() {

if (i >= nbmesures) {

Serial.print("Durée des mesures: " + String(millis() - debut));

Serial.println(" attendu :" + String(nbmesures * interMesures / 1000));

if (debug) Serial.println();

int cas = 2;

int nbcas = 1;

cas = mesures[0];

if (debug) Serial.println("**************** les mesures avec comptage ***********************************");

for (int j = 1; j < nbmesures; j++) {

if (mesures[j] == cas) {

nbcas++;

}

else {

if (debug) Serial.println(" (" + String(cas) + ":" + String(nbcas) + ") ");

cas = mesures[j];

nbcas = 1;

}

Serial.print(mesures[j]);

if ((nbcas % 100) == 0) Serial.println();

}

if (debug) Serial.println(" (" + String(cas) + ":" + String(nbcas) + ") ");

// fin des mesures ********************************************

// for (int u = 0; u < nbmesures; u++) mesures[u] = 0;

if (debug) Serial.println("Touche en attente... ");//pour lancer une nouvelle série de mesures

while (digitalRead(touche) == HIGH) {

delay(100);

}

if (debug) Serial.println();

i = 0;

debut = millis();

timerAlarmEnable(timerMesures);

}

resultat sans signal

Durée des mesures: 208 attendu :208

**************** les mesures avec comptage ***********************************
(0:1)
11 (1:2)
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 (0:3997)
Touche en attente…

résultats avec signal (après élimination des données superflues ou redontantes…)

Durée des mesures: 208 attendu :208

**************** les mesures avec comptage ***********************************

111 (1:3)
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 (0:197)
111111 (1:6)
00000000000000000000 (0:20)
111111 (1:6)
0000000000000000000 (0:19)
111111 (1:6)
00000000000000000000 (0:20)
111111111111111111 (1:18)
00000000 (0:8)
11111 (1:5)
00000000000000000000 (0:20)
111111111111111111 (1:18)
000000000 (0:9)
1111 (1:4)
000000000000000000000 (0:21)
111111111111111111 (1:18)
000000000 (0:9)
1111 (1:4)
00000000000000000000 (0:20)
111111111111111111 (1:18)
000000000 (0:9)
1111 (1:4)
000000000000000000000 (0:21)
111111111111111111 (1:18)
000000000 (0:9)
1111 (1:4)
00000000000000000000 (0:20)
11111 (1:5)
000000000000000000000 (0:21)
11111 (1:5)
00000000000000000000 (0:20)
111111111111111111 (1:18)
000000000 (0:9)
1111 (1:4)
000000000000000000000 (0:21)
111111111111111111 (1:18)
000000000 (0:9)
1111 (1:4)
00000000000000000000 (0:20)
111111111111111111 (1:18)
000000000 (0:9)
1111 (1:4)
000000000000000000000 (0:21)
111111111111111111 (1:18)
000000000 (0:9)
11111111111111111 (1:17)
000000000 (0:9)
11111111111111111 (1:17)
000000000 (0:9)
1111 (1:4)
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 (0:197)

entre deux blocs de 197 O, on voit apparaitre une alternance de 0 et 1:

-un 1 :
111111111111111111 (1:18)
00000000 (0:8)

-un 0:
11111 (1:5)
00000000000000000000 (0:20)

On retrouve le codage sur 4 états HHHb pour un 1 et Hbbb pour un 0, la durée de chaque état étant de 5 à 8 intervalles de mesures de 52 µs soit 260-416 µs soit en moyenne 338 µs ( entre 25*52/4 et 27*52/4)

En comptant les nombres d’échantillons de chaque état, on on obtient la signature du signal, par exemple:

11111111111111111111111111 (1:26)
00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 (0:1019)
111111111111111111111111111111111 (1:33)
000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 (0:99)
11111111111111111111111111111111 (1:32)
000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 (0:99)
11111111111111111111111111111111 (1:32)
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 (0:100)
11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 (1:98)
0000000000000000000000000000000000000 (0:37)
111111111111111111111111111111 (1:30)
000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 (0:102)
11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 (1:98)
0000000000000000000000000000000000000 (0:37)
111111111111111111111111111111 (1:30)
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 (0:103)
1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 (1:97)
00000000000000000000000000000000000000 (0:38)
11111111111111111111111111111 (1:29)
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 (0:103)
1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 (1:97)
000000000000000000000000000000000000000 (0:39)
11111111111111111111111111111 (1:29)
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 (0:103)
11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 (1:98)
000000000000000000000000000000000000000 (0:39)
1111111111111111111111111111 (1:28)
00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 (0:104)
111111111111111111111111111111 (1:30)
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 (0:103)
11111111111111111111111111111 (1:29)
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 (0:103)
1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 (1:97)
000000000000000000000000000000000000000 (0:39)
11111111111111111111111111111 (1:29)
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 (0:103)
1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 (1:97)
0000000000000000000000000000000000000000 (0:40)
1111111111111111111111111111 (1:28)
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 (0:103)
11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 (1:98)
000000000000000000000000000000000000000 (0:39)
1111111111111111111111111111 (1:28)
00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 (0:104)
1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 (1:97)
000000000000000000000000000000000000000 (0:39)
111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 (1:96)
0000000000000000000000000000000000000000 (0:40)
111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 (1:96)
000000000000000000000000000000000000000 (0:39)
1111111111111111111111111111 (1:28)
00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 (0:1019)
26,1019,33,99,32,99,32,100,98,37,30,102,98,37,30,103,97,38,29,103,97,39,29,103,98,39,28,104,30,103,29,103,97,39,29,103,97,40,28,103,98,39,28,104,97,39,96,40,96,39,28,1019,

Cette dernière ligne sera donnée au player avec la durée entre deux échantillons, par exemple

int veilleuseOff[] = {236, 28, 124, 28, 124, 104, 48, 28, 124, 104, 48, 28,<br />124, 104, 48, 28, 124, 28, 124, 28,124, 104, 47, 29, 123, 105, 46, 30, 122,<br />107, 45, 31, 121, 30, 121, 107, 46, 106, 46,106, 46, 106, 46, 106, 47, 29,<br />122, 30, 123, 30};<br /><br />void  player() {<br />int imax = 50;//nombre de données<br />for (int v = 0; v &lt; 5; v++) {<br />      boolean niveau = LOW;<br />      for (int i = 0; i &lt; imax; i++) {<br />           digitalWrite(rfTransmitPin, niveau);<br />          delayMicroseconds(veilleuseOff[i] * 10);//10 durée entre 2 échantillons<br />          niveau = !niveau;<br />       }<br /> }<br /> }<br /><br />.

int veilleuseOff[] = {236, 28, 124, 28, 124, 104, 48, 28, 124, 104, 48, 28, 124, 104, 48, 28, 124, 28, 124, 28,124, 104, 47, 29, 123, 105, 46, 30, 122, 107, 45, 31, 121, 30, 121, 107, 46, 106, 46,106, 46, 106, 46, 106, 47, 29, 122, 30, 123, 30}; void player() { int imax = 50;//nombre de données for (int v = 0; v < 5; v++) { boolean niveau = LOW; for (int i = 0; i < imax; i++) { digitalWrite(rfTransmitPin, niveau); delayMicroseconds(veilleuseOff[i] * 10);//10 durée entre 2 échantillons niveau = !niveau; } } } .

Publié dans Non classé | Laisser un commentaire

ESP8266 Arduino Killer

Publié le 6 août 2016 par daniel

Très attendue cette commande est enfin arrivée avec les esp8266 et surtout sa mise en œuvre Wemos:

et depuis j’utilise beaucoup moins mes arduinos….
La station météo ressemble désormais à ça :

C’est quand même plus simple….plus besoin d’Android et ses liaisons BlueTooth et Wifi, l’esp transmettant directement les données sur mon site

le code:

#include <ESP8266WiFi.h>
#include <Wire.h>                                                       // required by BME280 library
#include <BME280_t.h>
#include <ESP8266HTTPClient.h>

#define ASCII_ESC 27
#define MYALTITUDE  150.50

char bufout[10];

BME280<> BMESensor;

const char* ssid = "XXXXXXXX";
const char* password = "XXXXXXXXX";
long previousMillis = 0;
unsigned long currentMillis = 0;
long interval = 300000; // READING INTERVAL

String data;
//EthernetClient Eclient;
WiFiServer server(80);

void setup() {
  Serial.begin(115200);
  Wire.begin(0, 2);                                                     // initialize I2C that connects to sensor
  BMESensor.begin();
  delay(10);

  // Connect to WiFi network
  Serial.println();
  Serial.println();
  Serial.print("Connecting to ");
  Serial.println(ssid);

  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.println("WiFi connected");

  // Start the server
  server.begin();
  Serial.println("Server started");

  // Print the IP address
  Serial.print("Use this URL to connect: ");
  Serial.print("http://");
  Serial.print(WiFi.localIP());
  Serial.println("/");

}

void loop() {
  BMESensor.refresh();                                                  // read current sensor data
  sprintf(bufout, "%c[1;0H", ASCII_ESC);
  Serial.print(bufout);
  //Serial.write(27);       // ESC command
  //Serial.print("[2J");    // clear screen command
  //Serial.write(27);
  //Serial.print("[H");
  Serial.print("Temperature: ");
  Serial.print(BMESensor.temperature);                                  // display temperature in Celsius
  Serial.println("C");

  Serial.print("Humidity:    ");
  Serial.print(BMESensor.humidity);                                     // display humidity in %
  Serial.println("%");

  Serial.print("Pressure:    ");
  Serial.print(BMESensor.pressure  / 100.0F);                           // display pressure in hPa
  Serial.println("hPa");

  float relativepressure = BMESensor.seaLevelForAltitude(MYALTITUDE);
  Serial.print("RelPress:    ");
  Serial.print(relativepressure  / 100.0F);                             // display relative pressure in hPa for given altitude
  Serial.println("hPa");

  Serial.print("Altitude:    ");
  Serial.print(BMESensor.pressureToAltitude(relativepressure));         // display altitude in m for given pressure
  Serial.println("m");

  delay(5000);
  //***************************************************************
  currentMillis = millis();
  if (currentMillis - previousMillis > interval) { // READ ONLY ONCE PER INTERVAL
    previousMillis = currentMillis;
    String t =  String(BMESensor.temperature, 2);
    String h =  String(BMESensor.humidity, 2);
    String p =  String( BMESensor.pressure);

    data = "?temp1=" + t + "&hum1=" + h + "&pres1=" + p;
    HTTPClient http;

    Serial.print("[HTTP] begin...\n");

    http.begin("http://www.xxxxxxxxxxxxxxxxxx.php"+data); //HTTP

    Serial.print("[HTTP] GET...\n");
    Serial.print("http://www.xxxxxxxxxxxxxxx.php");Serial.print(data);Serial.print("\n");
    // start connection and send HTTP header
    int httpCode = http.GET();

    // httpCode will be negative on error
    if (httpCode > 0) {
      // HTTP header has been send and Server response header has been handled
      Serial.printf("[HTTP] GET... code: %d\n", httpCode);

      // file found at server
      if (httpCode == HTTP_CODE_OK) {
        String payload = http.getString();
        Serial.println(payload);
      }
    } else {
      Serial.printf("[HTTP] GET... failed, error: %s\n", http.errorToString(httpCode).c_str());
    }

    http.end();
  }

  // Check if a client has connected
  WiFiClient client = server.available();
  if (!client) {
    return;
  }

  // Wait until the client sends some data
  Serial.println("new client");
  while (!client.available()) {
    delay(1);
  }

  // Return the response
  client.println("HTTP/1.1 200 OK");
  client.println("Content-Type: text/html");
  client.println(""); //  do not forget this one
  client.println("<!DOCTYPE HTML>");
  client.println("<html>");
  client.println("<head><META HTTP-EQUIV=\"refresh\" CONTENT=\"10\"></head><body>");
  client.println("Mesures du <SCRIPT LANGUAGE=\"JavaScript\"> var maintenant=new Date();document.write(maintenant);</SCRIPT>: <br>");

  client.println("Temp&eacute;rature:");
  client.println(BMESensor.temperature);
  client.println("&deg;C<br>");

  client.println("Humidit&eacute;:   ");
  client.println(BMESensor.humidity);                                     // display humidity in %
  client.println("%<br>");

  client.println("Pression:   ");
  client.println(BMESensor.pressure  / 100.0F);                           // display pressure in hPa
  client.println("hPa");

  client.println("</body></html>");

  delay(1);
  Serial.println("Client disonnected");
  Serial.println("");

}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

#include <ESP8266WiFi.h>

#include <Wire.h> // required by BME280 library

#include <BME280_t.h>

#include <ESP8266HTTPClient.h>

#define ASCII_ESC 27

#define MYALTITUDE 150.50

char bufout[10];

BME280<> BMESensor;

const char* ssid = "XXXXXXXX";

const char* password = "XXXXXXXXX";

long previousMillis = 0;

unsigned long currentMillis = 0;

long interval = 300000; // READING INTERVAL

String data;

//EthernetClient Eclient;

WiFiServer server(80);

void setup() {

Serial.begin(115200);

Wire.begin(0, 2); // initialize I2C that connects to sensor

BMESensor.begin();

delay(10);

// Connect to WiFi network

Serial.println();

Serial.print("Connecting to ");

Serial.println(ssid);

WiFi.begin(ssid, password);

while (WiFi.status() != WL_CONNECTED) {

delay(500);

Serial.print(".");

}

Serial.println("");

Serial.println("WiFi connected");

// Start the server

server.begin();

Serial.println("Server started");

// Print the IP address

Serial.print("Use this URL to connect: ");

Serial.print("http://");

Serial.print(WiFi.localIP());

Serial.println("/");

}

void loop() {

BMESensor.refresh(); // read current sensor data

sprintf(bufout, "%c[1;0H", ASCII_ESC);

Serial.print(bufout);

//Serial.write(27); // ESC command

//Serial.print("[2J"); // clear screen command

//Serial.write(27);

//Serial.print("[H");

Serial.print("Temperature: ");

Serial.print(BMESensor.temperature); // display temperature in Celsius

Serial.println("C");

Serial.print("Humidity: ");

Serial.print(BMESensor.humidity); // display humidity in %

Serial.println("%");

Serial.print("Pressure: ");

Serial.print(BMESensor.pressure / 100.0F); // display pressure in hPa

Serial.println("hPa");

float relativepressure = BMESensor.seaLevelForAltitude(MYALTITUDE);

Serial.print("RelPress: ");

Serial.print(relativepressure / 100.0F); // display relative pressure in hPa for given altitude

Serial.println("hPa");

Serial.print("Altitude: ");

Serial.print(BMESensor.pressureToAltitude(relativepressure)); // display altitude in m for given pressure

Serial.println("m");

delay(5000);

//***************************************************************

currentMillis = millis();

if (currentMillis - previousMillis > interval) { // READ ONLY ONCE PER INTERVAL

previousMillis = currentMillis;

String t = String(BMESensor.temperature, 2);

String h = String(BMESensor.humidity, 2);

String p = String( BMESensor.pressure);

data = "?temp1=" + t + "&hum1=" + h + "&pres1=" + p;

HTTPClient http;

Serial.print("[HTTP] begin...\n");

http.begin("http://www.xxxxxxxxxxxxxxxxxx.php"+data); //HTTP

Serial.print("[HTTP] GET...\n");

Serial.print("http://www.xxxxxxxxxxxxxxx.php");Serial.print(data);Serial.print("\n");

// start connection and send HTTP header

int httpCode = http.GET();

// httpCode will be negative on error

if (httpCode > 0) {

// HTTP header has been send and Server response header has been handled

Serial.printf("[HTTP] GET... code: %d\n", httpCode);

// file found at server

if (httpCode == HTTP_CODE_OK) {

String payload = http.getString();

Serial.println(payload);

}

} else {

Serial.printf("[HTTP] GET... failed, error: %s\n", http.errorToString(httpCode).c_str());

}

http.end();

}

// Check if a client has connected

WiFiClient client = server.available();

if (!client) {

return;

}

// Wait until the client sends some data

Serial.println("new client");

while (!client.available()) {

delay(1);

}

// Return the response

client.println("HTTP/1.1 200 OK");

client.println("Content-Type: text/html");

client.println(""); // do not forget this one

client.println("<!DOCTYPE HTML>");

client.println("<html>");

client.println("<head><META HTTP-EQUIV=\"refresh\" CONTENT=\"10\"></head><body>");

client.println("Mesures du <SCRIPT LANGUAGE=\"JavaScript\"> var maintenant=new Date();document.write(maintenant);</SCRIPT>: ");

client.println("Température:");

client.println(BMESensor.temperature);

client.println("°C ");

client.println("Humidité: ");

client.println(BMESensor.humidity); // display humidity in %

client.println("% ");

client.println("Pression: ");

client.println(BMESensor.pressure / 100.0F); // display pressure in hPa

client.println("hPa");

client.println("</body></html>");

delay(1);

Serial.println("Client disonnected");

Serial.println("");

}

les données sont stockées dans une base mysql par le script .php:

<?php
include ("connexion.php");

$temp1=$_GET["temp1"];
$hum1=$_GET["hum1"];
$pres1=$_GET["pres1"];

$query = "INSERT INTO meteo2(date, temperature, humidite, pression)
VALUES (CURRENT_TIMESTAMP,'$temp1','$hum1','$pres1')";

$result = mysqli_query($link, $query);

mysqli_close($link);

header("Location: index.php");
?>

<?php

include ("connexion.php");

$temp1=$_GET["temp1"];

$hum1=$_GET["hum1"];

$pres1=$_GET["pres1"];

$query = "INSERT INTO meteo2(date, temperature, humidite, pression)

VALUES (CURRENT_TIMESTAMP,'$temp1','$hum1','$pres1')";

$result = mysqli_query($link, $query);

mysqli_close($link);

header("Location: index.php");

les résultats ici: daniel974/meteo2/

Publié dans Non classé | Laisser un commentaire

Mini station météo

Publié le 6 juillet 2016 par daniel

Comme beaucoup qui jouent avec une Arduino, j’ai eu envie d’avoir ma station météo, température, pression, humidité
pas de pluviomètre ni d’anémomètre, ces capteurs étant un peu chers à mon gout…

Je voulais en outre publier les mesures sur ce site:
Mes mesures météo

La chaine est donc la suivante:

Capteurs–>Arduino–>…BT…–>Android–>…WIFI…–>MaBox–>..Internet…–>Monsite

On doit pouvoir faire plus simple…mais c’est intéressant!…

J’ai tout d’abord essayé le capteur LM35

Très facile à mettre en œuvre, et nombreux tutos par exemple
mais il ne fait que la température, j’ai finalement opté pour un DS18B20 et un BMP085 avant de passer au BME280 en commande…

Restait à publier….
Ma solution a été de relier l’Arduino à un viel Android en BlueTooth(je ne suis pas sur que mon Samsung Galaxy S apprécie…) Celui-ci envoie en WIFI les mesures sur mon site via ma box !… l’Arduino devra en plus gérer la charge de l’Android, de façon à ce qu’on puisse laisser cet ensemble dans un coin et ne plus s’en occuper…

L’application Android est fortement inspirée de:
1- BlueTooth-spp-Terminal pour la liaison BlueTooth Arduino>->Android
2- Android UpLoad pour le transfert des données Android->MonSite
3- BatteryLevel pour la gestion de la charge de l’Android

Voici l’installation:
j’ai mis tout ça dans une porte fenêtre peu utilisée, on voit le boitier de l’Arduino, l’Android en liaison USB pour la charge et Bluetooth pour les mesures, l’alimentation et enfin le fil de la sonde DS18B20qui est placée à l’extérieur,
la capteur BMP035 étant dans le boitier Arduino. Vite un couvercle, ça fait peur…

Montage:A venir: codes….

J’ai depuis découvert l’ESP8266 et notamment cet article
Ça à l’air bien…j’ai donc commandé ce composant et ai hâte de le mettre en œuvre…

Publié dans Non classé | Laisser un commentaire

Oscilloscopes…

Publié le 16 mars 2016 par daniel

J’ai commandé un ds0 138

En attendant sa livraison, j’ai essayé d’imiter celui-la décrit sur http://projectproto.blogspot.com/2010/09/android-bluetooth-oscilloscope.html

Pour cela j’ai dépoussièré ma carte IOIO et modifié l’application IOIOSimpleApp, et j’ai obtenu ce truc … le signal est fourni par le moteur de ma plaque IOIO.
J’ai utilisé la même classe que le précédent pour l’affichage, mais l’échantillonnage de la carte IOIO est limité à 1 kSa/s, c’est peu…

Je me suis alors tourné vers les applis PC et essayé XOcillo et Scopino qui utilisent un arduino

Super les deux….

La manip complète….(GBF—>Echantillonneur—->Grapheur)
(70s GBF, Arduino, PC)

Publié dans Non classé | Laisser un commentaire

Blog Daniel974

Production photovoltaïque et surplus…

Mon Serveur Domoticz…

Solveur de Rubik’s cube

Traceurs 2D

Traceurs 2D

F-Engrave

Pluviomètre WH0531 (à finir…)

Pluviomètre 1

Sniffer RF433 MHz et télécommandes 433MHz (à finir…)

Telecommande On/Off

Version Simplifiée avec esp32

resultat sans signal

résultats avec signal (après élimination des données superflues ou redontantes…)

ESP8266 Arduino Killer

Mini station météo

Oscilloscopes…

Articles récents

Commentaires récents

Archives

Catégories

Méta