#include <UNO_S88.h>    // la librairie S88 pour les UNO/Nano

void setup() {
  S88_Setup(16);        // on donne le nombre capteur 8 ou 16
}

void loop() {
  S88_Loop();           // boucle sur les capteurs
}

#include <Arduino.h>
void S88_Setup(int nb_sensors);
void S88_Loop();

#include "UNO_S88.h"
#include <Arduino.h>

const byte clockS88 = 2;  // horloge du bus S88 pin = 2
int clockCounter=0;       // compteur de tops horloge 
const byte PSS88 = 3;     // signal PS du bus S88 pin = 3
long loopCounter=0;       // reset proper à l’ECOS
const byte dataIn=0;      // entrée des données depuis un autre Arduino dans
                          // la chaîne S88 pin = 0
const byte dataOut=1;     // sortie des données vers un autre Arduino dans
                          // la chaîne ou vers la centrale pin=1
unsigned int sensors=0;   // tampon de 16 bits pour les capteurs
unsigned int data=0xffff; // le registre à décalage
int nbsensors;            // nombre de capteurs  8 or 16
int beginPin = 4;         // première broche utilisée pour les capteurs
int endPin8 = 12;         // dernière broche pour  8 capteurs
int endPin16 = 21;        // dernière broche pour 16 capteurs
int endPin;               // variable locale

// routine d’interruption du signal PS
// (déclenchement d’un nouveau cycle d’horloge)

void PS() {
    clockCounter=0;       // on remet le compteur à zéro
    data=sensors;         // on vide le tampon des capteurs dans le
                          // registre à décalage
    sensors=0;            // on remet à zéro le tampon des capteurs
    loopCounter++;        // on incrémente le nombre de top d’horloge
}

// routine d’interruption de l’horloge S88

void clock() {
    digitalWrite(dataOut,bitRead(data,clockCounter)); // on décale 1 bit en sortie
    delayMicroseconds(16);                            // délai pour le décalage
    bitWrite(data,clockCounter,digitalRead(dataIn));  // on décale 1 bit en entrée
    clockCounter =(clockCounter +1) % nbsensors;      // modulo le nombre de capteurs
                                                      // (8 ou 16)
}

// le setup S88

void S88_Setup(int nb_sensors) {
    nbsensors = nb_sensors;         // nombre de capteurs désirés (8 ou 16)
    if (nbsensors == 8) {           // MAJ des broches concernées
      endPin = endPin8;
    }
    else {
      endPin = endPin16;
    } 
    pinMode(clockS88, INPUT_PULLUP); // init de la broche pour l’horloge
    attachInterrupt(0,clock,RISING); // horloge sur int 0 sur la broche 2 
    pinMode(PSS88, INPUT_PULLUP);    // init de la broche du signal PS
    attachInterrupt(1,PS,RISING);    // PS sur int1 sur la broche 3
    pinMode(dataIn,INPUT_PULLUP);    // pin 0 = entrée des données depuis un
                                     // autre Arduino
    pinMode(dataOut, OUTPUT);        // pin 1 = sortie des données vers la
                                     // centrale ou vers un autre Arduino
                                     // dans le chaînage S88
    for (int i = beginPin; i< endPin;i++) {
      pinMode(i,INPUT_PULLUP);       // init des broches des capteurs
    }
}

// la boucle

void S88_Loop() {
    if (loopCounter==20) {
      bitSet(sensors,0);             // reset des tampons des capteurs pour l’ECOS
    }
    for (int i = 4; i<endPin; i++) { // MAJ des capteurs
      if (!digitalRead(i)) {
        bitSet(sensors,i-4);
      }
    }
}

#include <MEGA_S88.h> // librairie S88 pour le MEGA

void setup()
{
  S88_Setup(2);       // on donne le nombre de modules souhaités
}

void loop()
{
  S88_Loop();		      // on boucle
}

#include "MEGA_S88.h"
#include <Arduino.h>

// Allocation des broches

const byte dataIn   = 0; // entrée des données depuis d’autres Arduino
const byte dataOut  = 1; // sortie vers la centrale ou vers d’autres 
                         // Arduino
const byte clockS88 = 2; // int0 pour l’horloge sur la broche 2 
const byte PSS88    = 3; // int1 pour le signal PS sur la broche 3 

int clockCounter = 0;    // compteur des tops horloge 
long loopCounter = 0;    // reset propre à l’ECOS

// nombre de modules de 16 capteurs 

int nbBlocs = 0; // le nombre de module souhaité

// registres à décalage des différents modules

unsigned int data1 = 0xFFFF; // register du module 1
unsigned int data2 = 0xFFFF; // register du module 2
unsigned int data3 = 0xFFFF; // register du module 3
unsigned int data4 = 0xFFFF; // register du module 4

// tampon des capteurs

unsigned int sensors1 = 0; // 16 capteurs du module 1
unsigned int sensors2 = 0; // 16 capteurs du module 2
unsigned int sensors3 = 0; // 16 capteurs du module 3
unsigned int sensors4 = 0; // 16 capteurs du module 4

