Alarme

README.md

@@ -0,0 +1,2 @@
+# BE_Board
+simple simulation of an arduino board

compile_mac.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+set -x
+g++ -Wall -Wextra -std=c++11 board.cpp core_simulation.cpp mydevices.cpp sketch_ino.cpp -o arduino

src/board.cpp

@@ -0,0 +1,59 @@
+#include "core_simulation.h"
+#include "mydevices.h"
+
+
+
+
+int main(){
+  // creation d'une board
+  Board esp8266;
+
+ 
+  // achat des senseurs et actionneurs
+  // AnalogSensorLuminosity luminosite(DELAY);
+  //AnalogSensorTemperature temperature(DELAY);
+  //DigitalActuatorLED led1(DELAY);
+  DigitalLED ledAlarme(DELAY,"LED/Alarm/on.txt","Alarme ");
+  //ExternalDigitalSensorButton bouton1(DELAY);
+  I2CActuatorScreen screen;
+  AnalogSensorMovement Capt1(DELAY);
+  AnalogSensorMovement Capt2(DELAY);
+  DigitalLED ledSonnerie(DELAY,"sonnerie.txt","Sonnerie");
+  DigitalLED ledModeMax(DELAY, "LED/Actif_Max/on.txt","Mode Max Alert");
+  DigitalLED ledModeIntelligent(DELAY,"LED/Actif_Intelligent/on.txt","Mode Intelligent");
+
+
+  //Configuration des Capteurs
+  Capt1.config();
+  Capt2.config();
+  
+ 
+
+ 
+ 
+
+ 
+  // branchement des capteurs actionneurs
+  esp8266.pin(0,ledAlarme);
+  esp8266.i2c(1,screen);
+  esp8266.pin(2,ledSonnerie);
+  esp8266.pin(3,ledModeMax);
+  esp8266.pin(4,ledModeIntelligent);
+  esp8266.pin(5,Capt1);
+  esp8266.pin(6,Capt2);
+  //esp8266.pin(1,temperature);
+  //esp8266.pin(2,luminosite);
+  //esp8266.pin(4,bouton1);
+  //esp8266.pin(5,Capt1);
+  //esp8266.pin(6,Alarme);
+  
+
+ 
+
+  // allumage de la carte
+  esp8266.run();
+  //detect.gestionIntrusion(&Capt1);
+  return 0;
+}
+
+

src/board.cpp~

@@ -0,0 +1,48 @@
+#include "core_simulation.h"
+#include "mydevices.h"
+
+
+
+
+int main(){
+  // creation d'une board
+  Board esp8266;
+
+ 
+  // achat des senseurs et actionneurs
+  // AnalogSensorLuminosity luminosite(DELAY);
+  //AnalogSensorTemperature temperature(DELAY);
+  //DigitalActuatorLED led1(DELAY);
+  IntelligentDigitalActuatorLED ledAlarme(DELAY);
+  //ExternalDigitalSensorButton bouton1(DELAY);
+  I2CActuatorScreen screen;
+  AnalogSensorMovement Capt1(DELAY);
+
+
+  //Configuration des Capteurs
+  Capt1.config();
+  
+ 
+
+ 
+ 
+
+ 
+  // branchement des capteurs actionneurs
+  esp8266.pin(0,ledAlarme);
+  //esp8266.pin(1,temperature);
+  //esp8266.pin(2,luminosite);
+  //esp8266.pin(4,bouton1);
+  //esp8266.pin(5,Capt1);
+  //esp8266.pin(6,Alarme);
+  esp8266.i2c(1,screen);
+
+ 
+
+  // allumage de la carte
+  esp8266.run();
+  //detect.gestionIntrusion(&Capt1);
+  return 0;
+}
+
+

src/compile_linux.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+set -x
+g++  -Wextra -std=c++11 -pthread board.cpp core_simulation.cpp mydevices.cpp sketch_ino.cpp  -o arduino

src/compile_linux.sh~

@@ -0,0 +1,3 @@
+#!/bin/bash
+set -x
+g++  -Wextra -std=c++11 -pthread board.cpp core_simulation.cpp mydevices.cpp sketch_ino.cpp detection.cpp -o arduino

src/core_simulation.cpp

