Les programmes 4 à 7 ne sont pas encore terminés ou testés, et notamment celui sur les signaux SNCB.
J’ai mis à jour la documentation, elle correspond à l’état du logiciel. A suivre donc. J’attends la platine V3 pour reprendre des tests plus sérieux.
Merci de ton retour !
Oui je vais y réfléchir avec la V4 (module de freinage inclu) pour présenter un ensemble complet.
@+
bonjour Julie
vous utilisez une “const struct blink”
qui est la définition et puis juste après il y a l’initialisation des zones qui est faite par le compilateur
auriez-vous la gentillesse de me montrer une ou deux utilisations “BlinkOn” dans les lignes de votre programme svp
merci
Patrice
Bonjour Patrice,
Julie n’a pas dit qu’elle utilisait la structure blink. C’est à l’utilisateur de mettre une telle structure dans son propre code (en général dans le fichier principal .ino ou main.cpp) et il (l’utilisateur) pourra obtenir des effets particuliers, ici, de néon qui s’allume.
En quelque sorte, elle a déjà fait une partie de votre travail !
Il y a deux exemples dans un programme qu’elle donne un peu après dans ce 1° post 
// Tutoriel Neon
// (c) Julie Dumortier, 2021
// licence GPL
//
// Evolutions
// v0.1 première version sur plateforme de démonstration
// v0.2 polish pour un code plus lisible et prendre en compte quelques remarques (Thias, Stéphane)
//
// branchez une LED entre GND et D3
// et appréciez l'allumage du néon à la mise sous tension de l'Arduino
//
// pensez à protéger votre led avec une résistance
// utilisez le calculateur de résistance svp https://www.digikey.fr/fr/resources/conversion-calculators/conversion-calculator-led-series-resistor
// pas plus de 40 mA par sortie, pas plus de 200 mA au total, au risque de griller une sortie et/ou l'Arduino Nano
//
// l'intensité est réglable sur les sorties D3, D5, D6, D9, D10 et D11 (cf pwmPin)
//
// Retrouvez ce tutoriel sur le lien :https://forum.3rails.fr/t/une-debutante-dans-le-decor-ep13-que-la-lumiere-jaillisse/20889
#include <Arduino.h>
// mettre à 1 pour un debug dans la console série, 2 pour full debug
const int debug = 1;
// configuration sortie D3 pour connecter la led
int ledPin = 3;
// l'intensité maximum de chaque sortie PWM
const int PWM_FOR_LED = 12;
// ON ou OFF ou autre valeur (fading)
const int LIGHT_ON = PWM_FOR_LED;
const int LIGHT_FAD2 = PWM_FOR_LED/2;
const int LIGHT_FAD4 = PWM_FOR_LED/4;
const int LIGHT_OFF = 0;
// blink
const struct blink {
int duration;
int intensity;
} blinkOn[] = {
10, LIGHT_ON, 20, LIGHT_OFF,
20, LIGHT_ON, 240, LIGHT_OFF,
20, LIGHT_ON, 40, LIGHT_OFF,
20, LIGHT_ON, 100, LIGHT_OFF,
20, LIGHT_ON, 20, LIGHT_OFF,
20, LIGHT_ON, 260, LIGHT_OFF,
80, LIGHT_ON, 20, LIGHT_OFF,
240, LIGHT_ON, 60, LIGHT_OFF,
160, LIGHT_ON, 20, LIGHT_OFF,
240, LIGHT_ON, 20, LIGHT_OFF,
1000, LIGHT_FAD2, 20, LIGHT_OFF,
20, LIGHT_ON, 40, LIGHT_OFF,
100, LIGHT_ON, 20, LIGHT_OFF,
2740, LIGHT_ON, 340, LIGHT_FAD4,
860, LIGHT_FAD2, 20, LIGHT_OFF,
1400, LIGHT_ON, 20, LIGHT_OFF,
60, LIGHT_ON, 20, LIGHT_OFF
};
// nombre de transitions
const int maxStateBlink = sizeof(blinkOn)/sizeof(blink);
// etat de clignotement (position dans le tableau précédent)
int gStateBlink = 0;
// stateLight
const int state_OFF = 0;
const int state_ON = 1;
const int state_PWRUP = 2;
int gStateRunning = state_OFF;
// delay avant une transition de la machine à état
int gDelay = 0;
// ---------------------------------------------------------------------
// --- setup()
// ---------------------------------------------------------------------
void setup() {
// code de démarrage executé une seule fois à la mise sous tension de la carte
// ouvre le port série (console de l'outil) avec la vitesse 57600 bauds
// attention que le paramètre sur la console soit bien 57600 !
Serial.begin(57600);
// Ports digitaux programmables (PWM) : D3, D5, D6, D9, D10 et D11
pinMode(ledPin,OUTPUT);
// Annonce la version
Serial.println("Neon v02 20211029 - (c) Julie Dumortier - Licence GPL");
}
// ---------------------------------------------------------------------
// ligthOff()
//
// éteint le néon
// ---------------------------------------------------------------------
void lightOff()
{
if (debug) Serial.println("state_OFF");
// eteint la led (au cas où)
analogWrite(ledPin,0);
// passe en mode démarrage
gStateRunning = state_PWRUP;
if (debug) Serial.println("stateRunning <-- PWRUP");
// prépare la séquence
gStateBlink = 0;
gDelay = 0;
}
// ---------------------------------------------------------------------
// ligthOn()
//
// allume le néon en permanent
// ---------------------------------------------------------------------
void lightOn()
{
int alea;
analogWrite(ledPin,PWM_FOR_LED);
// fait un tirage aléatoire et refait un glitch à partir de la séquence 22
// ajuster la valeur random en fonction de la fréquence d'apparition (en ms)
alea = random(0,10000);
if (alea < 1) {
if (debug) Serial.print("Glitch alea:");
if (debug) Serial.println(alea);
gStateRunning = state_PWRUP;
gStateBlink = 22;
gDelay = 0;
}
}
// ---------------------------------------------------------------------
// powerUp()
//
// gère une séquence d'allumage du néon
// ---------------------------------------------------------------------
void powerUp()
{
int lightOn;
// si le délai est échu, démarre une nouvelle séquence
if (gDelay<=0)
{
if (debug) {
Serial.print("state_PWRUP - blink sequence ");
Serial.print(gStateBlink);
}
lightOn = blinkOn[gStateBlink].intensity;
analogWrite(ledPin,lightOn);
if (debug) {
Serial.print(" intensity: ");
Serial.print(lightOn);
Serial.print(" delay:");
}
gDelay = blinkOn[gStateBlink].duration;
if (debug) Serial.println(gDelay);
gStateBlink += 1;
if (gStateBlink>=maxStateBlink) {
gStateBlink = 0;
gStateRunning = state_ON;
if (debug) Serial.println("state_ON");
}
}
if (debug>1) Serial.print(".");
gDelay = gDelay - 1;
}
// ---------------------------------------------------------------------
// loop()
//
// L'automate néon
// ---------------------------------------------------------------------
void loop() {
switch (gStateRunning) {
case state_OFF : lightOff(); break;
case state_ON : lightOn(); break;
case state_PWRUP : powerUp(); break;
} // end switch
delay(1);
}
Ligne 158 :
lightOn = blinkOn[gStateBlink].intensity;
et ligne 168
gDelay = blinkOn[gStateBlink].duration;
Christophe