-Largeur → 2M
-Longeur → 3M
-Hauteur → 70CM

-Gâteau :
carton plume de
120mm de diamètre et de
20mm d’épaisseur et perce au centre d’un
trou de 20mm
Pile de 3 couche pour faire un gâteau complet

-Cerise → balles de Nerf 22,5mm

-Panier → 450 x 222 x 430 (LES CERISES SONT DEPOSER A UNE ALTITUDE DE 30CM)

Taille des zones : 45cm de coté

Longeur total des cerises : : 23Cm de long

Bonus = 20 – [Score du match – Score estimé]

Ces missions seront : • Faire des gâteaux, • Mettre les cerises sur les gâteaux, • Ranger les cerises restantes dans le panier, • Mettre les roues dans le plat, à la fin du service, • Se déguiser pour faire la fête, • Calculer l’addition.

/!\ ON STOCK !!!!!! /!\

- Pince.
→ On prend une couche avant de la basculée dans le “stock” à l'arrière.
Une fois les trois couches assemblées on les lâche sur l'assiette.

- ?? Comment déposer les cerises sur le gâteau ??
- Grace a un tube qui stock les cerises dedans et les dépose dans le trou des gâteaux

5 moteurs (OK)
4 roues (OK)
4 servo moteur plus support (OK)
2 Joystick (OK)
2 l298N (OK)
Un lot 20 Interrupteurs Switch (pas encore trouver, regarder en atelier)
1 Kit batterie LiPo plus housse (OK)

Après plusieurs test de différentes géométrie de grappin, nous avons opté pour un système de glissière, ce qui réduit considérablement la hauteur.

Joystick pour la pince :

Interrupteur Switch pour la direction :

1: FAIRE DES GÂTEAUX
• 1 point par étage dans le gâteau
• 3 points supplémentaires si le gâteau respecte la recette légendaire

2: METTRE LA CERISE SUR LE GÂTEAU
• 4 points pour chaque cerise posée sur un gâteau valide;

3: METTRE LES CERISES DANS LE PANIER
• 5 points si l’équipe dépose un panier pendant le temps de préparation;
• 1 point par cerise dans le panier
• 5 points supplémentaires si le comptage est juste et supérieur à 0

4: METTRE LES ROUES DANS LE PLAT
• 15 points si le robot principal de l’équipe est dans sa zone;

5: FUNNY ACTION
• 5 points si la funny action est réalisée;

Plusieurs actions durant le match pourront entraîner des pénalités.
Les actions suivantes entraîneront un avertissement ou une perte de point sur le score final si un avertissement a déjà été émis pour l’équipe (la règle de l’avertissement n’est valable que pour les séries) :

• perte de pièce ou d’élément d’un robot sur l’aire de jeu : perte de 20 points.
• dégradation de la table ou d’un élément de jeu : perte de 30 points.
• système d’évitement non fonctionnel : perte de 30 points.
• tirer sur le câble pour faire bouger le robot : perte de 30 points.
• faux départ : perte de 50 points.
• le robot continue de bouger à la fin du temps imparti : perte de 50 points.
• temps de préparation excessif : perte de 50 points.
• comportement non fair-play : perte de 50 à 100 points.
• sur décisions de l’arbitrage : perte de 50 à 100 points.
• sur décisions de l’organisation : perte de 50 à 100 points.

Règlement PDF:

ICI

Présentation vidéo du concours robotix's 2023 :

https://www.youtube.com/watch?v=urzpqwvCV-8

Pour réaliser notre bras robotique, nous utilisons 3 servomoteurs digitaux SCS15 (épaule, coude, poignet) ainsi que 2 FS5103B pour l'articulation de la base et la main.
Le but est, d'une part, programmer la manipulation du bras à l'aide de Joysticks et, d'autre part, automatiser le dépôt des parties de gâteaux dans le stock à l'aide d'un bouton pression.

