Arduino Nano et arpRF ?

[maximeS]

Ca y est j'ai mon code fonctionnel. je me suis pas mal aidé de chatGPT, mais ça ne remplace pas les précieux conseil de Jacques

Je vous le partage si jamais ça peut intéresser ou inspirer quelqu'un :

Code : Tout sélectionner

#include <ArpRFLib.h>

byte NODEID = 1;
#define NETWORKID  212  // Adresse du réseau commune à toutes les machines
uint16_t band = RF12_868MHZ; // Fréquence de l'émetteur RF12

float frequency_setting = 868.00; // Entre 863,00 et 870,00 MHz

const int randomButtonPin = Arp0;  // Ajustez le numéro de broche selon votre configuration
const int flashButton = Arp1;
const int ledPin = Arp5;
int Val = 0;
bool var = 0;

unsigned long previousMillis = 0;
long intervalMin = 400;
long intervalMax = 1000;

void generateRandomValues();

void setup() {
  rf12_initialize(NODEID, band, NETWORKID, rf12_calcul_freq(frequency_setting));

  pinMode(randomButtonPin, INPUT);
  pinMode(flashButton, INPUT);
  pinMode(ledPin, OUTPUT);

  randomSeed(analogRead(Arp2));  // Initialisation de la graine pour la génération pseudo-aléatoire
}

void loop() {
  int randomButtonState = analogRead(randomButtonPin);

  // Si le bouton flash est enfoncé, la valeur est 1023, sinon 0 ou aléatoire
  if (analogRead(flashButton) > 300) {
      Val = 1023;
  } else {
      if (randomButtonState > 300) {
          unsigned long currentMillis = millis();
          if (currentMillis - previousMillis >= intervalMin) {
              generateRandomValues();
              previousMillis = currentMillis;
              intervalMin = random(intervalMin, intervalMax + 1);
          }
      } else {
          // Si le bouton aléatoire est en position OFF, la valeur est 0
          Val = 0;
      }
  }

  delay(10);

  digitalWrite(ledPin, var);
  var = !var; // Inverse l'état de var à chaque itération
  rf12_sendNow(0, &Val, sizeof(Val));
  delay(10);
}

void generateRandomValues() {
  Val = random(300, 1023);
  rf12_sendNow(0, &Val, sizeof(Val));
} 

Je suis curieux d'avoir un retour/avis dessus.

Encore merci pour la rapidité de réponses

[Jacques]

OK, super bravo !
Et ça fait quoi dans le spectacle ?

[maximeS]

Dans le spectacle il y aura une télévision dont l'écran est remplacé par un panneau couvert de ruban LED blanc avec un diffuseur devant. "L'écran" sera toujours orienté vers le lointain.
Le Wilulu pilote le ruban LED.
L'ArpsensorRF sera monté dans un panneau de contrôle qui se trouvera en coulisse. Un interrupteur à levier activera ou non une séquence aléatoire pour reproduire l'effet d'une TV allumé. et un bouton permet de faire des flashs manuels.

J'ai peaufiné le code pour améliorer l'effet TV. Je pense qu'il y aura encore des ajustements mais je suis plutôt content du résultat.

Voilà la nouvelle version du code :

Code : Tout sélectionner

#include <ArpRFLib.h>

byte NODEID = 1; // Adresse de léméteur RF dans le réseau
#define NETWORKID  212  // Adresse du réseau commune à toutes les machines
uint16_t band = RF12_868MHZ; // Fréquence de l'émetteur RF12

float frequency_setting = 868.00; // Entre 863,00 et 870,00 MHz

const int randomButton = Arp0;      // Déclaration de la pin pour l'interrupteur random
const int flashButton = Arp1;       // Déclaration de la pin pour le bouton flash
const int ledPin = Arp5;            // Déclaration de la pin pour la LED témoin
int Val;                            // Déclaration de la variable qui stock la valeur à envoyer
int newVal;                         // Déclaration d'une variable pour faire osciller a variable 'Val'
bool var = 0;                       // Déclaration de la variabble pour faire clignoter la LED témoin
unsigned long previousMillis = 0;   // Variable qui stock la durée entre deux valeurs aléatoires
unsigned long startTime;            // Déclaration d'une variable pour enregistrer le temps dans la boucle 'for'


//###############   FLASH   ###############
unsigned short ledFlashMax = 1023;    // VALEUR DU FLASH (ENTRE 0 ET 1023)


