Gen

GDW#22 Le retardateur d'allumage

Recommended Posts

Gen

Salut la room..

 

Je vous fait part d'un petit montage que l'on m'a demandé de faire.

Il s'agit d'un circuit dédié à 2 salles de culture, qui allumera successivement suivant un délais programmé les lampes les unes à la suite des autres,

ceci afin d'éviter un pic de tension sur le circuit électrique

les données sont paramétrable via un écran tactile 7" ou autre

une sonde thermique renseignera la température interne du boîtier

Entrée de signal indépendante et circuit protégé par opto-coupleurs

les données sont accessibles depuis la wifi locale ou ailleurs si une passerelle est configurée sur votre routeur

Capacité maximum 2x10 lampes, puissance de sortie en fonction des relais SSR utilisés

100% compatible avec le GENESYS

Dimension 100mm x 80mm

 

switch_view.thumb.png.d6ed905c5b82d1309be485c891dda45c.png

 

le synoptique

switch_sch.thumb.png.c1644c791cbbd9f669d71d54fba65d9d.png

 

 

++

GEN

 

Edited by Gen
  • Like 2

Share this post


Link to post
Share on other sites
Ke'One MJ

Salut Gen,

 

Pas mal cette idée de pouvoir allumer les lampes une par une :supair:

 

Tu as une idée du prix déjà ?

 

++

 

Kew

Edited by Ke'One MJ

Share this post


Link to post
Share on other sites
Gen

yop

 

MP

 

++

GEN

Share this post


Link to post
Share on other sites
Gen

yop

 

Voici le code source testé juste pour la partie électronique du circuit.

 

#include <Arduino.h>
#include "MCP23008.h"
#include "LAMP.h"

#define inputA 19
#define inputB 18

MCP23008 *mcp1     = new MCP23008;
MCP23008 *mcp2     = new MCP23008;
MCP23008 *mcp3     = new MCP23008;

LAMP     *LAMP_A1  = new LAMP(mcp1,7,10);
LAMP     *LAMP_A2  = new LAMP(mcp1,6,14);
LAMP     *LAMP_A3  = new LAMP(mcp1,5,18);
LAMP     *LAMP_A4  = new LAMP(mcp1,4,22);
LAMP     *LAMP_A5  = new LAMP(mcp1,3,26);
LAMP     *LAMP_A6  = new LAMP(mcp1,2,30);
LAMP     *LAMP_A7  = new LAMP(mcp1,1,34);
LAMP     *LAMP_A8  = new LAMP(mcp1,0,38);
LAMP     *LAMP_A9  = new LAMP(mcp2,7,42);
LAMP     *LAMP_A10 = new LAMP(mcp2,6,46);
LAMP     *LAMP_B1  = new LAMP(mcp2,5,50);
LAMP     *LAMP_B2  = new LAMP(mcp2,4,54);
LAMP     *LAMP_B3  = new LAMP(mcp2,3,58);
LAMP     *LAMP_B4  = new LAMP(mcp2,2,62);
LAMP     *LAMP_B5  = new LAMP(mcp2,1,66);
LAMP     *LAMP_B6  = new LAMP(mcp2,0,70);
LAMP     *LAMP_B7  = new LAMP(mcp3,7,74);
LAMP     *LAMP_B8  = new LAMP(mcp3,6,78);
LAMP     *LAMP_B9  = new LAMP(mcp3,5,82);
LAMP     *LAMP_B10 = new LAMP(mcp3,4,86);

LAMP *lamplistA[10] =
{LAMP_A1,LAMP_A2,LAMP_A3,LAMP_A4,LAMP_A5,LAMP_A6,LAMP_A7,LAMP_A8,LAMP_A9,LAMP_A10};
LAMP *lamplistB[10] =
{LAMP_B1,LAMP_B2,LAMP_B3,LAMP_B4,LAMP_B5,LAMP_B6,LAMP_B7,LAMP_B8,LAMP_B9,LAMP_B10};


bool previousStatusA = false;
bool previousStatusB = false;
int  sequenceDelay = 2;

/*********************************************************************************************
**********************************************************************************************
*****                                       CORE 1                                       *****
**********************************************************************************************
*********************************************************************************************/

void memWrite(int address, long value)
{
  byte four  = (value & 0xFF);
  byte three = ((value >> 8 ) & 0xFF);
  byte two   = ((value >> 16) & 0xFF);
  byte one   = ((value >> 24) & 0xFF);
  EEPROM.write(address, four);
  EEPROM.write(address + 1, three);
  EEPROM.write(address + 2, two);
  EEPROM.write(address + 3, one);
  EEPROM.commit();
}

long memRead(long address)
{
  long four  = EEPROM.read(address);
  long three = EEPROM.read(address + 1);
  long two   = EEPROM.read(address + 2);
  long one   = EEPROM.read(address + 3);
  return ((four << 0) & 0xFF) + ((three << 8 ) & 0xFFFF) +
       ((two << 16) & 0xFFFFFF) + ((one << 24) & 0xFFFFFFFF);
}