- Dimensions: 40 x 20 x 40,5 mm
- Poids: 56 g
- Pignons: métal (rapport 275:1)
- BUS Interface: niveau TTL
- Position capteur (Résolution): Potentimètre (215°/1024)
- Angle: 200° (mode servo standard)
- Alimentation: 6 V à 8,4 V
- Couple (Kg.cm): 15 → 6V - 16,5 → 7,4V - 17 → 8,4V
- Courant: 1,5A @ 7,4V
- Vitesse (rpm): 55 → 6V - 65 → 7,4V - 73 → 8,4V
- 2 connecteurs 3 points: Pour chaînage et raccordement.

/*
 * Sélectionne position et vitesse de déplacement d'un servomoteur
 * SERVO.WritePos(No_Servo,Position,Vitesse)
 * Permet de lire la température d'un servomoteur
 * SERVO.ReadTemper(No_Servo) 
 * Permet de lire la position d'un servomoteur
 * SERVO.ReadPos(No_Servo) 
 * Permet de lire la tension d'un servomoteur
 * SERVO.ReadVoltage(No_Servo) 
*/
// On importe la lib' SCServo.h 
#include <SCServo.h>
SCServo SERVO;
// On déclare la variable pour lire la Pin du potar
int pinPot = A0;
// On déclare la variable pour stocker les valeur du potar
int valPot;
 
void setup(){
  Serial1.begin(1000000);
  SERVO.pSerial = &Serial1;
  delay(500);
  SERVO.EnableTorque(1, 1);
  SERVO.EnableTorque(2, 1);
 
  pinMode(pinPot, INPUT);
}
 
void loop(){
  valPot = analogRead(pinPot);
  Serial.println(valPot);
 
  SERVO.WritePos(1, valPot, 1000);
  SERVO.WritePos(2, valPot, 1000);
  delay(100);
};

const int boutonPin = 2; // Numéro de la broche du bouton
int compteur = 0; // Initialisation du compteur
bool boutonEtat = HIGH; // Initialisation de l'état du bouton
bool dernierEtat = HIGH; // Initialisation du dernier état du bouton
 
void setup() {
  pinMode(boutonPin, INPUT_PULLUP); // Activation de la résistance de tirage vers le haut interne du microcontrôleur
  Serial.begin(9600); // Initialisation de la communication série
}
 
void loop() {
  boutonEtat = digitalRead(boutonPin); // Lecture de l'état actuel du bouton
 
  if (boutonEtat == LOW && dernierEtat == HIGH) { // Si le bouton vient d'être pressé
    compteur++; // Incrémentation du compteur
    Serial.println(compteur); // Affichage du compteur sur le moniteur série
  }
  dernierEtat = boutonEtat; // Sauvegarde de l'état actuel du bouton pour la prochaine boucle
  delay(50); // Délai pour éviter les rebonds
}

/*
   axe joystick: diriger de g à d le bras
   bouton joystick: baisser, serrer machoire, lever
   bouton joystick(2x ou plus):désserer machoire,baisser,serrer,lever
  autre bouton: 180,desserer,-180
 
*/
 
/*
   La pince est en position fermée
   Quand appuis sur bouton, la pince s'ouvre
   le bras se baise
   la pince se ferme
   le bras se relève
 
   30 degrés = milieux bras avant
*/
 
//servo Qui tourne pour la cerise (deposer) == pin 8 ok
//Servo qui tourne le bras a cerise == pin 7
//servo gauche des portes arrières == pin 4
//servo droite des portes arrières == pin 3
 
#include <SCServo.h>
#include <Servo.h>
//--------Servo pince et rotatif_base-------
Servo servoPince;
Servo servoBase; // = coude
Servo servoTourneCerise;
Servo servoCoudeCerise;
//--------------PORTES-----------------
//-----------------------------2 Portes du devants-----------------------
const byte SERVO_A_ANGLE_ZERO_D = 0;
const byte SERVO_A_ANGLE_MIN_D = 1;
const byte SERVO_A_ANGLE_MAX_D = 2;
 
const byte SERVO_A_ANGLE_ZERO_G = 3;
const byte SERVO_A_ANGLE_MIN_G = 4;
const byte SERVO_A_ANGLE_MAX_G = 5;
 
