Tous les capteurs reliés au RPI par Wifi avec module ESP8266

[Jean-Marie]

Hello Veloce

C'est intéressant et original

C'est pas vraiment original. Je pense que je suis plutôt en train de réinventer la roue. Mais ça m'intéresse effectivement.

Ton idée est peut-être bien excellente. Je connaissais de nom de l'horloge DS1307 mais pas la DS1337.
J'ai rapidement lu dans la datasheet que la DS1337 a "Two Time-of-Day Alarms". Cela veut-il dire que cette horloge est capable de déclencher un changement de pin logique toutes les 12h ? Pour une surveillance de l'humidité du sol, ce serait parfait. Pour surveiller la T° de la salle de bain, c'est peut-être un peu peu ! Sauf si on ne se lave pas souvent

Après tout, on n'est peut-être pas limité à une alarme toutes les 12h. En effet, cette horloge est programmable. Donc, pendant la période de réveil, le µC de service pourrait très bien remettre l'heure à zéro et fixer l'alarme x heures plus tard pour un déclenchement toutes les x heures.

Veloce, ton idée n'est pas excellente, elle est géniale !
Je vais un peu potasser la matière. Enfin, essentiellement après mon week-end prolongé.

Dernière info : on trouve ceci sur AliExpress:

17.jpg (87.17 Kio) Vu 7830 fois

87 centimes, c'est pas cher l'horloge.

[Veloce]

Veloce, ton idée n'est pas excellente, elle est géniale !

Oui, enfin si ça marche...

C'est effectivement la grande sœur de la DS1307, donc j'imagine qu'on peut s'inspirer des nombreux exemples de code qui existent, tant pour l'Arduino que pour le Raspberry Pi. Ce n'est pas directement compatible, mais avec le datasheet sous les yeux ça doit être modifiable facilement.

Les alarmes sont très flexibles, on peut les déclencher toutes les secondes, minutes, heures, ou lorsque les secondes ou minutes ou heures sont égales à une valeur programmée. Ou tous les jours à telle heure, minute, seconde, comme un réveil. Ou à une date précise, comme un calendrier.

Consommation 1,5 µA

Sûr que ça vaut le coup d'essayer, mais ils ne la vendent pas plutôt en boîtier DIP tes chinois ? Ce serait plus facile à utiliser.

Veloce

[Jean-Marie]

Hello Veloce,

Les alarmes sont très flexibles, on peut les déclencher toutes les secondes, minutes, heures, ou lorsque les secondes ou minutes ou heures sont égales à une valeur programmée. Ou tous les jours à telle heure, minute, seconde, comme un réveil. Ou à une date précise, comme un calendrier.

Consommation 1,5 µA

Je crois que c'est très souple et exactement ce qui convient.
On peut effectivement déclencher l'alarme à la fréquence qu'on veut. Il suffit de remettre l'horloge à zéro à chaque déclenchement.

La DS1337 est disponible en boîtier DIP mais c'est plus cher et un boîtier SOP8 est facilement transformable en DIP avec ces adaptateurs (0,78€ pour 10, envoi compris):

18.jpg (23.55 Kio) Vu 7816 fois

Le format DIP est pratique pour des essais sur une breadboard mais le format SOP8 permet de souder le chip directement sur la face cuivre d'un PCB homemade.

Bon weekend à tous et à mardi soir.

[Jean-Marie]

Hello les amis,

Voici un schéma de principe de ce qu'il faut réaliser pour un capteur autonome fonctionnant sur batterie et qui ne doit transmettre sa mesure que de temps en temps.

Gestion Alimentation Autonome 2.JPG (48.51 Kio) Vu 7794 fois