//###############   VALEURS ALEATOIRES   ###############
unsigned short ledMin = 300;    // VALEUR MINIMAL POUR LES VALEURS ALEATOIRES (ENTRE 0 ET 1023)
unsigned short ledMax = 500;    // VALEUR MAXIMAL POUR LES VALEURS ALEATOIRES (ENTRE 0 ET 1023)

unsigned long intervalMin = 4000;    // DUREE MINIMAL D'UNE BOUCLE D'OSCILLATIONS (en milliseconde)
unsigned long intervalMax = 10000;    // DUREE MAXIMAL D'UNE BOUCLE D'OSCILLATIONS (en milliseconde)


//###############   VALEURS OSCILLATIONS   ###############
short oscillationMin = -30;    // VALEUR MINIMAL POUR LES OSCILLATIONS
short oscillationMax = 30;     // VALEUR MAXIMAL POUR LES OSCILLATIONS

short numOscillationsMin = 30;       // NOMBRE MINIMAL D'OSCILLATIONS
short numOscillationsMax = 60;      // NOMBRE MAXIMAL D'OSCILLATIONS

unsigned long delayOscillationMin = 200;     // DELAIS MINIMAL ENTRE OSCILLATIONS (en milliseconde)
unsigned long delayOscillationMax = 800;    // DUREE MAXIMAL ENTRE OSCILLATIONS (en milliseconde)


void setup() {
  rf12_initialize(NODEID, band, NETWORKID, rf12_calcul_freq(frequency_setting));  // Initialisation de la liaison RF

  pinMode(randomButton, INPUT);   // Configuration le la pin du l'interrupteur
  pinMode(flashButton, INPUT);    // Configuration le la pin du boutton flash
  pinMode(ledPin, OUTPUT);        // Configuration le la pin de la LED témoin

  randomSeed(analogRead(Arp2));  // Initialisation de la graine pour la génération pseudo-aléatoire
}

void loop() {
 

  // Si le bouton flash est enfoncé, la valeur max du flash est envoyée, sinon lecture de l'interrupteur aléatoire
   if (analogRead(flashButton) > 300) {
    Val = ledFlashMax; // Envoie la valeur max du flash
  } else {
  if (analogRead(randomButton) > 300) { // Lecture de l'interrupteur
    unsigned long currentMillis = millis();
      int numOscillations = random(numOscillationsMin, numOscillationsMax); // Génère le nombre d'oscillation pour la prochaine boucle
    if (currentMillis - previousMillis >= intervalMin) {
      newVal = random(ledMin, ledMax);  // Génère une nouvelle valeur de 'Val' pour la boucle d'oscillation suivante
      startTime = currentMillis; // Enregistre le temps de début de la boucle
      for (int i = 0; i < numOscillations; ++i) {
                  // Si le bouton aléatoire est désactivé ou le bouton flash est pressé, interrompt la boucle 'for'
        if (analogRead(randomButton) <= 300 || analogRead(flashButton) > 300) {
          break;
        }
        Val = newVal + random(oscillationMin, oscillationMax);    // Défini 'Val' en ajoutant une valeur aléatoire à 'newVal' 
        rf12_sendNow(0, &Val, sizeof(Val));                       // Envoi la valeur 'Val'
        delay(random(delayOscillationMin, delayOscillationMax));  // Génère un delais avant la prochaine oscillation
        newVal=Val;                                               // Enregistre 'Val' comme 'newVal' pour la prochaine oscillation
        
          // Si le bouton aléatoire est désactivé ou le bouton flash est pressé, interrompt la boucle 'for'
        if (analogRead(randomButton) <= 300 || analogRead(flashButton) > 300) {
          break;
        }
      }
      previousMillis = currentMillis;
      intervalMin = random(intervalMin, intervalMax + 1);  // Génère la durée de la prochaine boucle d'oscillations
    }
  } else {
    // Si l'interrupteur est en position OFF, la valeur est 0
    Val = 0;
  }
  }
  delay(10);
  
  // Le bloc suivant envoie la variable 'Val' et fait clignoter la led témoin à chaque envoie
  digitalWrite(ledPin, var);
  var = !var; // Inverse l'état de var à chaque itération
  rf12_sendNow(0, &Val, sizeof(Val));
  delay(10);
}

[Jacques]

OK, je comprend.
D'ou l'utilisation de random().
Content que ça fonctionne, bravo.