void setMcpPinMode(MCP23008 *mcp)
{
  for(int i = 0 ; i<=7 ; i++)
  {
    mcp->pinMode(i,OUTPUT);
    mcp->digitalWrite(i,LOW);
  }
}

void loadMemoryData()
{
  LAMP_A1->loadActivation();
  LAMP_A2->loadActivation();
  LAMP_A3->loadActivation();
  LAMP_A4->loadActivation();
  LAMP_A5->loadActivation();
  LAMP_A6->loadActivation();
  LAMP_A7->loadActivation();
  LAMP_A8->loadActivation();
  LAMP_A9->loadActivation();
  LAMP_A10->loadActivation();
  LAMP_B1->loadActivation();
  LAMP_B2->loadActivation();
  LAMP_B3->loadActivation();
  LAMP_B4->loadActivation();
  LAMP_B5->loadActivation();
  LAMP_B6->loadActivation();
  LAMP_B7->loadActivation();
  LAMP_B8->loadActivation();
  LAMP_B9->loadActivation();
  LAMP_B10->loadActivation();
//  sequenceDelay = memRead(100);
}

void setSequenceDelay(int value)
{
  sequenceDelay = value;
  memWrite(100,value);
}


void setup()
{
  Serial.begin(115200);
  pinMode(inputA,INPUT);
  pinMode(inputB,INPUT);
  mcp1->begin(0);    
  mcp2->begin(1);      
  mcp3->begin(2);      
  setMcpPinMode(mcp1);
  setMcpPinMode(mcp2);
  setMcpPinMode(mcp3);
  loadMemoryData();
}

void setLineLighting(bool value, LAMP *list[10])
{  
    for(int i = 0 ; i <= 9; i++)
  {
    if(value)
    {
      list[  i ]->setLightingON();
      delay(sequenceDelay*1000);
    }
    else
    {
      list[  i ]->setLigntinOFF();
    }
  }
}


void loop()
{
  bool statusA,statusB = false;
 
  statusA = digitalRead(inputA);
  statusB = digitalRead(inputB);
 
  if(statusA != previousStatusA)
  {
    setLineLighting(statusA,lamplistA);
    previousStatusA = statusA;
  }
 
  if(statusB != previousStatusB)
  {
    setLineLighting(statusB,lamplistB);
    previousStatusB = statusB;
  }
 
  delay(1000);
}

 

 

 

En gros je crée 3 pointeurs, chacun pointant sur un objet MCP

je crée 20 pointeurs sur les objets lamp (classe que j'ai créé afin d'éviter du code à répétition) ou je passe comme paramètre le MCP, l'I/O, et la position mémoire de où sera enregistré l'activation

Après cela je crée un tableau de pointeur que j'envoie à une procédure comme paramètres et je n'ai plus qu'à le parcourir pour allumer ou éteindre les lampes.

 

voila si ça peut intéresser quelqu'un..

++

GEN

Edited by Gen
  • Thanks 1

Share this post


Link to post
Share on other sites
for&ver

bonjour gen.

 

je suis intéressé. ce projet répond a une des questions que je me posais sur le GENESYS. a savoir comment ne pas allumer toutes les lampes en  même temps pour éviter ce fameux pic de tension. je ne savais pas si le GENESYS pourrait gérer cela.

 

peut tu nous en dire plus sur l'intégration avec le GENESYS stp ? :

- je suppose qu'il n'est plus nécessaire de monter les prises des lampes sur le boitier du GENESYS,

- peut on envisager de ne faire qu'un boitier combinant GENESYS et retardateur,

- comment relie t'on les 2 cartes (GENESYS/retardateur) [édition] surement en reliant la sortie timer 1 du GENESYS a IN A du retardateur

 

merci.

Edited by for&ver
je crois avoir trouvé la réponse a une question.

Share this post


Link to post
Share on other sites
Gen

Yop

 

Le GENESYS ne gère pas cela, c'est un autre circuit indépendant, il possède son propre processeur,

il attend le signal SSR du GENESYS et commence son cycle d'allumage..

 

pour les raccorder ensemble, on part du ssr de T1 ou T2 du GENESYS que l'on branche sur l'entrée dédié du circuit, rien de plus simple.

Il est dédié en 2 séries de 10 lampes au max, chaque série peut être commandée séparément.

Ce circuit est compatible avec n'importe quoi, il a juste besoin de recevoir du 3V3 pour s'enclencher

 

Oui tu peux monter le GENESYS et cette carte dans la même boîte

Voila le montage en cours, ça avance doucement car je taffe encore sur 2 proto à expédier.

 

DSC_0072.JPG.fdcc70afe03485e58218fcf5ad78779d.JPG

 

La carte est prévue pour éventuellement ajouter un écran tactile et du Wifi

 et pour répondre à ta question, tu montes alors les prises en partant de ce circuit via les SSR

 

++

GEN

 

 

 

 

Edited by Gen

Share this post


Link to post
Share on other sites