Le principe est simple. La batterie (Li-ion 3.7V de forte capacité) alimente non-stop une horloge temps réel DS1337 qui consomme extrêmement peu. Contrairement à la DS1307, la DS1337 possède 2 alarmes capables de faire basculer les pin IntA et IntB au niveau bas lorsque l'alarme est déclenchée.
L'une de ces pins est connectée au gate d'un transistor MOSFET dont le type est capable de fonctionner à basse tension (par exemple IRF7319). Cette action sur le gate rend le transistor passant, ce qui alimente à la fois le µContrôleur et l'ESP à travers la diode Shottky qui abaisse la tension de 0.4V.
Après avoir booté, le µC s'occupe en premier lieu du maintien du gate du transistor au niveau bas. Il récolte ensuite la mesure du capteur (non représenté sur le schéma) et lance les commandes à l'ESP pour que celui-ci transmette la mesure à l'unité centrale par wifi.
Le µC communique alors à l'horloge la nouvelle heure d'alarme.
Il ramène ensuite le gate du transistor au niveau haut, ce qui a pour effet de couper l'alimentation.

Il est possible qu'il faille encore modifier ce schéma car j'ignore pendant combien de temps la DS1337 maintien la pin d'interruption basse. Il faut en effet que cette pin reste basse le temps que le µC puisse booter et prendre le relais de la DS1337 pour maintenir l'alimentation.

Edit: j'ai corrigé 4 fois la même erreur ci-dessus. Je parlais de "drain" du transistor, alors qu'il s'agit du "gate".

[guillaume9344]

Bonsoir après un rapide coup d’œil au data sheet de l horloge , je pense que la pin d'interupt reste à l 'état bas temps que les bit 0 ou 1 du registre status ne sont pas mis à 0.
@+

[Jean-Marie]

Hello Guillaume9344

Tu as raison. Si une pin d'interrupt a été mise à zéro, c'est à l'utilisateur de remettre le bit A1F ou A2F du Status Register à zéro, ce qui relâche la pin d'interrupt.
C'est donc parfait et la connexion entre la pin 1 et la gate du transistor peut être supprimée.
Merci Guillaume pour cette précision.

[Manfraid]

petite question, peut-on brancher directement le DS1337 avec l'ESP, avec le firmware nodmcu on pourrais piloter le DS1337 directement depuis l'esp

[Jean-Marie]

Hello Manfraid

"Petite question" qui n'a l'air de rien mais qui fait remuer les neurones.

En principe, tout microcontrôleur qui se respecte sait parler I2C, puisque c'est le seul langage que la DS1337 comprend.

Sur le plan hardware, cela paraît possible à condition de disposer des pin GPIO2 et GPIO14.

J'ai rassemblé ci-dessous des infos qui proviennent de ce site, ainsi qu'une représentation du module ESP-12.

22.jpg (157.42 Kio) Vu 7757 fois

En haut à gauche, on voit la puce avec toutes ses pattes. Le tableau du bas donne une description détaillée de chaque pin. J'ai mis en vert les pins qui concernent la communication I2C : SCL correspond à GPIO14 et SDA correspond à GPIO2. Ces pin sont heureusement représentées sur le module ESP-12.

Il est donc théoriquement possible de mettre en oeuvre I2C, mais il faut connaître les registres qui contrôlent l'I2C et savoir programmer ces registres. SMBA38 serait beaucoup plus compétent que moi pour donner un avis sur cette question.

[Manfraid]

Merci pour tes recherches, je pense que cette solution me conviens très bien, dès que j'ai le temps j'achète ce qu'il me faut et je test cela

[smba38]

Bonjour,

Lua dispose de modules I2C.

Code : Tout sélectionner

i2c.setup
i2c.start
i2c.stop
i2c.address
i2c.write
i2c.read

Je n'ai pas testé ces modules, on trouve des exemples sur Internet.

Voici un exemple livré avec nodemcu pour piloter un capteur de pression / température bmp085
Datasheet bmp085

https://www.google.fr/url?sa=t&rct=j&q= ... 2LaVXrtcPQ

Exemple de code pour piloter en Lua le BMP085

Code : Tout sélectionner