@@ -0,0 +1,181 @@
+
+#include <thread>
+#include <unistd.h>
+#include <string.h>
+
+#include "core_simulation.h"
+
+// class BoardException
+int BoardException::get(){return num;}
+
+string BoardException::text(){
+  string s;
+  switch(num){
+  case SPEED : s=string("mauvaise vitesse de la laison terminal");break;
+  case INOUT : s=string("mauvaise utilisation du sens de l'entree/sortie"); break;
+  case ADDRESS : s=string("mauvaise adresse de la pin"); break;
+  case SIZEXC : s=string("taille erronee"); break;
+  case EMPTY: s=string("zone vide"); break;
+  default: s=string("erreur inconnue");
+  }
+  return s;
+}
+
+// classe terminale
+void Terminal::begin(int speed){
+  if (speed!=9600){
+    cerr << "wrong speed\n";
+    throw BoardException(SPEED);
+  }
+}
+void Terminal::println(string s){
+  cout <<"Serial: "<< s<<endl;
+}
+
+// representatoin du bus I2C
+I2C::I2C(){
+  for(int i=0;i<MAX_I2C_DEVICES;i++){
+    registre[i]=new char[I2C_BUFFER_SIZE];
+    vide[i]=true;
+  }
+}
+
+bool I2C::isEmptyRegister(int addr){
+  bool result=true;
+  if ((addr>=0)&&(addr<MAX_I2C_DEVICES))
+    result=vide[addr];
+  else
+    throw BoardException(ADDRESS);
+  return result;
+}
+
+int I2C::write(int addr, char* bytes, int size){
+  if ((addr<0)||(addr>=MAX_I2C_DEVICES))
+    throw BoardException(ADDRESS);
+  if ((size<0)||(size>I2C_BUFFER_SIZE))
+    throw BoardException(SIZEXC);
+  tabmutex[addr].lock();
+  memcpy(registre[addr],bytes,size*sizeof(char));
+  vide[addr]=false;
+  tabmutex[addr].unlock();
+  return size;
+}
+
+int I2C::requestFrom(int addr, char* bytes, int size){
+  int result =0;
+  if ((addr<0)||(addr>=MAX_I2C_DEVICES))
+    throw BoardException(ADDRESS);
+  if ((size<0)||(size>I2C_BUFFER_SIZE))
+    throw BoardException(SIZEXC);
+  if (vide[addr]==false){
+    tabmutex[addr].lock();
+    memcpy(bytes,registre[addr],size*sizeof(char));
+    vide[addr]=true;
+    tabmutex[addr].unlock();
+    result =size;
+  }
+  return result;
+}
+
+char * I2C::getRegistre(int addr){
+  if ((addr<0)||(addr>=MAX_I2C_DEVICES))
+    throw BoardException(ADDRESS);
+  return (registre[addr]);
+}
+
+bool* I2C::getVide(int addr){
+  if ((addr<0)||(addr>=MAX_I2C_DEVICES))
+    throw BoardException(ADDRESS);
+  return (&vide[addr]);
+}
+
+// classe generique reprenstant un capteur/actionneur
+Device::Device(){
+  ptrtype=NULL;
+  ptrmem=NULL;
+  i2caddr=-1;
+  i2cbus=NULL;
+}
+
+void Device::run(){
+  while(1){
+    
+    cout << "empty device\n";
+    sleep(3);
+  }
+}
+
+void Device::setPinMem(unsigned short* ptr,enum typeio *c){
+  ptrtype=c;
+  ptrmem=ptr;
+}
+
+void Device::setI2CAddr(int addr, I2C * bus){
+  i2caddr=addr;
+  i2cbus=bus;
+}
+
+
+
+
+
+  
+void Board::run(){
+  try{
+    setup();
+    while(1) loop();
+  }
+  catch(BoardException e){
+    cout <<"exception: "<<e.get() <<endl;
+  }
+}
+
+void Board::pin(int p, Device& s){
+  s.setPinMem(&io[p], &stateio[p]);
+  tabthreadpin[p]=new thread(&Device::run,&s);
+  
+}
+
+void Board::pinMode(int p,enum typeio t){
+  stateio[p]=t;
+}
+
+void Board::digitalWrite(int i, int l){
+  if (stateio[i]==OUTPUT)
+    io[i]=l;
+  else
+    throw BoardException(INOUT);
+}
+
+int Board::digitalRead(int i){
+  int   result=0;
+  if (stateio[i]==INPUT)
+    result= io[i];
+  else
+    throw BoardException(INOUT);
+  return result;
+}
+
+void Board::analogWrite(int i, int l){
+  if (stateio[i]==OUTPUT)
+    io[i]=l;
+  else
+    throw BoardException(INOUT);
+}
+
+int Board::analogRead(int i){
+  int   result=0;
+  if (stateio[i]==INPUT)
+    result= io[i];
+  else
+    throw BoardException(INOUT);
+  return result;
+}
+
+void Board::i2c(int addr,Device& dev){
+  if ((addr<0)||(addr>=MAX_I2C_DEVICES))
+   throw BoardException(ADDRESS);
+  dev.setI2CAddr(addr,&bus);
+  tabthreadbus[addr]=new thread(&Device::run,&dev);
+}
+

src/core_simulation.cpp~