// internal variable

int i,j;

// routine d’interruption du signal PS 

void PS()
{
  clockCounter = 0;  // RAZ du compteur de top horloge
  // il y a au moins un module, le premier le module 1
  data1 = sensors1;  // on vide le tampon des capteurs
                     // dans le registre à décalage
  sensors1 = 0;      // RAZ du tampon des capteurs
  switch (nbBlocs)
  {
    case 2 : { // si deux modules
      data2 = sensors2; sensors2 = 0;
      break;
    }
    case 3 : { // si 3
      data2 = sensors2; sensors2 = 0;
      data3 = sensors3; sensors3 = 0;
      break;
    }
    case 4 : { // si 4
      data2 = sensors2; sensors2 = 0;
      data3 = sensors3; sensors3 = 0;
      data4 = sensors4; sensors4 = 0;
      break;
    }
  }
  loopCounter++; // for reset management
}

// clock signal from S88

void clock()
{
  // exit bits to next S88 in chain
  digitalWrite(dataOut, bitRead(data1,clockCounter));
  switch (nbBlocs) // data buffer shift
  {	
    case 1 : {
      bitWrite(data1, clockCounter, digitalRead(dataIn));
      break;
    }
    case 2 : {
      bitWrite(data1, clockCounter, bitRead(data2,clockCounter));
      bitWrite(data2, clockCounter, digitalRead(dataIn));
      break;
    }
    case 3 : {
      bitWrite(data1, clockCounter, bitRead(data2,clockCounter));
      bitWrite(data2, clockCounter, bitRead(data3,clockCounter));
      bitWrite(data3, clockCounter, digitalRead(dataIn));
      break;
    }
    case 4 : {
      bitWrite(data1, clockCounter, bitRead(data2,clockCounter));
      bitWrite(data2, clockCounter, bitRead(data3,clockCounter));
      bitWrite(data3, clockCounter, bitRead(data4,clockCounter));
      bitWrite(data4, clockCounter, digitalRead(dataIn));
      break;
    }
  }
  clockCounter = (clockCounter + 1) % 16; // bits 0 to 15
}

// setup

void S88_Setup(int NbBlocs)
{
  nbBlocs = NbBlocs;
  for (i=4; i<20; i++) { // the first bloc
    pinMode(i,INPUT_PULLUP);
  }
  switch (nbBlocs)
  {
    case 2 : { // the second
      for (i=22; i<38; i++) {
        pinMode(i,INPUT_PULLUP);
      }
      break;
    }
    case 3 : { // the third
      for (i=22; i<54; i++) {
        pinMode(i,INPUT_PULLUP);
      }
      break;
    }
    case 4 : { // the fourth
      for (i=22; i<70; i++) {
        pinMode(i,INPUT_PULLUP);
      }
      break;
    }
  }
  pinMode(clockS88,INPUT_PULLUP);  // S88 clock in input
  attachInterrupt(0,clock,RISING); // interrupt int0
  pinMode(PSS88,INPUT_PULLUP);     // S88 PS in input
  attachInterrupt(1,PS,RISING);    // interrupt int1
  pinMode(dataOut, OUTPUT);        // init data out to other Arduino
                                   // or control board
  digitalWrite(dataOut,LOW);       // led off
  pinMode(dataIn,INPUT_PULLUP);    // data in from other Arduino
}

// loop

void S88_Loop()
{
  // reset management for ECOS
  if (loopCounter == 20) {
    bitSet(sensors1,0);
    switch (nbBlocs)
    {
      case 2 : {
        bitSet(sensors2,0);
        break;
      }
      case 3 : {
        bitSet(sensors3,0);
        break;
      }
      case 4 : {
        bitSet(sensors4,0);
        break;
      }
    }
  }

  // update all sensors by group
  for (i=4; i<20; i++) {
    if (!digitalRead(i)) {
      bitSet(sensors1,i-4);
    }
  }

  switch (nbBlocs)
  {
    case 2 : {
      for (i=22; i<38; i++) {
        if (!digitalRead(i)) {
          bitSet(sensors2,i-22);
        }
      }
      break;
    }
    case 3 : {
      for (i=22; i<38; i++) {
        if (!digitalRead(i)) {
          bitSet(sensors2,i-22);
        }
      }
      for (i=38; i<54; i++) {
        if (!digitalRead(i)) {
          bitSet(sensors3,i-38);
        }
      }
      break;
    }
    case 4 : {
      for (i=22; i<38; i++) {
        if (!digitalRead(i)) {
          bitSet(sensors2,i-22);
        }
      }
      for (i=38; i<54; i++) {
        if (!digitalRead(i)) {
          bitSet(sensors3,i-38);
        }
      }
      for (i=54; i<70; i++) {
        if (!digitalRead(i)) {
          bitSet(sensors4,i-54);
        }
      }
      break;
    }
  }
}