first commit

This commit is contained in:
Cameron Bray 2020-05-12 09:52:03 +02:00
commit 639e2b7b8f
6 changed files with 480 additions and 0 deletions

23
board.cpp Normal file
View file

@ -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;
}

176
core_simulation.cpp Normal file
View file

@ -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);
}

130
core_simulation.h Normal file
View file

@ -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

53
mydevices.cpp Normal file
View file

@ -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);
}
}

56
mydevices.h Normal file
View file

@ -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

42
sketch_ino.cpp Normal file
View file

@ -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;
}