first commit

board.cpp

@@ -0,0 +1,23 @@
+#include "core_simulation.h"
+#include "mydevices.h"
+
+
+int main(){
+  // creation d'une board
+  Board esp8266;
+  // achat des senseurs et actionneurs
+  AnalogSensorTemperature temperature(DELAY,TEMP);
+  DigitalActuatorLED led1(DELAY);
+  I2CActuatorScreen screen;
+  
+  // branchement des capteurs actionneurs
+  esp8266.pin(1,temperature);
+  esp8266.pin(0,led1);
+  esp8266.i2c(1,screen);
+  
+  // allumage de la carte
+  esp8266.run();
+  return 0;
+}
+
+

core_simulation.cpp

@@ -0,0 +1,176 @@
+
+#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 SIZE : 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(SIZE);
+  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(SIZE);
+  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
+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);
+}
+

core_simulation.h

@@ -0,0 +1,130 @@
+#ifndef CORE_SIMULATEUR_H
+#define CORE_SIMULATEUR_H
+
+#include <iostream>
+#include <string>
+#include <thread>
+#include <mutex>
+
+#define DELAY 3
+#define TEMP 22
+#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, SIZE, 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];
+    
+// 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
+
+

mydevices.cpp

@@ -0,0 +1,53 @@
+
+#include "mydevices.h"
+
+using namespace std;
+
+//classe AnalogSensorTemperature
+AnalogSensorTemperature::AnalogSensorTemperature(int d,int  t):Device(),val(t),temps(d){
+  alea=1;
+}
+
+void AnalogSensorTemperature::run(){
+  while(1){
+    alea=1-alea;
+    if(ptrmem!=NULL)
+      *ptrmem=val+alea;
+    sleep(temps);
+  }
+}
+
+//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 << "((((eteint))))\n";
+    else
+    cout << "((((allume))))\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);
+    }
+}
+
+
+
+
+

mydevices.h

@@ -0,0 +1,56 @@
+#ifndef MYDEVICES_H
+#define MYDEVICES_H
+
+#include <iostream>
+#include <thread>
+#include <unistd.h>
+#include <string.h>
+#include "core_simulation.h"
+
+
+// exemple de capteur analogique de temperature, ne pas oublier d'heriter de Device
+class AnalogSensorTemperature: public Device {
+private:
+  // fait osciller la valeur du cpateur de 1
+  int alea;
+  // valeur de temperature mesuree
+  int val;
+  // temps entre 2 prises de valeurs
+  int temps;
+  
+public:
+  //constructeur ne pas oublier d'initialiser la classe mere
+  AnalogSensorTemperature(int d,int  t);
+  // thread representant le capteur et permettant de fonctionner independamment de la board
+  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

sketch_ino.cpp

@@ -0,0 +1,42 @@
+#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(1,INPUT);
+  pinMode(0,OUTPUT);
+}
+
+// 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);
+  }
+// on eteint et on allume la LED
+  if(bascule)
+    digitalWrite(0,HIGH);
+  else
+    digitalWrite(0,LOW);
+  bascule=1-bascule;
+  
+}
+
+