const byte SERVO_EN_MOUVEMENT_VERS_ANGLE_ZERO = 6;
const byte SERVO_EN_MOUVEMENT_VERS_ANGLE_MIN = 7;
const byte SERVO_EN_MOUVEMENT_VERS_ANGLE_MAX = 8;
 
const int angleZero = 0;
 
const int angleMin_G = 90;
const int angleMax_G = 180;
 
const int angleMin_D = 90;
const int angleMax_D = 180;
 
int vitesse = 100;
int angle_G = angleMin_G;
int angle_D = angleMin_D;
 
byte etatServo_G = SERVO_A_ANGLE_MIN_G;
byte etatServo_D = SERVO_A_ANGLE_MIN_D;
//-------------------------------------
Servo monServo_G;
Servo monServo_D;
//----------Servo pince----------
SCServo SERVO;
byte ID[2];
//-------------------------------bouton qui fait : s'abaisser le bras, fermer la pince et remonter le bras
const int pinBouton_bras = A1; /* le bouton est connecté à la broche A1*/
const boolean PRESSE = true;
const boolean RELACHE = false;
boolean etatBouton = RELACHE;
const byte AUCUN_EVENEMENT = 0;
const byte EVENEMENT_PRESSE = 1;
const byte EVENEMENT_RELACHE = 2;
int pinLed = 7;
int delais = 500;         //vitesse du bras flexion/extension
//-------------------------------bouton qui fait : tourner le bars vers l'arrière, baisser le bras,ouvrir la pince,tourner vers l'avant, fermer la pince
const int pinBouton_bras2 = A0; /* le bouton est connecté à la broche A1 */
const boolean PRESSE2 = true;   //btn du joystick
const boolean RELACHE2 = false;
boolean etatBouton2 = RELACHE2;
const byte AUCUN_EVENEMENT2 = 0;
const byte EVENEMENT_PRESSE2 = 1;
const byte EVENEMENT_RELACHE2 = 2;
int delais2 = 200;
//-------------------------------bouton qui fait tourner la roue et le bras a cerise
const int pinBouton_bras3 = A2; //bouton qui fait tourner la roue pour les cerises
const boolean PRESSE3 = true;
const boolean RELACHE3 = false;
boolean etatBouton3 = RELACHE3;
byte AUCUN_EVENEMENT3 = 0;
byte EVENEMENT_PRESSE3 = 1;
byte EVENEMENT_RELACHE3 = 2;
//-------------------------------bouton fait ouvrir les portes
const int pinBouton_bras4 = A3; //bouton qui fait ouvrir les portes arrières
const boolean PRESSE4 = true;
const boolean RELACHE4 = false;
boolean etatBouton4 = RELACHE4;
byte AUCUN_EVENEMENT4 = 0;
byte EVENEMENT_PRESSE4 = 1;
byte EVENEMENT_RELACHE4 = 2;
 
//---------Joystick--------------
int axeX = A5;
int valX;
 
/* Fonctions de gestion du poussoir */
boolean lirePoussoir() {
  boolean resultat = RELACHE;
  if (analogRead(pinBouton_bras) > 512) { //pinBouton bras
    resultat = PRESSE;
  }
  return resultat;
}
/* Fonctions de gestion du poussoir n2 */
boolean lirePoussoir2() {
  boolean resultat2 = RELACHE2;
  if (digitalRead(pinBouton_bras2) == 0) {
    resultat2 = PRESSE2;
    //  Serial.print("btn  joystick pressé");
  }
  return resultat2;
}
 