@@ -0,0 +1,183 @@
+
+#include <thread>
+#include <unistd.h>
+#include <string.h>
+
+#include "core_simulation.h"
+
+// class BoardException
+int BoardException::get(){return num;}
+
+string BoardException::text(){
+  string s;
+  switch(num){
+  case SPEED : s=string("mauvaise vitesse de la laison terminal");break;
+  case INOUT : s=string("mauvaise utilisation du sens de l'entree/sortie"); break;
+  case ADDRESS : s=string("mauvaise adresse de la pin"); break;
+  case SIZEXC : s=string("taille erronee"); break;
+  case EMPTY: s=string("zone vide"); break;
+  default: s=string("erreur inconnue");
+  }
+  return s;
+}
+
+// classe terminale
+void Terminal::begin(int speed){
+  if (speed!=9600){
+    cerr << "wrong speed\n";
+    throw BoardException(SPEED);
+  }
+}
+void Terminal::println(string s){
+  cout <<"Serial: "<< s<<endl;
+}
+
+// representatoin du bus I2C
+I2C::I2C(){
+  for(int i=0;i<MAX_I2C_DEVICES;i++){
+    registre[i]=new char[I2C_BUFFER_SIZE];
+    vide[i]=true;
+  }
+}
+
+bool I2C::isEmptyRegister(int addr){
+  bool result=true;
+  if ((addr>=0)&&(addr<MAX_I2C_DEVICES))
+    result=vide[addr];
+  else
+    throw BoardException(ADDRESS);
+  return result;
+}
+
+int I2C::write(int addr, char* bytes, int size){
+  if ((addr<0)||(addr>=MAX_I2C_DEVICES))
+    throw BoardException(ADDRESS);
+  if ((size<0)||(size>I2C_BUFFER_SIZE))
+    throw BoardException(SIZEXC);
+  tabmutex[addr].lock();
+  memcpy(registre[addr],bytes,size*sizeof(char));
+  vide[addr]=false;
+  tabmutex[addr].unlock();
+  return size;
+}
+
+int I2C::requestFrom(int addr, char* bytes, int size){
+  int result =0;
+  if ((addr<0)||(addr>=MAX_I2C_DEVICES))
+    throw BoardException(ADDRESS);
+  if ((size<0)||(size>I2C_BUFFER_SIZE))
+    throw BoardException(SIZEXC);
+  if (vide[addr]==false){
+    tabmutex[addr].lock();
+    memcpy(bytes,registre[addr],size*sizeof(char));
+    vide[addr]=true;
+    tabmutex[addr].unlock();
+    result =size;
+  }
+  return result;
+}
+
+char * I2C::getRegistre(int addr){
+  if ((addr<0)||(addr>=MAX_I2C_DEVICES))
+    throw BoardException(ADDRESS);
+  return (registre[addr]);
+}
+
+bool* I2C::getVide(int addr){
+  if ((addr<0)||(addr>=MAX_I2C_DEVICES))
+    throw BoardException(ADDRESS);
+  return (&vide[addr]);
+}
+
+// classe generique reprenstant un capteur/actionneur
+Device::Device(){
+  ptrtype=NULL;
+  ptrmem=NULL;
+  i2caddr=-1;
+  i2cbus=NULL;
+}
+
+void Device::run(){
+  while(1){
+    
+    cout << "empty device\n";
+    sleep(3);
+  }
+}
+
+void Device::setPinMem(unsigned short* ptr,enum typeio *c){
+  ptrtype=c;
+  ptrmem=ptr;
+}
+
+void Device::setI2CAddr(int addr, I2C * bus){
+  i2caddr=addr;
+  i2cbus=bus;
+}
+
+// classe representant une carte arduino
+//Pour la gestion des differents capteurs d'alarme
+void Board::gestionAlarme() {
+
+
+
+  
+void Board::run(){
+  try{
+    setup();
+    while(1) loop();
+  }
+  catch(BoardException e){
+    cout <<"exception: "<<e.get() <<endl;
+  }
+}
+
+void Board::pin(int p, Device& s){
+  s.setPinMem(&io[p], &stateio[p]);
+  tabthreadpin[p]=new thread(&Device::run,&s);
+  
+}
+
+void Board::pinMode(int p,enum typeio t){
+  stateio[p]=t;
+}
+
+void Board::digitalWrite(int i, int l){
+  if (stateio[i]==OUTPUT)
+    io[i]=l;
+  else
+    throw BoardException(INOUT);
+}
+
+int Board::digitalRead(int i){
+  int   result=0;
+  if (stateio[i]==INPUT)
+    result= io[i];
+  else
+    throw BoardException(INOUT);
+  return result;
+}
+
+void Board::analogWrite(int i, int l){
+  if (stateio[i]==OUTPUT)
+    io[i]=l;
+  else
+    throw BoardException(INOUT);
+}
+
+int Board::analogRead(int i){
+  int   result=0;
+  if (stateio[i]==INPUT)
+    result= io[i];
+  else
+    throw BoardException(INOUT);
+  return result;
+}
+
+void Board::i2c(int addr,Device& dev){
+  if ((addr<0)||(addr>=MAX_I2C_DEVICES))
+   throw BoardException(ADDRESS);
+  dev.setI2CAddr(addr,&bus);
+  tabthreadbus[addr]=new thread(&Device::run,&dev);
+}
+

src/core_simulation.h

@@ -0,0 +1,144 @@
+#ifndef CORE_SIMULATEUR_H
+#define CORE_SIMULATEUR_H
+
+// sleep() also under windows
+#ifdef __unix__
+# include <unistd.h>
+#elif defined _WIN32
+# include <windows.h>
+#define sleep(x) Sleep(1000 * (x))
+#endif
+
+#include <iostream>
+#include <string>
+#include <thread>
+#include <mutex>
+
+#define DELAY 3
+#define TEMP 22
+#define LUM 200
+#define HIGH 1
+#define LOW 0
+#define MAX_I2C_DEVICES 4
+#define I2C_BUFFER_SIZE 1024
+#define MAX_IO_PIN 15
+
+using namespace std;
+
+enum typeio {OUTPUT, INPUT};
+
+// exceptions gerees
+enum excep {SPEED, INOUT, ADDRESS, SIZEXC, EMPTY};
+class BoardException{
+protected:
+    // numero de l'exception
+  int num;
+public:
+  BoardException(int i):num(i){}
+    // recuperation du numero d'exception
+    int get();
+    // chaine expliquant l'exception
+    string text();
+};
+
+// gestion de la liaison terminal
+class Terminal {
+    public :
+    // fonction arduino : initialisation de la liaison
+    void begin(int speed);
+    // fonction arduino : affichage sur le terminal
+    void println(string s);
+};
+
+// representatoin du bus I2C
+class I2C{
+protected:
+    // zone memoire d'echange pour chaque element connecte sur le bus
+  char * registre[MAX_I2C_DEVICES];
+    // etat de la zone memoire d'echange pour chaque element vide ou pas
+  bool vide[MAX_I2C_DEVICES];
+    // outil pour eviter les conflits en lecture ecriture sur le bus
+  mutex tabmutex[MAX_I2C_DEVICES];
+public:
+    // constructeur des différents attributs: memoire, etat et synchonisation
+    I2C();
+  // est ce qu il y a quelque chose a lire pour le device numero addr
+    bool isEmptyRegister(int addr);
+   // ecriture d'un ensemble d'octets dansle registre du device numero addr
+    int write(int addr, char* bytes, int size);
+   // lecture d'un ensemble d'octets dans le registre du device numero addr
+    int requestFrom(int addr, char* bytes, int size);
+    // recuperation de la zone memoire du registre du device numero addr
+    char * getRegistre(int addr);
+  // est ce que le registre du device numero addr EST VIDE
+    bool* getVide(int addr);
+};
+
+// representation generique d'un capteur ou d'un actionneur numerique, analogique ou sur le bue I2C
+class Device{
+protected:
+    // lien avec la carte pour lire/ecrire une valeur
+  unsigned short *ptrmem;
+    // lien avec la carte pour savoir si c'est une pin en entree ou en sortie
+  enum typeio *ptrtype;
+    // numero sur le bus i2c
+  int i2caddr;
+    // lien sur l'objet representant le bus I2C
+  I2C *i2cbus;
+public:
+    // constructeur initialisant le minimum
+    Device();
+    // boucle simulant l'equipement
+    virtual void run();
+    // lien entre le device et la carte arduino
+    void setPinMem(unsigned short* ptr,enum typeio *c);
+    // lien entre le device I2C et la carte arduino
+    void setI2CAddr(int addr, I2C * bus);
+};
+
+// classe representant une carte arduino
+class Board{
+public:
+ // valeur sur les pin
+  unsigned short io[MAX_IO_PIN];
+    // pin d'entree ou de sortie
+  enum typeio stateio[MAX_IO_PIN];
+    // threads representant chaque senseur/actionneur sur le pins analogique et digitale
+  thread *tabthreadpin[MAX_IO_PIN];
+    // representation du bus I2C
+  I2C bus;
+    // representation de la liaison terminal
+  Terminal Serial;
+    // threads representant chaque senseur/actionneur sur le bus I2C
+  thread *tabthreadbus[MAX_I2C_DEVICES];
+
+  
+
+  //Gestion Capteurs alarme
+  void gestionAlarme();
+ 
+// simulation de la boucle de controle arduino
+    void run();
+  // accroachage d'un senseur/actionneur à une pin
+    void pin(int p, Device& s);
+    // accroachage d'un senseur/actionneur à une adresse du bus I2C
+      void i2c(int addr,Device& dev);
+ // fonction arduino : configuration d'une pin en entree ou en sortie
+    void pinMode(int p,enum typeio t);
+  // fonction arduino : ecriture HIGH ou LOW sur une pin
+    void digitalWrite(int i, int l);
+    // fonction arduino : lecture digital sur une pin
+    int digitalRead(int i);
+     // fonction arduino : lecture analogique sur une pin
+    void analogWrite(int i, int l);
+   // fonction arduino : ecriture analogique sur une pin
+    int analogRead(int i);
+  // fonction arduino : initialisation de la carte arduino
+  void setup();
+    // fonction arduino : boucle de controle de la carte arduino
+  void loop();
+};
+
+#endif
+
+

src/core_simulation.h~

@@ -0,0 +1,144 @@
+#ifndef CORE_SIMULATEUR_H
+#define CORE_SIMULATEUR_H
+
+// sleep() also under windows
+#ifdef __unix__
+# include <unistd.h>
+#elif defined _WIN32
+# include <windows.h>
+#define sleep(x) Sleep(1000 * (x))
+#endif
+
+#include <iostream>
+#include <string>
+#include <thread>
+#include <mutex>
+
+#define DELAY 3
+#define TEMP 22
+#define LUM 200
+#define HIGH 1
+#define LOW 0
+#define MAX_I2C_DEVICES 4
+#define I2C_BUFFER_SIZE 1024
+#define MAX_IO_PIN 6
+
+using namespace std;
+
+enum typeio {OUTPUT, INPUT};
+
+// exceptions gerees
+enum excep {SPEED, INOUT, ADDRESS, SIZEXC, EMPTY};
+class BoardException{
+protected:
+    // numero de l'exception
+  int num;
+public:
+  BoardException(int i):num(i){}
+    // recuperation du numero d'exception
+    int get();
+    // chaine expliquant l'exception
+    string text();
+};
+
+// gestion de la liaison terminal
+class Terminal {
+    public :
+    // fonction arduino : initialisation de la liaison
+    void begin(int speed);
+    // fonction arduino : affichage sur le terminal
+    void println(string s);
+};
+
+// representatoin du bus I2C
+class I2C{
+protected:
+    // zone memoire d'echange pour chaque element connecte sur le bus
+  char * registre[MAX_I2C_DEVICES];
+    // etat de la zone memoire d'echange pour chaque element vide ou pas
+  bool vide[MAX_I2C_DEVICES];
+    // outil pour eviter les conflits en lecture ecriture sur le bus
+  mutex tabmutex[MAX_I2C_DEVICES];
+public:
+    // constructeur des différents attributs: memoire, etat et synchonisation
+    I2C();
+  // est ce qu il y a quelque chose a lire pour le device numero addr
+    bool isEmptyRegister(int addr);
+   // ecriture d'un ensemble d'octets dansle registre du device numero addr
+    int write(int addr, char* bytes, int size);
+   // lecture d'un ensemble d'octets dans le registre du device numero addr
+    int requestFrom(int addr, char* bytes, int size);
+    // recuperation de la zone memoire du registre du device numero addr
+    char * getRegistre(int addr);
+  // est ce que le registre du device numero addr EST VIDE
+    bool* getVide(int addr);
+};
+
+// representation generique d'un capteur ou d'un actionneur numerique, analogique ou sur le bue I2C
+class Device{
+protected:
+    // lien avec la carte pour lire/ecrire une valeur
+  unsigned short *ptrmem;
+    // lien avec la carte pour savoir si c'est une pin en entree ou en sortie
+  enum typeio *ptrtype;
+    // numero sur le bus i2c
+  int i2caddr;
+    // lien sur l'objet representant le bus I2C
+  I2C *i2cbus;
+public:
+    // constructeur initialisant le minimum
+    Device();
+    // boucle simulant l'equipement
+    virtual void run();
+    // lien entre le device et la carte arduino
+    void setPinMem(unsigned short* ptr,enum typeio *c);
+    // lien entre le device I2C et la carte arduino
+    void setI2CAddr(int addr, I2C * bus);
+};
+
+// classe representant une carte arduino
+class Board{
+public:
+ // valeur sur les pin
+  unsigned short io[MAX_IO_PIN];
+    // pin d'entree ou de sortie
+  enum typeio stateio[MAX_IO_PIN];
+    // threads representant chaque senseur/actionneur sur le pins analogique et digitale
+  thread *tabthreadpin[MAX_IO_PIN];
+    // representation du bus I2C
+  I2C bus;
+    // representation de la liaison terminal
+  Terminal Serial;
+    // threads representant chaque senseur/actionneur sur le bus I2C
+  thread *tabthreadbus[MAX_I2C_DEVICES];
+
+  
+
+  //Gestion Capteurs alarme
+  void gestionAlarme();
+ 
+// simulation de la boucle de controle arduino
+    void run();
+  // accroachage d'un senseur/actionneur à une pin
+    void pin(int p, Device& s);
+    // accroachage d'un senseur/actionneur à une adresse du bus I2C
+      void i2c(int addr,Device& dev);
+ // fonction arduino : configuration d'une pin en entree ou en sortie
+    void pinMode(int p,enum typeio t);
+  // fonction arduino : ecriture HIGH ou LOW sur une pin
+    void digitalWrite(int i, int l);
+    // fonction arduino : lecture digital sur une pin
+    int digitalRead(int i);
+     // fonction arduino : lecture analogique sur une pin
+    void analogWrite(int i, int l);
+   // fonction arduino : ecriture analogique sur une pin
+    int analogRead(int i);
+  // fonction arduino : initialisation de la carte arduino
+  void setup();
+    // fonction arduino : boucle de controle de la carte arduino
+  void loop();
+};
+
+#endif
+
+

src/mydevices.cpp

@@ -0,0 +1,323 @@
+#include "mydevices.h"
+
+
+using namespace std;
+
+int indice = 0;
+int luminosite_LED=LUM;
+
+
+
+//Classe Actionneur
+Actionneur::Actionneur(int ty, int t,int s):Device(),temps(t),type(ty),state(s){
+  nbrTotal+=1;
+}
+
+int Actionneur::getNbrTotal(){
+  return nbrTotal; }
+
+
+void Actionneur::setState(int s){
+  state =s;}
+
+int Actionneur::getState(){
+  return state;}
+
+void Actionneur::setTemps(int t){
+  temps=t;}
+
+int Actionneur::getTemps(){
+  return temps;}
+int Actionneur::getType(){
+  return type;}
+//Methode Run  redefinir pour chaque type de Bouton
+void Actionneur::run() {
+  setState(0);
+
+}
+
+  
+
+
+  
+
+//Interaction Exterieure
+  ExternalDigitalSensorButton::ExternalDigitalSensorButton(int t): Actionneur(1,t,0){
+  
+  
+
+}
+void ExternalDigitalSensorButton::run(){
+  if(ifstream("on.txt")){
+    setState(1);
+    
+    
+    }
+  else{
+    setState(0);
+   
+  }
+
+  
+
+  }
+	
+
+//Classe Capteur
+Capteur::Capteur(int ty, int t):Device(),temps(t),type(ty),alea(1){
+  
+
+}
+int Capteur::getNbrTotal(){
+  return nbrTotal;}
+
+void Capteur::setTemps(int t){
+  temps = t;}
+
+int Capteur::getTemps(){
+  return temps;}
+
+void Capteur::setValeur(int va){
+  valeur =va;}
+
+int Capteur::getValeur(){
+  return valeur;}
+void Capteur::setAlea(int al){
+  alea = al;}
+int Capteur::getAlea(){
+  return alea;}
+int Capteur::getType(){
+  return type;}
+void Capteur::run(){
+  setValeur(0);}
+
+
+//classe AnalogSensorTemperature
+AnalogSensorTemperature::AnalogSensorTemperature(int d):Capteur(1,d){
+  valeur = TEMP;
+  
+}
+
+void AnalogSensorTemperature::run(){
+  
+  while(1){
+    alea=1-alea;
+    if(ptrmem!=NULL)
+      *ptrmem=valeur+alea;
+    sleep(temps);
+  }
+}
+//classe AnalogSensorLuminosity
+AnalogSensorLuminosity::AnalogSensorLuminosity(int d):Capteur(2,d){
+  valeur = LUM;
+
+}
+
+void AnalogSensorLuminosity::run(){
+ 
+  while(1){
+     
+    alea=1-alea;
+    if(ptrmem!=NULL){
+      valeur=luminosite_LED;
+      *ptrmem=valeur+alea;}
+    sleep(temps);
+  }
+}
+
+AnalogSensorMovement::AnalogSensorMovement(int d):Capteur(3,d){
+  mode =1;
+  nom ="Default";
+  path = "Maison/on.txt";
+}
+void AnalogSensorMovement::setPath(string p){
+  path =p;
+}
+string AnalogSensorMovement::getPath(){
+  return path;}
+string AnalogSensorMovement::getNom(){
+  return nom;}
+int AnalogSensorMovement::getMode(){
+  return mode;}
+
+void AnalogSensorMovement::config(){
+  string n;
+  int m;
+  int p;
+  
+  cout << "  " << endl;
+  cout << "Nouveau Capteur. Veuillez le configurer" << endl;
+  cout << "Comment voulez vous l'appeler?" << endl;
+  cin >> n;
+  nom=n;
+  cout << "Quel mode voulez-vous lui donner? 1-> Alerte Max, 2-> Ne sera pas actif si le mode Intelligent est activé" << endl;
+  cin >> m;
+  mode = m;
+  cout << "Dans quelle pièce de la maison allez-vous le placer? 1-> Chambre, 2-Salon, 3-> Garage" << endl;
+  cin >> p;
+  if(p==1){setPath("Maison/Chambre/on.txt");}
+  else if(p==2){setPath("Maison/Salon/on.txt");}
+  else if(p==3){setPath("Maison/Garage/on.txt");}
+
+
+  cout << "Le capteur rentré est : "<< endl;
+  cout << getNom() << endl;
+  cout << getPath() << endl;
+  cout << getMode() << endl;
+}
+void AnalogSensorMovement::detectMovement(){
+  int bin;
+  if (valeur == 0){
+    bin = remove("sonnerie.txt");
+  }
+  else if (valeur==1){
+    if (ifstream("LED/Actif_Max/on.txt")){
+      cout << "Il y a eu du mouvement "<< endl;
+      cout << "Capteur : "<< nom << endl;
+      std::ofstream outfile("sonnerie.txt");
+      outfile.close();
+    
+    
+      sleep(2);
+    }
+    else if (ifstream("LED/Actif_Intelligent/on.txt")){
+    
+      if (mode == 1){
+	cout << "Il y a eu du mouvement "<< endl;
+	cout << "Capteur : "<< nom << endl;
+        std::ofstream outfile("sonnerie.txt");
+	outfile.close();
+     
+	
+	sleep(2);
+      }
+      else if( mode ==2){
+	//Pas de sonnerie déclenché
+      }
+    
+    
+    
+    } 
+  }
+}
+    
+  
+  
+  
+void AnalogSensorMovement::run(){
+  while(1){
+    detectMovement();
+    if(ifstream(path)){
+      valeur = 1;
+      
+    }
+    else {
+      valeur =0;
+      
+    *ptrmem=valeur; 
+  }
+ 
+  if(ptrmem!=NULL){   
+    *ptrmem=valeur;}
+  }
+  
+}
+    
+
+
+
+
+//classe DigitalActuatorLED
+DigitalActuatorLED::DigitalActuatorLED(int t):Device(),state(LOW),temps(t){
+}
+
+void DigitalActuatorLED::run(){
+  while(1){
+    if(ptrmem!=NULL){
+      state=*ptrmem;}
+    if (state==LOW){
+      cout << "((((LED eteint))))\n";
+    sleep(temps);}
+    else{
+    cout << "((((LED allume))))\n";
+    sleep(temps);}
+    }
+}
+
+//Classe DigitalLED
+DigitalLED::DigitalLED(int t, string p, string n) : Device(), state(0),temps(t){
+  path = p;
+  nom=n;
+}
+
+void DigitalLED::run (){
+  while(1){
+    if(ifstream(path)){
+      cout << "LED :" << nom << " ON" << endl;
+    }
+    else{
+      cout << "LED: " << nom << " OFF" << endl;
+    }
+    
+    sleep(temps);
+  }
+}
+
+//Classe 
+//classe IntelligentDigitalActuatorLED
+IntelligentDigitalActuatorLED::IntelligentDigitalActuatorLED(int t): Device(), state(LOW),temps(t){
+}
+
+void IntelligentDigitalActuatorLED::run(){
+  while(1){
+    if(ptrmem!=NULL){
+      state=*ptrmem;}
+    if (ifstream("on.txt")){
+      state=HIGH;}
+    else{
+      state=LOW;}
+    if (state==LOW and indice==0){
+      cout << "((((LED OFF))))\n";
+      sleep(temps);}
+
+    else if( state!=LOW and indice==0){
+      cout << "((((LED ON))))\n";
+      luminosite_LED +=50;
+      indice+=1;
+      
+      sleep(temps);}
+
+    else if(state==LOW and indice==1) {
+      cout << "((((LED OFF))))\n";
+      luminosite_LED-=50;
+      indice-=1;
+      
+      sleep(temps);}
+    else if (state!= LOW and indice==1){
+      cout << "((((LED ON))))\n";
+      
+      sleep(temps);}
+	
+  }
+}
+
+
+
+// classe I2CActuatorScreen
+I2CActuatorScreen::I2CActuatorScreen ():Device(){
+  }
+
+void I2CActuatorScreen::run(){
+  while(1){
+    if ( (i2cbus!=NULL)&&!(i2cbus->isEmptyRegister(i2caddr))){
+      Device::i2cbus->requestFrom(i2caddr, buf, I2C_BUFFER_SIZE);
+      cout << "---screen :"<< buf << endl;
+    }
+    sleep(1);
+    }
+}
+
+
+
+
+

src/mydevices.cpp~

@@ -0,0 +1,250 @@
+#include "mydevices.h"
+
+
+using namespace std;
+
+int indice = 0;
+int luminosite_LED=LUM;
+
+
+
+//Classe Actionneur
+Actionneur::Actionneur(int ty, int t,int s):Device(),temps(t),type(ty),state(s){
+  nbrTotal+=1;
+}
+
+int Actionneur::getNbrTotal(){
+  return nbrTotal; }
+
+
+void Actionneur::setState(int s){
+  state =s;}
+
+int Actionneur::getState(){
+  return state;}
+
+void Actionneur::setTemps(int t){
+  temps=t;}
+
+int Actionneur::getTemps(){
+  return temps;}
+int Actionneur::getType(){
+  return type;}
+//Methode Run  redefinir pour chaque type de Bouton
+void Actionneur::run() {
+  setState(0);
+
+}
+
+  
+
+
+  
+
+//Interaction Exterieure
+  ExternalDigitalSensorButton::ExternalDigitalSensorButton(int t): Actionneur(1,t,0){
+  
+  
+
+}
+void ExternalDigitalSensorButton::run(){
+  if(ifstream("on.txt")){
+    setState(1);
+    
+    
+    }
+  else{
+    setState(0);
+   
+  }
+
+  
+
+  }
+	
+
+
+
+
+
+
+
+
+
+//Classe Capteur
+Capteur::Capteur(int ty, int t):Device(),temps(t),type(ty),alea(1){
+  
+
+}
+int Capteur::getNbrTotal(){
+  return nbrTotal;}
+
+void Capteur::setTemps(int t){
+  temps = t;}
+
+int Capteur::getTemps(){
+  return temps;}
+
+void Capteur::setValeur(int va){
+  valeur =va;}
+
+int Capteur::getValeur(){
+  return valeur;}
+void Capteur::setAlea(int al){
+  alea = al;}
+int Capteur::getAlea(){
+  return alea;}
+int Capteur::getType(){
+  return type;}
+void Capteur::run(){
+  setValeur(0);}
+
+
+//classe AnalogSensorTemperature
+AnalogSensorTemperature::AnalogSensorTemperature(int d):Capteur(1,d){
+  valeur = TEMP;
+  
+}
+
+void AnalogSensorTemperature::run(){
+  
+  while(1){
+    alea=1-alea;
+    if(ptrmem!=NULL)
+      *ptrmem=valeur+alea;
+    sleep(temps);
+  }
+}
+//classe AnalogSensorLuminosity
+AnalogSensorLuminosity::AnalogSensorLuminosity(int d):Capteur(2,d){
+  valeur = LUM;
+
+}
+
+void AnalogSensorLuminosity::run(){
+ 
+  while(1){
+     
+    alea=1-alea;
+    if(ptrmem!=NULL){
+      valeur=luminosite_LED;
+      *ptrmem=valeur+alea;}
+    sleep(temps);
+  }
+}
+
+AnalogSensorMovement::AnalogSensorMovement(int d):Capteur(3,d){
+  mode =1;
+  nom ="Defautl";
+  path = "Maison/on.txt";
+}
+void AnalogSensorMovement::setPath(string p){
+  path =p;
+}
+void AnalogSensorMovement::run(){
+  while(1){
+    if(ifstream(path)){
+      
+    valeur = 1;
+    cout << "Il y a qqun" << endl;
+    *ptrmem=valeur; 
+  }
+  else{ valeur = 0;}
+  if(ptrmem!=NULL){   
+    *ptrmem=valeur;}
+  }
+}
+    
+
+
+
+
+//classe DigitalActuatorLED
+DigitalActuatorLED::DigitalActuatorLED(int t):Device(),state(LOW),temps(t){
+}
+
+void DigitalActuatorLED::run(){
+  while(1){
+    if(ptrmem!=NULL){
+      state=*ptrmem;}
+    if (state==LOW){
+      cout << "((((LED eteint))))\n";
+    sleep(temps);}
+    else{
+    cout << "((((LED allume))))\n";
+    sleep(temps);}
+    }
+}
+//classe IntelligentDigitalActuatorLED
+IntelligentDigitalActuatorLED::IntelligentDigitalActuatorLED(int t): Device(), state(LOW),temps(t){
+}
+
+void IntelligentDigitalActuatorLED::run(){
+  while(1){
+    if(ptrmem!=NULL){
+      state=*ptrmem;}
+    if (ifstream("on.txt")){
+      state=HIGH;}
+    else{
+      state=LOW;}
+    if (state==LOW and indice==0){
+      cout << "((((LED OFF))))\n";
+      sleep(temps);}
+
+    else if( state!=LOW and indice==0){
+      cout << "((((LED ON))))\n";
+      luminosite_LED +=50;
+      indice+=1;
+      
+      sleep(temps);}
+
+    else if(state==LOW and indice==1) {
+      cout << "((((LED OFF))))\n";
+      luminosite_LED-=50;
+      indice-=1;
+      
+      sleep(temps);}
+    else if (state!= LOW and indice==1){
+      cout << "((((LED ON))))\n";
+      
+      sleep(temps);}
+	
+  }
+}
+
+//classe DigitalActuatorAlarm
+DigitalActuatorAlarm::DigitalActuatorAlarm(int t):Device(),state(LOW),temps(t){
+}
+
+void DigitalActuatorAlarm::run(){
+  detection detect;
+  detect=detection();
+  while(1){
+    if(ptrmem!=NULL){
+      state=*ptrmem;}
+    if (ifstream("Maison/Test/on.txt")){
+      
+    }
+  }
+    
+}
+
+
+// classe I2CActuatorScreen
+I2CActuatorScreen::I2CActuatorScreen ():Device(){
+  }
+
+void I2CActuatorScreen::run(){
+  while(1){
+    if ( (i2cbus!=NULL)&&!(i2cbus->isEmptyRegister(i2caddr))){
+      Device::i2cbus->requestFrom(i2caddr, buf, I2C_BUFFER_SIZE);
+      cout << "---screen :"<< buf << endl;
+    }
+    sleep(1);
+    }
+}
+
+
+
+
+

src/mydevices.h

@@ -0,0 +1,212 @@
+#ifndef MYDEVICES_H
+#define MYDEVICES_H
+
+#include <iostream>
+//#include <ofstream>
+#include <thread>
+#include <unistd.h>
+#include <string.h>
+#include <stdio.h>
+#include <fstream>
+#include "core_simulation.h"
+
+//Classe Actionneur
+
+class Actionneur : public Device{
+ protected:
+  int type; // 1-> Bouton
+  int temps;
+  int state; //0-> OFF  1-> ON
+  int nbrTotal=0;
+
+ public:
+  //constructeur
+  Actionneur(int ty, int t,int s);
+
+  //Methodes
+  
+
+  //Pour recuperer le nombre total d'actionneurs crees.
+  int getNbrTotal();
+
+  //Pour changer l'etat de l'actionneur
+  //0 ->OFF 1 -> ON
+  void setState(int s);
+
+  //Pour avoir l'etat actuel de l'actionneur
+  //0-> OFF  1-> ON
+  int getState();
+
+
+  //Pour changer le temps
+  void setTemps(int t);
+  //Pour avoir le temps
+  int getTemps();
+  //Pour avoir le type
+  int getType();
+  //Methode Run  redefinir pour chaque type de Bouton
+  void run();
+
+  
+
+  
+
+};
+
+class Capteur : public Device{
+
+ protected:
+  int type;
+  int temps;
+  int valeur;
+  int alea; //De base il est  1
+  int nbrTotal;
+
+ public:
+  Capteur(int ty, int t);
+
+  //Pour recuperer le nombre total de capteurs crees.
+  int getNbrTotal();
+  //Pour changer le temps
+  void setTemps(int t);
+  //Pour avoir le temps
+  int getTemps();
+  //Pour actualiser la valeur
+  void setValeur(int va);
+  //Pour avoir la valeur du capteur
+  int getValeur();
+  //Pour changer l'alea
+  void setAlea(int al);
+  //Pour avor l'alea
+  int getAlea();
+  //Pour avoir le type de capteur
+  int getType();
+
+  virtual void run();
+  
+};
+
+// exemple de capteur analogique de temperature, ne pas oublier d'heriter de Device
+class AnalogSensorTemperature: public Capteur { 
+ 
+  
+public:
+  //constructeur ne pas oublier d'initialiser la classe mere
+  AnalogSensorTemperature(int d);
+  // thread representant le capteur et permettant de fonctionner independamment de la board
+   void run();
+};
+
+
+//Capteur de Luminosite
+class AnalogSensorLuminosity : public Capteur {
+ 
+ public:
+  AnalogSensorLuminosity (int d);
+
+  virtual void run();
+
+};
+
+//Capteur de mouvement
+class AnalogSensorMovement:public Capteur{
+ private:
+
+  int mode;
+  string nom;
+  string path;
+  
+ public:
+  //Constructeur
+  AnalogSensorMovement(int d);
+
+  void setPath(string p);
+  string getPath();
+  string getNom();
+  int getMode();
+  void config();
+  void detectMovement();
+
+  void run();
+
+};
+
+  
+
+
+
+//LED intelligente
+class IntelligentDigitalActuatorLED : public Device{
+ private:
+  int state;
+  int temps;
+
+ public:
+  IntelligentDigitalActuatorLED(int i);
+
+  virtual void run();
+};
+
+
+// exemple d'actionneur digital : une led, ne pas oublier d'heriter de Device
+
+
+
+
+//Interaction Exterieure
+class ExternalDigitalSensorButton: public Actionneur{
+ 
+
+ public:
+  ExternalDigitalSensorButton(int t);
+  virtual void run();
+
+
+
+};
+
+					      
+
+
+
+// exemple d'actionneur digital : une led, ne pas oublier d'heriter de Device
+class DigitalActuatorLED: public Device {
+private:
+  // etat de la LED
+  int state;
+  // temps entre 2 affichage de l etat de la led
+  int temps;
+  
+public:
+    // initialisation du temps de rafraichiisement
+  DigitalActuatorLED(int t);
+  // thread representant l'actionneur et permettant de fonctionner independamment de la board
+  virtual void run();
+};
+
+class DigitalLED : public Device{
+ private:
+  int state;
+  int temps;
+  string path;
+  string nom;
+
+ public:
+  DigitalLED(int t, string p,string n);
+  void run();
+};
+
+// exemple d'actionneur sur le bus I2C permettant d'echanger des tableaux de caracteres : un ecran, ne pas oublier d'heriter de Device
+class I2CActuatorScreen : public Device{
+protected:
+    // memorise l'affichage de l'ecran
+  char buf[I2C_BUFFER_SIZE];
+  
+public:
+  // constructeur
+  I2CActuatorScreen ();
+  // thread representant le capteur et permettant de fonctionner independamment de la board
+  virtual void run();
+};
+
+#endif

src/mydevices.h~

@@ -0,0 +1,205 @@
+#ifndef MYDEVICES_H
+#define MYDEVICES_H
+
+#include <iostream>
+#include <thread>
+#include <unistd.h>
+#include <string.h>
+#include <fstream>
+#include "core_simulation.h"
+#include "detection.h"
+//Classe Actionneur
+
+class Actionneur : public Device{
+ protected:
+  int type; // 1-> Bouton
+  int temps;
+  int state; //0-> OFF  1-> ON
+  int nbrTotal=0;
+
+ public:
+  //constructeur
+  Actionneur(int ty, int t,int s);
+
+  //Methodes
+  
+
+  //Pour recuperer le nombre total d'actionneurs crees.
+  int getNbrTotal();
+
+  //Pour changer l'etat de l'actionneur
+  //0 ->OFF 1 -> ON
+  void setState(int s);
+
+  //Pour avoir l'etat actuel de l'actionneur
+  //0-> OFF  1-> ON
+  int getState();
+
+
+  //Pour changer le temps
+  void setTemps(int t);
+  //Pour avoir le temps
+  int getTemps();
+  //Pour avoir le type
+  int getType();
+  //Methode Run  redefinir pour chaque type de Bouton
+  void run();
+
+  
+
+  
+
+};
+
+class Capteur : public Device{
+
+ protected:
+  int type;
+  int temps;
+  int valeur;
+  int alea; //De base il est  1
+  int nbrTotal;
+
+ public:
+  Capteur(int ty, int t);
+
+  //Pour recuperer le nombre total de capteurs crees.
+  int getNbrTotal();
+  //Pour changer le temps
+  void setTemps(int t);
+  //Pour avoir le temps
+  int getTemps();
+  //Pour actualiser la valeur
+  void setValeur(int va);
+  //Pour avoir la valeur du capteur
+  int getValeur();
+  //Pour changer l'alea
+  void setAlea(int al);
+  //Pour avor l'alea
+  int getAlea();
+  //Pour avoir le type de capteur
+  int getType();
+
+  virtual void run();
+  
+};
+
+// exemple de capteur analogique de temperature, ne pas oublier d'heriter de Device
+class AnalogSensorTemperature: public Capteur { 
+ 
+  
+public:
+  //constructeur ne pas oublier d'initialiser la classe mere
+  AnalogSensorTemperature(int d);
+  // thread representant le capteur et permettant de fonctionner independamment de la board
+   void run();
+};
+
+
+//Capteur de Luminosite
+class AnalogSensorLuminosity : public Capteur {
+ 
+ public:
+  AnalogSensorLuminosity (int d);
+
+  virtual void run();
+
+};
+
+//Capteur de mouvement
+class AnalogSensorMovement:public Capteur{
+ private:
+
+  int mode;
+  string nom;
+  string path;
+  
+ public:
+  //Constructeur
+  AnalogSensorMovement(int d);
+
+  void setPath(string p);
+
+  void run();
+
+};
+
+  
+
+
+
+//LED intelligente
+class IntelligentDigitalActuatorLED : public Device{
+ private:
+  int state;
+  int temps;
+
+ public:
+  IntelligentDigitalActuatorLED(int i);
+
+  virtual void run();
+};
+
+
+// exemple d'actionneur digital : une led, ne pas oublier d'heriter de Device
+class DigitalActuatorAlarm: public Device {
+private:
+  // etat de l'alarme
+  int state;
+  // temps entre 2 affichage de l etat de l'alarme
+  int temps;
+  
+public:
+    // initialisation du temps de rafraichiisement
+  DigitalActuatorAlarm(int t);
+  // thread representant l'actionneur et permettant de fonctionner independamment de la board
+  virtual void run();
+};
+
+
+
+//Interaction Exterieure
+class ExternalDigitalSensorButton: public Actionneur{
+ 
+
+ public:
+  ExternalDigitalSensorButton(int t);
+  virtual void run();
+
+
+
+};
+
+					      
+
+
+
+// exemple d'actionneur digital : une led, ne pas oublier d'heriter de Device
+class DigitalActuatorLED: public Device {
+private:
+  // etat de la LED
+  int state;
+  // temps entre 2 affichage de l etat de la led
+  int temps;
+  
+public:
+    // initialisation du temps de rafraichiisement
+  DigitalActuatorLED(int t);
+  // thread representant l'actionneur et permettant de fonctionner independamment de la board
+  virtual void run();
+};
+
+// exemple d'actionneur sur le bus I2C permettant d'echanger des tableaux de caracteres : un ecran, ne pas oublier d'heriter de Device
+class I2CActuatorScreen : public Device{
+protected:
+    // memorise l'affichage de l'ecran
+  char buf[I2C_BUFFER_SIZE];
+  
+public:
+  // constructeur
+  I2CActuatorScreen ();
+  // thread representant le capteur et permettant de fonctionner independamment de la board
+  virtual void run();
+};
+
+#endif

src/sketch_ino.cpp

@@ -0,0 +1,93 @@
+#include <unistd.h>
+
+#include "core_simulation.h"
+
+
+// la fonction d'initialisation d'arduino
+void Board::setup(){
+  // on configure la vitesse de la liaison
+  Serial.begin(9600);
+// on fixe les pin en entree et en sorite en fonction des capteurs/actionneurs mis sur la carte
+  pinMode(0,OUTPUT);
+  pinMode(1,INPUT);
+  pinMode(2,OUTPUT);
+  pinMode(3,OUTPUT);
+  pinMode(4,OUTPUT);
+  pinMode(5,INPUT);
+  pinMode(6,INPUT);
+}
+
+
+// la boucle de controle arduino
+void Board::loop(){
+  
+  char buf[100];
+  int val;
+  static int cpt=0;
+  static int bascule=0;
+  int i=0;
+
+  
+  for(i=0;i<10;i++){
+    /*
+    // lecture sur la pin 1 : capteur de temperature
+    val=analogRead(1);
+    sprintf(buf,"temperature %d",val);
+    Serial.println(buf);
+   
+    if(cpt%5==0){
+      // tous les 5 fois on affiche sur l ecran la temperature
+      sprintf(buf,"%d",val);
+      bus.write(1,buf,100);
+    }
+    cpt++;
+    sleep(1);
+
+    // lecture sur la pin 2 : capteur de luminosite
+    val=analogRead(2);
+    sprintf(buf,"luminosite %d",val);
+    Serial.println(buf);
+    if(cpt%5==0){
+      // tous les 5 fois on affiche sur l ecran la luminosite
+      sprintf(buf,"%d",val);
+      bus.write(1,buf,100);
+    }
+    cpt++;
+    sleep(1);
+
+     // lecture sur la pin 6 : LED Alarme
+    val=analogRead(6);
+    if(val==1){
+    sprintf(buf,"Alarme activé");
+    Serial.println(buf);}
+    
+    sleep(1);
+  }
+  // on eteint et on allume la LED
+  if(bascule)
+    digitalWrite(0,HIGH);
+  else
+    digitalWrite(0,LOW);
+  bascule=1-bascule;
+
+
+  // on eteint et on allume la IntelligentLED
+  if(bascule)
+    digitalWrite(3,HIGH);
+  else
+    digitalWrite(3,LOW);
+  bascule=1-bascule;
+    */
+
+  }
+    
+
+
+ 
+}
+
+
+
+ 
+
+

src/sketch_ino.cpp~

@@ -0,0 +1,93 @@
+#include <unistd.h>
+
+#include "core_simulation.h"
+
+
+// la fonction d'initialisation d'arduino
+void Board::setup(){
+  // on configure la vitesse de la liaison
+  Serial.begin(9600);
+// on fixe les pin en entree et en sorite en fonction des capteurs/actionneurs mis sur la carte
+  pinMode(0,OUTPUT);
+  pinMode(1,INPUT);
+  pinMode(2,INPUT);
+  pinMode(3,INPUT);
+  pinMode(4,INPUT);
+  pinMode(5,INPUT);
+  pinMode(6,INPUT);
+}
+
+
+// la boucle de controle arduino
+void Board::loop(){
+  
+  char buf[100];
+  int val;
+  static int cpt=0;
+  static int bascule=0;
+  int i=0;
+
+  
+  for(i=0;i<10;i++){
+    /*
+    // lecture sur la pin 1 : capteur de temperature
+    val=analogRead(1);
+    sprintf(buf,"temperature %d",val);
+    Serial.println(buf);
+   
+    if(cpt%5==0){
+      // tous les 5 fois on affiche sur l ecran la temperature
+      sprintf(buf,"%d",val);
+      bus.write(1,buf,100);
+    }
+    cpt++;
+    sleep(1);
+
+    // lecture sur la pin 2 : capteur de luminosite
+    val=analogRead(2);
+    sprintf(buf,"luminosite %d",val);
+    Serial.println(buf);
+    if(cpt%5==0){
+      // tous les 5 fois on affiche sur l ecran la luminosite
+      sprintf(buf,"%d",val);
+      bus.write(1,buf,100);
+    }
+    cpt++;
+    sleep(1);
+
+     // lecture sur la pin 6 : LED Alarme
+    val=analogRead(6);
+    if(val==1){
+    sprintf(buf,"Alarme activé");
+    Serial.println(buf);}
+    
+    sleep(1);
+  }
+  // on eteint et on allume la LED
+  if(bascule)
+    digitalWrite(0,HIGH);
+  else
+    digitalWrite(0,LOW);
+  bascule=1-bascule;
+
+
+  // on eteint et on allume la IntelligentLED
+  if(bascule)
+    digitalWrite(3,HIGH);
+  else
+    digitalWrite(3,LOW);
+  bascule=1-bascule;
+    */
+
+  }
+    
+
+
+ 
+}
+
+
+
+ 
+
+