------------------------------------------------------------------------------
-- BMP085 query module
--
-- LICENCE: http://opensource.org/licenses/MIT
-- Vladimir Dronnikov <dronnikov@gmail.com>
-- Heavily based on work of Christee <Christee@nodemcu.com>
--
-- Example:
-- require("bmp085").read(sda, scl)
------------------------------------------------------------------------------
local M
do
  -- cache
  local i2c, tmr = i2c, tmr
  -- helpers
  local r8 = function(reg)
    i2c.start(0)
    i2c.address(0, 0x77, i2c.TRANSMITTER)
    i2c.write(0, reg)
    i2c.stop(0)
    i2c.start(0)
    i2c.address(0, 0x77, i2c.RECEIVER)
    local r = i2c.read(0, 1)
    i2c.stop(0)
    return r:byte(1)
  end
  local w8 = function(reg, val)
    i2c.start(0)
    i2c.address(0, 0x77, i2c.TRANSMITTER)
    i2c.write(0, reg)
    i2c.write(0, val)
    i2c.stop(0)
  end
  local r16u = function(reg)
    return r8(reg) * 256 + r8(reg + 1)
  end
  local r16 = function(reg)
    local r = r16u(reg)
    if r > 32767 then r = r - 65536 end
    return r
  end
  -- calibration data
  local AC1, AC2, AC3, AC4, AC5, AC6, B1, B2, MB, MC, MD
  -- read
  local read = function(sda, scl, oss)
    i2c.setup(0, sda, scl, i2c.SLOW)
    -- cache calibration data
    if not AC1 then
      AC1 = r16(0xAA)
      AC2 = r16(0xAC)
      AC3 = r16(0xAE)
      AC4 = r16u(0xB0)
      AC5 = r16u(0xB2)
      AC6 = r16u(0xB4)
      B1  = r16(0xB6)
      B2  = r16(0xB8)
      MB  = r16(0xBA)
      MC  = r16(0xBC)
      MD  = r16(0xBE)
    end
    -- get raw P
    local p
    -- NB: optimize for oss = 0
    if not oss then oss = 0 end
    if oss == 0 then
      oss = 0
      w8(0xF4, 0x34)
      tmr.delay(5000)
      p = r8(0xF6) * 256 + r8(0xF7)
    else
      w8(0xF4, 0x34 + 64 * oss)
      tmr.delay(30000)
      p = r8(0xF6) * 65536 + r8(0xF7) * 256 + r8(0xF8)
      p = p / 2^(8 - oss)
    end
    -- get T
    w8(0xF4, 0x2E)
    tmr.delay(5000)
    local t = r16(0xF6)
    local X1 = (t - AC6) * AC5 / 32768
    local X2 = MC * 2048 / (X1 + MD)
    t = (X2 + X1 + 8) / 16
    -- normalize P
    local B5 = t * 16 - 8;
    local B6 = B5 - 4000
    local X1 = B2 * (B6 * B6 / 4096) / 2048
    local X2 = AC2 * B6 / 2048
    local X3 = X1 + X2
    local B3 = ((AC1 * 4 + X3) * 2^oss + 2) / 4
    X1 = AC3 * B6 / 8192
    X2 = (B1 * (B6 * B6 / 4096)) / 65536
    X3 = (X1 + X2 + 2) / 4
    local B4 = AC4 * (X3 + 32768) / 32768
    local B7 = (p - B3) * (50000 / 2^oss)
    p = B7 / B4 * 2
    X1 = (p / 256)^2
    X1 = (X1 * 3038) / 65536
    X2 = (-7357 * p) / 65536
    p = p + (X1 + X2 + 3791) / 16
    -- Celsius * 10, Hg mm * 10
    return t, p * 3 / 40
  end
  -- expose
  M = {
    read = read,
  }
end
return M

J'ai trouvé par exemple cette info sur Internet
http://www.esp8266-projects.com/2015/03 ... river.html

Pour piloter un circuit RTC I2C en Lua.

A+
SMBA38