Programmation de l'automate

Déclaration des variables

Commençons par définir le mapping de chaque broche du Controllino :

#include <Arduino.h>
#include <Controllino.h>

int M1_conveyor_FW = 2; // 17 côté Warehouse, Digital-Out 0 côté Controllino (pin 2)
int M1_conveyor_BW = 4; // 18 côté Warehouse, Digital-Out 2 côté Controllino (pin 4)

int M2_horiz_TR = 5; // 19 côté Warehouse, Digital-Out 3 côté Controllino (pin 5)
int M2_horiz_TCB = 3; // 20 côté Warehouse, Digital-Out 1 côté Controllino (pin 3)

int M3_vert_DOWN = 6; // 21 côté Warehouse, Digital-Out 4 côté Controllino (pin 6)
int M3_vert_UP = 7; // 22 côté Warehouse, Digital-Out 5 côté Controllino (pin 7)

int M4_cantilever_FW = 8; // 23 côté Warehouse, Digital-Out 6 côté Controllino (pin 8)
int M4_cantilever_BW = 9; // 24 côté Warehouse, Digital-Out 7 côté Controllino (pin 9)

int PIN_switch_horizontal = A12; // 5 côté Warehouse, Digital-In 0 côté Controllino (pin A12)
int PIN_cantilever_back = A13; // 16 côté Warehouse (I6), Digital-In 1 côté Controllino (pin A13)
int PIN_cantilever_front = 10; // 15 côté Warehouse (I5), Digital-In 2 côté Controllino (pin 10)
int PIN_light_barrier_inside = A10;  // 6 côté Warehouse (I2), Analog-In 10 côté Controllino (pin A10)
int PIN_light_barrier_outside = 11; // 7 côté Warehouse (I3), Digital-In 3 côté Controllino (pin 11)
int PIN_switch_vertical = A11; // 8 côté Warehouse (I4), Analog-In 11 côté Controllino (pin A11)

void setup() {
  pinMode(M1_conveyor_FW, OUTPUT);
  pinMode(M1_conveyor_BW, OUTPUT);

  pinMode(M2_horiz_TR, OUTPUT);
  pinMode(M2_horiz_TCB, OUTPUT);

  pinMode(M4_cantilever_FW, OUTPUT);
  pinMode(M4_cantilever_BW, OUTPUT);

  pinMode(PIN_switch_horizontal, INPUT);
  pinMode(PIN_cantilever_back, INPUT);
  pinMode(PIN_cantilever_front, INPUT);
  pinMode(PIN_light_barrier_inside, INPUT);
  pinMode(PIN_light_barrier_outside, INPUT);
  pinMode(PIN_switch_vertical, INPUT);
}

void loop() {
}

Fonctions des capteurs

Pour faciliter notre code, définissons les fonctions qui serviront à vérifier l'état des capteurs, car un test comme isThereIncomingBox(), c'ests toujours plus parlant qu'un test comme digitalRead(A10) == 0 :

// Pour le stockage, lorsqu'une pièce arrive sur le convoyeur.
bool isThereIncomingBox() {
  return digitalRead(PIN_light_barrier_outside) == 0;
}

// Pour le stockage, lorsqu'une pièce arrive en fin de course du convoyeur, 
// prête à être prise en charge par le pont du transstockeur.
bool boxHasReachedEndOfConveyor() {
  return digitalRead(PIN_light_barrier_inside) == 0;
}

// Pour le déstockage, lorsqu'une pièce sort du convoyeur.
bool boxHasGoneOut() {
  return digitalRead(PIN_light_barrier_outside) == 0;
}

// Capteur de fin de course vertical
bool hasTouchedSwitchVertical() {
  return digitalRead(PIN_switch_vertical) == 1;
}

// Capteur de fin de course horizontal
bool hasTouchedSwitchHorizontal() {
  return digitalRead(PIN_switch_horizontal) == 1;
}

// Capteur de fin de course intérieur du pont du transstockeur
bool hasTouchedCantileverFront() {
  return digitalRead(PIN_cantilever_front) == 1;
}

// Capteur de fin de course extérieur du pont du transstockeur
bool hasTouchedCantileverBack() {
  return digitalRead(PIN_cantilever_back) == 1;
}

Fonctions des actionneurs

De la même manière, définissons les fonctions que nous utiliserons pour actionner et arrêter les moteurs de l'entrepôt :

// ************************* Moteur M1 *************************
// Actionner le convoyeur en avant (M1)
void moveConveyorForward() {
  digitalWrite(M1_conveyor_FW, LOW);
  digitalWrite(M1_conveyor_BW, HIGH);
}

// Actionner le convoyeur en arrière (M1)
void moveConveyorBackward() {
  digitalWrite(M1_conveyor_FW, HIGH);
  digitalWrite(M1_conveyor_BW, LOW);
}

// Arrêter le convoyeur (M1)
void stopConveyor() {
  digitalWrite(M1_conveyor_FW, LOW);
  digitalWrite(M1_conveyor_BW, LOW);
}

// ************************* Moteur M2 *************************
// Actionner le transstockeur horizontalement vers le convoyeur (M2)
void moveArmTowardConveyor() {
  digitalWrite(M2_horiz_TR, LOW);
  digitalWrite(M2_horiz_TCB, HIGH);
}

// Actionner le transstockeur horizontalement vers les étagères (M2)
void moveArmTowardRack() {
  digitalWrite(M2_horiz_TR, HIGH);
  digitalWrite(M2_horiz_TCB, LOW);
}

// Arrêter le moteur horizontal du transstockeur (M2)
void stopM2Horizontal() {
  digitalWrite(M2_horiz_TR, LOW);
  digitalWrite(M2_horiz_TCB, LOW);
}

// ************************* Moteur M3 *************************
// Actionner le transstockeur vers le haut (M3)
void moveArmUp() {
  digitalWrite(M3_vert_UP, HIGH);
  digitalWrite(M3_vert_DOWN, LOW);
}

// Actionner le transstockeur vers le bas (M3)
void moveArmDown() {
  digitalWrite(M3_vert_DOWN, HIGH);
  digitalWrite(M3_vert_UP, LOW);
}

// Arrêter le moteur vertical du transstockeur (M3)
void stopVertical() {
  digitalWrite(M3_vert_DOWN, LOW);
  digitalWrite(M3_vert_UP, LOW);
}

// ************************* Moteur M4 *************************
// Actionner le pont du transstockeur vers l'avant (M4)
void moveCantileverForward() {
  digitalWrite(M4_cantilever_FW, HIGH);
  digitalWrite(M4_cantilever_BW, LOW);
}

// Actionner le pont du transstockeur vers l'arrière (M4)
void moveCantileverBackward() {
  digitalWrite(M4_cantilever_FW, LOW);
  digitalWrite(M4_cantilever_BW, HIGH);
}

// Arrêter le pont du transstockeur (M4)
void stopCantilever() {
  digitalWrite(M4_cantilever_FW, LOW);
  digitalWrite(M4_cantilever_BW, LOW);
}

Un premier test avec le pont du transstockeur

Maintenant que nous avons nos fonctions de base, il est désormais plus facile de faire un premier test : nous allons simplement actionner le pont du transstockeur pour faire des va-et-vient.

void setup() {
  // [n'oubliez pas ici tous les pinModes précédemment définis (voir plus haut)]
  moveCantileverForward();
}

void loop() {
  if(hasTouchedCantileverFront()) {
    moveCantileverBackward();
  } else if(hasTouchedCantileverBack()) {
    moveCantileverForward();
  }
}

et voila 🎉🎉🎉 !