I. Partie « Hardware »

1. Communication sans-fil

a. nRF24L01+

le circuit

On va utiliser la bibliothèque NRF24 de TMRh20 disponible ici.
Le module nRF24L01+ utilise le protocole de communication SPI, il a donc un branchement particulier que la documentation de la bibliothèque décrit en bas de cette page.

Voici le schéma de branchement (les broches CS et CE du module peuvent être connectées ailleurs sur l’Arduino à condition de l’indiquer dans le code…) :

le code

Ce code permet simplement de voir si la communication entre deux Arduino fonctionne.
En connectant le pin 4 au GND on informe l’Arduino qu’il s’agit du récepteur, sinon il s’agit de l’émetteur

II. Partie « software »

1. Processing

I. Gestion des sprites

[youtube]https://youtu.be/QL-VrBpdeWo[/youtube]

J’ai bidouillé un code existant (à voir ici) qui va loader successivement des fichiers de type « Marche_00.png » jusqu’à « Marche_08.png » et les jouer sur place.

J’ai cleané un peu le code existant et rajouté un test de collision avec les bords extérieurs de mon écran que j’ai appelé collisionBord (qui est une valeur booléenne, soit « True », soit « False »). Si on change la largeur de l’écran, le lemming réagit bien aux bords nouvellement définis. Rajout également, à l’initialisation il tombe.

Animation marcheD, marcheG, tombe;

float xPos;   // La position en abscisse du sprite
float yPos;   // La position en ordonnée du sprite
float solPos; 
int speedPix;   // La vitesse de déplacement du sprite 

boolean collisionBord = false; // Test la collision avec le bord de l'écran 
boolean collisionSol = false; // Test la collision avec le sol 

void setup() {
  size(100, 400); // On défini la taille de l'écran
  frameRate(12); // images par secondes, comme au cinéma

  xPos = (width/2)-12; // On centre la position x par rapport à la largeir de l'écran et du sprite
  yPos = 0;
  solPos = height-50; // Position du sol en y
  speedPix = 4; 
  
  marcheD = new Animation("MarcheD_", 8);  // le 8 représente le nombre d'images à boucler.
  marcheG = new Animation("MarcheG_", 8);
  tombe = new Animation("Tombe_", 4);
}

void draw() { 

    background(0, 0, 0);   // dans cette boucle on efface l'écran (ici noir) avant de redessiner
    if (yPos < solPos) {
    tombe.display(xPos, yPos);yPos = yPos+8;}
    
    else {
    
    if (xPos > width-24) {
    collisionBord = true;background(100, 0, 0);
    } // Si mon sprite atteind le bord droit de l'écran ( moins la largeur du sprite de 24px) alors il y a collision
    
    if (xPos < 0) {
    collisionBord = false;background(100, 0, 0);
    } // Si mon sprite atteind le bord gauche de l'écran (sous 0) alors il n'y a pas de collision (une façon de boucler)
    
    if (!collisionBord) { 
    marcheD.display(xPos, yPos);xPos = xPos+speedPix;
    } // Si il n'y a pas de collision avec le bord droit de l'écran, alors je joue l'animation de marche vers la droite, en déplaçant de tant de pixels vers la droite
    
    if (collisionBord) {
    marcheG.display(xPos, yPos);xPos = xPos-speedPix;
    } // Si il Y A EU une collision avec le bord droit de l'écran, alors je joue l'animation de marche vers la gauche, en déplaçant de tant de pixels vers la gauche
    }
}


// Class pour l'animation des fichiers .png 

class Animation {
  PImage[] images;
  int imageCount;
  int frame;
  
  Animation(String imagePrefix, int count) {
    imageCount = count;
    images = new PImage[imageCount];

    for (int i = 0; i < imageCount; i++) {
      String filename = imagePrefix + nf(i, 2) + ".png"; // nf() sert à intégrer 1 zero avant le compteur d'image pour passer de "MarcheD_09.png" à "MarcheD_10.png" et non "MarcheD_010.png"
      images[i] = loadImage(filename);
    }
  }

void display(float xPos, float yPos) {
frame = (frame+1) % imageCount;
image(images[frame], xPos, yPos);
}  

}

Enregistrer