boolean lirePoussoir3() {  // BTN_POSE_SERISE A2
  boolean resultat3 = RELACHE3;
  if (digitalRead(pinBouton_bras3) == 0) {
    resultat3 = PRESSE3;
    //Serial.print("btn  cerise pressé");
  }
  return resultat3;
}
//---------------------
boolean lirePoussoir4() {  //Ouvre portes arrières
  boolean resultat4 = RELACHE4;
  if (digitalRead(pinBouton_bras4) == 0) {
    resultat4 = PRESSE4;
    //Serial.print("btn  porte pressé");
  }
  return resultat4;
}
//---------------------
byte lireEvenement() {
  byte evenement;
  boolean nouvelEtat = lirePoussoir();
  Serial.println(nouvelEtat);
  if (nouvelEtat == etatBouton)
    evenement = AUCUN_EVENEMENT;
  if (nouvelEtat == PRESSE && etatBouton == RELACHE)
    evenement = EVENEMENT_PRESSE;
  if (nouvelEtat == RELACHE && etatBouton == PRESSE)
    evenement = EVENEMENT_RELACHE;
  etatBouton = nouvelEtat;
  return evenement;
}
//----------------------
byte lireEvenement2() {  //btn joystick
  byte evenement2;
  boolean nouvelEtat2 = lirePoussoir2();
  if (nouvelEtat2 == etatBouton2)
    evenement2 = AUCUN_EVENEMENT2;
  if (nouvelEtat2 == PRESSE2 && etatBouton2 == RELACHE2)
    evenement2 = EVENEMENT_PRESSE2;
  if (nouvelEtat2 == RELACHE2 && etatBouton2 == PRESSE2)
    evenement2 = EVENEMENT_RELACHE2;
  etatBouton2 = nouvelEtat2;
  return evenement2;
}
//-----------------------
byte lireEvenement3() {  //btn cerise
  byte evenement3;
  boolean nouvelEtat3 = lirePoussoir3();
  if (nouvelEtat3 == etatBouton3)
    evenement3 = AUCUN_EVENEMENT3;
  if (nouvelEtat3 == PRESSE3 && etatBouton3 == RELACHE3)
    evenement3 = EVENEMENT_PRESSE3;
  if (nouvelEtat3 == RELACHE3 && etatBouton3 == PRESSE3)
    evenement3 = EVENEMENT_RELACHE3;
  etatBouton3 = nouvelEtat3;
  return evenement3;
}
//------------------------
byte lireEvenement4() {  //btn portes arrières
  byte evenement4;
  boolean nouvelEtat4 = lirePoussoir4();
  if (nouvelEtat4 == etatBouton4)
    evenement4 = AUCUN_EVENEMENT4;
  if (nouvelEtat4 == PRESSE4 && etatBouton4 == RELACHE4)
    evenement4 = EVENEMENT_PRESSE4;
  if (nouvelEtat4 == RELACHE4 && etatBouton4 == PRESSE4)
    evenement4 = EVENEMENT_RELACHE4;
  etatBouton4 = nouvelEtat4;
  return evenement4;
}
//--------------------------------------------------------------------
void setup() {
  Serial.begin(1000000);
  SERVO.pSerial = &Serial;
  delay(500);
  pinMode(pinLed, OUTPUT);
  pinMode(pinBouton_bras, INPUT_PULLUP);
  pinMode(pinBouton_bras2, INPUT_PULLUP);
  pinMode(pinBouton_bras3, INPUT_PULLUP);
  pinMode(pinBouton_bras4, INPUT_PULLUP);
  //--- SERVOMOTEURS ---//
  servoPince.attach(9);                           // Pince bras
  servoBase.attach(6);                            // Rotation du bras sur 180°
 
  servoPince.write(20);                           // Pince fermée
  servoBase.write(30);                            // 30
  //servoBase.write(0);
  //--- SCS SERVO ---//
  SERVO.EnableTorque(1, 1);
  SERVO.EnableTorque(2, 1);
  ID[0] = 1;
  ID[1] = 2;
  //--- JOYSTICK ---//
  pinMode(axeX, INPUT);
 
  servoTourneCerise.attach(8);                   //servo qui fait tourner la roue pour lacher la cerise
  servoCoudeCerise.attach(7); 
  servoCoudeCerise.write(160);
 
  monServo_G.attach(4);                          // PORTE GAUCHE 180
  monServo_D.attach(3);                          // PORTE DROITE 0
//  monServo_G.write(180);
//  monServo_D.write(0);
 
  SERVO.SyncWritePos(1, 2, 400 , delais); //ancienement 580
  delay(100);
}
 
