Le forum LOCODUINO est consacré aux discussions ayant trait à l'utilisation de l'Arduino dans les automatismes et les animations pour le train miniature. Nous avons eu récemment quelques inscriptions de personnes ayant des projets plus généraux mais surtout inapplicables au train miniature. Si votre projet ou vos questions ne concernent pas le modélisme ferroviaire, ne vous inscrivez pas, vous perdriez votre temps et nous aussi.
Messages récents
#include <Arduino.h>
#include "pico/multicore.h"
#include "pico/util/queue.h"
volatile uint32_t duration = 0;
constexpr byte pinIn = 15; // Broche du TSOP
bool receiving = false;
uint8_t currentByte = 0;
int8_t bitIndex = 7;
// File pour les bits détectés
queue_t durationQueue;
enum DecodeState {
IDLE,
RECEIVING
};
DecodeState currentState = IDLE;
void handleIR() {
static uint32_t lastTime = 0;
uint32_t now = micros();
uint32_t duration = now - lastTime;
lastTime = now;
queue_try_add(&durationQueue, &duration);
}
void setup() {
Serial.begin(115200);
pinMode(pinIn, INPUT);
// Initialisation de la queue pour 16 durées
queue_init(&durationQueue, sizeof(duration), 16);
attachInterrupt(digitalPinToInterrupt(pinIn), handleIR, RISING);
}
void loop() {
uint32_t duration = 0;
if (queue_try_remove(&durationQueue, &duration)) {
switch (currentState) {
case IDLE:
if (duration > 1600 && duration < 2400) {
// Début de trame détecté
currentByte = 0;
bitIndex = 7;
currentState = RECEIVING;
}
break;
case RECEIVING:
if (duration >= 400 && duration <= 700) {
// Bit 1
currentByte |= (1 << bitIndex);
bitIndex--;
} else if (duration >= 800 && duration <= 1200) {
// Bit 0
currentByte &= ~(1 << bitIndex);
bitIndex--;
} else {
// Durée invalide
currentState = IDLE;
break;
}
if (bitIndex < 0) {
Serial.printf("Octet reçu : 0x%02X\n", currentByte);
currentState = IDLE;
}
break;
}
}
}
```cpp
#include <Arduino.h>
// Configuration du timer pour PWM IR
#define IR_USE_AVR_TIMER2 // Utilise Timer2 pour l'envoi (pin D3)
#define SEND_PWM_BY_TIMER // Active le mode PWM matériel
#include "IRTimer.hpp" // Part of Arduino-IRremote https://github.com/Arduino-IRremote/Arduino-IRremote.
#define IR_SEND_PIN 3 // Broche utilisée
constexpr uint8_t DATA = 0xAA; // Octet à envoyer
constexpr uint16_t BIT_DURATION = 500; // Durée d’un bit en µs
// Envoie un octet codé via LED IR
void sendManchesterByte(uint8_t value) {
for (int i = 7; i >= 0; i--) {
bool bit = (value >> i) & 0x01;
if (bit) {
// 1
disableSendPWMByTimer(); delayMicroseconds(BIT_DURATION / 2);
enableSendPWMByTimer(); delayMicroseconds(BIT_DURATION / 2);
} else {
// 0
disableSendPWMByTimer(); delayMicroseconds(BIT_DURATION );
enableSendPWMByTimer(); delayMicroseconds(BIT_DURATION );
}
}
// Fin de trame
disableSendPWMByTimer();
delayMicroseconds(BIT_DURATION * 2);
enableSendPWMByTimer();
delayMicroseconds(BIT_DURATION * 2);
}
void setup() {
pinMode(IR_SEND_PIN, OUTPUT);
timerConfigForSend(38); // Fréquence IR : 38 kHz
disableSendPWMByTimer(); // Démarre éteint
}
void loop() {
sendManchesterByte(DATA);
}
```
Concernant la modulation de l'IR, elle n'est nécessaire que pour une transmission à plus longue distance avec de la lumière parasite. Mais la distance émetteur-récepteur est ici de l'ordre du centimètre, et les deux sont face à face.
Par ailleurs, si on modulait l'IR, il faudrait bien entendu le démoduler ensuite au niveau du récepteur pour filtrer. Il existe justement des démodulateurs tout faits (pour télécommandes TV et autres) et j'en ai essayé. Mais on perd énormément en débit, pour des raisons autant théoriques (filtrage = retard) que pratiques.
const byte irPin = 2; // D2 (INT0) connecté à la sortie du TSOP4838
volatile uint64_t lastTime = 0;
volatile uint64_t pulseWidth = 0;
volatile byte receivedBytes[2]; // [0] = identifiant, [1] = checksum
volatile byte bitCount = 0;
volatile byte byteIndex = 0;
volatile bool receiving = false;
volatile bool newData = false;
void setup() {
Serial.begin(115200);
pinMode(irPin, INPUT);
attachInterrupt(digitalPinToInterrupt(irPin), handleIR, CHANGE);
}
void loop() {
if (newData) {
byte id = receivedBytes[0];
byte chk = receivedBytes[1];
if ((id ^ 0xA5) == chk) {
Serial.print("ID valide : 0x");
Serial.println(id, HEX);
} else {
Serial.print("Erreur checksum - ID: 0x");
Serial.print(id, HEX);
Serial.print(" / Checksum: 0x");
Serial.println(chk, HEX);
}
newData = false;
byteIndex = 0;
bitCount = 0;
}
}
// Interruption sur changement d’état du signal TSOP
void handleIR() {
uint64_t now = micros();
pulseWidth = now - lastTime;
lastTime = now;
// Détecter le bit de start : burst long (2.4 ms)
if (pulseWidth > 2000 && pulseWidth < 3000) {
receiving = true;
bitCount = 0;
byteIndex = 0;
receivedBytes[0] = 0;
receivedBytes[1] = 0;
return;
}
if (!receiving) return;
// Interprétation des bits en fonction des durées mesurées
if (pulseWidth >= 1000 && pulseWidth < 1300) {
// Bit 1 = 600 burst + 600 silence
receivedBytes[byteIndex] = (receivedBytes[byteIndex] << 1) | 1;
bitCount++;
} else if (pulseWidth >= 1600 && pulseWidth < 2000) {
// Bit 0 = 600 burst + 1600 silence
receivedBytes[byteIndex] = (receivedBytes[byteIndex] << 1);
bitCount++;
}
// Passage à l'octet suivant
if (bitCount == 8) {
bitCount = 0;
byteIndex++;
if (byteIndex >= 2) {
receiving = false;
newData = true;
}
}
}