void loop() {
  /* actualisation de l'angle du servo */
  int del = 200;
  monServo_G.write(angle_G);
  monServo_D.write(angle_D);
 
  angle_G = angle_G + vitesse;
  angle_D = angle_D + vitesse;
  /**********************************************/
  /**********************************************/
  if (angle_G > angleMax_G) {
    angle_G = angleMax_G;                        //-------
    Serial.print(" ANGLE MAX GAUCHE : ");
    Serial.println(angle_G);
    vitesse = 0;
    etatServo_G = SERVO_A_ANGLE_MAX_G;
  }
  else if (angle_G < angleMin_D) {
    angle_G = angleMin_D + 10;                    //------- ON BOUGE PLUS +10 !!!
    Serial.print(" ANGLE MIN GAUCHE : ");
    Serial.println(angle_G);
    vitesse = 0;
    etatServo_G = SERVO_A_ANGLE_MIN_G;
    //Serial.println("---------------------------");
  }
  /**********************************************/
  /**********************************************/
  if (angle_D > angleMin_D) {
    angle_D = angleMin_D - angleMin_D;
    Serial.print(" ANGLE MAX DROIT : ");
    Serial.println(angle_D);
    vitesse = 0;
    etatServo_D = SERVO_A_ANGLE_MIN_D;
  }
  else if (angle_D < angleZero) {
    angle_D = angleZero + angleMin_D ;   //------- ON BOUGE PLUS -70 !!! eh bah tant pis c'est bougé eheh
    Serial.print(" ANGLE MAX DROIT : ");
    Serial.println(angle_D);
    vitesse = 0;
    etatServo_D = SERVO_A_ANGLE_ZERO_D;
    //Serial.println("---------------------------");
  }
  /**********************************************/
  /**********************************************/
 
  del = 1000;
  byte evenement = lireEvenement();
  byte evenement2 = lireEvenement2();
  byte evenement3 = lireEvenement3();
 
  if (evenement == EVENEMENT_PRESSE) {      // Descendre et prendre
    del = (500);
    //Serial.println("-1-");
    digitalWrite(pinLed, HIGH);
    //servoBase.write(25); < bah non si tu laisses ca le joystick sert plus a rien petit idio
    delay(del);
    servoPince.write(90);                   // Pince ouverte
    delay(del);
    SERVO.SyncWritePos(1, 2, 900, 800);  //bras descent
    delay(800);
    servoPince.write(0);                    // Pince fermée (7)
    delay(del);
    SERVO.SyncWritePos(1, 2, 840, delais);
    delay(200);
    //Serial.println();
 
  }
  else {
    //Serial.println("0");
    //digitalWrite(pinLed, LOW);
    //servoPince.write(90);                  // Pince fermée
    //servoBase.write(30);                  //30
  }
 
  if (evenement2 == EVENEMENT_PRESSE2) {    //relache le palais en arrière
    Serial.println("Btn joystic pressé");
    digitalWrite(pinLed, HIGH);
 
    SERVO.SyncWritePos(1, 2, 700, delais);
    delay(2000);
    servoBase.write(360);
    delay(1000);
    SERVO.SyncWritePos(1, 2, 830, 2500);
    delay(2500);
    servoPince.write(110);
    delay(1000);
    servoPince.write(30);
    delay(500); 
    SERVO.SyncWritePos(1, 2, 700, 1000);
    delay(1000);
    SERVO.SyncWritePos(1, 2, 840, 2000);
    delay(500);
    servoBase.write(30);
    delay(2000);
//    delay(1000);
  }
  else {
    digitalWrite(pinLed, LOW);
    //servoPince.write(0);                // Pince fermée
    //servoBase.write(30);                //30
  }
 
  if (evenement3 == EVENEMENT_PRESSE3) {  //tourne la roue et le bras ceruises
    Serial.print("evènement 3 : ");
    Serial.println(evenement3);
    delay(50);
    Serial.println("btn cerise pressé");
    servoTourneCerise.detach();
    servoCoudeCerise.attach(7);
    delay(20);
    servoCoudeCerise.write(100);             // Angle pour poser la cerise
    delay(800);
    servoTourneCerise.attach(8);
    servoTourneCerise.write(80);
    delay(450);
 
    servoTourneCerise.write(100);
    delay(350);
 
//    for(int i=0; i < 130;i++){
//      servoCoudeCerise.write(i);
//      delay(15);
//    }
 
//    for(int i=0; i < 2;i++){
//      servoTourneCerise.write(i);
//      delay(15);
//    }
 
//    servoTourneCerise.write(10);         // d'ailleurs c'est pas le write qui change le temps c le dalis
//    delay(5);                           // temps PARFAIT, je mange selui qui changera ça
    servoTourneCerise.detach();            // et bah j'ai changé tu vas faire quoi mainent ??
    delay(50);
    servoCoudeCerise.write(160);           // En "Magasin" 
    delay(1000);
  }
  else {
    servoTourneCerise.detach();
    servoCoudeCerise.detach();
//    delay(10);
//    servoTourneCerise.write(90);
//    servoCoudeCerise.write(160);
  }
  //--------------------------------
  byte evenement4 = lireEvenement4();
  Serial.println(evenement4);
  if (evenement4 == EVENEMENT_PRESSE4) {
    switch (etatServo_G) {
      case SERVO_A_ANGLE_MIN_G:
      case SERVO_EN_MOUVEMENT_VERS_ANGLE_MIN:
        vitesse =  100;
        etatServo_G = SERVO_EN_MOUVEMENT_VERS_ANGLE_MAX;
        break;
      case SERVO_A_ANGLE_MAX_G:
      case SERVO_EN_MOUVEMENT_VERS_ANGLE_MAX:
        vitesse = -100;
        etatServo_G = SERVO_EN_MOUVEMENT_VERS_ANGLE_MIN;
        break;
    }
 
    switch (etatServo_D) {
      case SERVO_A_ANGLE_ZERO_D:
      case SERVO_EN_MOUVEMENT_VERS_ANGLE_ZERO:
        vitesse =  100;
        etatServo_D = SERVO_EN_MOUVEMENT_VERS_ANGLE_MIN;
        break;
      case SERVO_A_ANGLE_MIN_D:
      case SERVO_EN_MOUVEMENT_VERS_ANGLE_MIN:
        vitesse = -100;
        etatServo_D = SERVO_EN_MOUVEMENT_VERS_ANGLE_ZERO;
        break;
    }
  }
  delay(100);
  joystic();
}/*** LOOP ***/
//-----joystick--------------
void joystic() {
  valX = analogRead(axeX);
  int mapX = map(valX, 0, 1023, 40, 20);  //joystick base
  //  Serial.print("val joystick : ");
  //  Serial.println(mapX);
  //  Serial.println(valX);
  //servoBase.write(mapX);
  //dead zone
  if (mapX <= -4) {
    servoBase.write(mapX);
    delay(10);
  }
  else if (mapX >= 4) {
    servoBase.write(mapX);
    delay(10);
  }
  else {
    servoBase.write(0);
    delay(10);
  }
}
/**
 
       &
      .-"`"-.
     /       \
     |   __  _|
     |  /  \/ \
    WW  \_o/_o/          |---------------|
    (        _)       -- | RIP le !@#&%  |
     |   .----\     --   |---------------|
     ;  | '----'  --
      \__'--;`
      |___/\|
 
**/      

Le robot devrait gagné en vitesse.
Gérer les vitesses
Corriger la roulette pour les cerises.
Revoir le code pour optimisation (en fonctions).
Changer le servomoteur des cerises 180.
Faire un double demi cercle pour les gâteaux
Plus de LED
Ajouter Connecteur sandwich.
Changer le système d’accrochage du câble.
Prendre la chariot.

Les colsons ! Ils bloquent dans la perche.

Pour le 25/04 → Refaire la base en CNC

Pour le /05 → Cable managment et ajouter connecteurs

Pour le /05 → Replacer les pinces

Pour le /05 → Alimentation (plus de PowerBank)

Pour le /05 →

       &
    .-"`"-.
   /       \
   |   __  _|
   |  /  \/ \
  WW  \_o/_o/          |---------------|
  (        _)       -- | RIP le !@#&%  |
   |   .----\     --   |---------------|
   ;  | '----'  --
    \__'--;`
    |___/\|