Maintenant notre relais F5ZNG est doté de sa signalisation/identification en graphie.
Rien de plus simple qu’un Arduino et quelques relais pour tout gérer ainsi que les commutations.

Dans le cas présent, c’est un Arduino nano avec un « sheild » (platine de raccordement) et une platine à 4 relais (et un convertisseur de tension avec une petite platine pour régler le niveau audio injecté du K),

Et si cela vous parait hors de portée, sachez que la programmation Arduino est enseignée dans les collèges pour des jeunes de 11 à 14ans !

Rien de plus simple, pour commencer, que de vous faire la main avec l’application libre de droit MBlock.

Et d’accéder très vite à la programmation en Arduino,

puis franchir le cap et passer directement sous l’IDE (c’est le nom de l’outils de développement et de programmation Arduino).

Bref. Rien qui ne soit hors de votre portée. ! Il n’est pas besoin d’etre ingénieur pour programmer un Arduino, puisque les outils pédagogiques sont là et que de principe, tout est libre de droit donc collaboratif et participatif. Et c’est par ce que c’est libre de droit qu’il y a des portions de codes qui sont en anglais, trouvé ça et là sur le net.

Pour ceux qui sont intéressés, vous trouverez au bas de la page les codes de notre interface. C’est loin d’être du grand Art, mais c’est simple à suivre.

//////////////////////////////////////////

#include <Wire.h>
#include <SoftwareSerial.h>

// ————————— Gestion du générateur de note morse
const int tonefreq = 800; //tone frequency
const int dotlength = 50; // constants for tone and rest durations
const int dashlength = dotlength * 3; // inter-element gap – between each dot or dash of a letter
const int inter = dotlength; // letter gap is 3 dots – the inter gap is always added – so this is one fewer
const int lgap = dotlength * 2; // inter-letter gap
// word gap is 7 dots – with letter and inter gap already counted, this is -1
const int wgap = dotlength * 4; //inter-word gap

double angle_rad = PI/180.0;
double angle_deg = 180.0/PI;

double Time; // Tempo quand le relais est au calme
double COR; // Tempo de detection de porteuse
double HOLD; // Tempo de maintient
double SMetre; //Mesure du Smetre

const int  SQL = 7; // Detection de porteuse
const int PTT = 6; //Commande TX
const int K = 9; // Patte du buzzer
const int Audio1 = 4; // Commande relais audio
const int Audio2 = 5; // Commande relais audio

int compteur = 0;  // un compteur de detection de porteuse
int etatBouton; // Detection de porteuse
int memoire = LOW; // Memoire de detection de porteuse

void SendK();
void F6KOP();
void Porteuse();
void AntiBavard();
void HOT();
void InLevel();
void InRSSI();
void neuf();
void huit();
void sept();
void six();
void cinq();
void quatre();
void trois();
void deux();
void un();
void zero();

/* Le numéro de broche analogique pour la mesure de la tension en VIN */
const byte BROCHE_CAPTEUR_VIN = A0;
/* Coefficient diviseur du pont de résistance */
const float COEFF_PONT_DIVISEUR_VIN = 1.0;

// ————————————————— Gestion RSSI
/** Mesure la référence interne à 1.1 volts */
unsigned int analogReadReference(void) {
/* Elimine toutes charges résiduelles */
#if defined(__AVR_ATmega328P__)
ADMUX = 0x4F;
#elif defined(__AVR_ATmega2560__)
ADCSRB &= ~(1 << MUX5);
ADMUX = 0x5F;
#elif defined(__AVR_ATmega32U4__)
ADCSRB &= ~(1 << MUX5);
ADMUX = 0x5F;
#endif
delayMicroseconds(5);

/* Sélectionne la référence interne à 1.1 volts comme point de mesure, avec comme limite haute VCC */
#if defined(__AVR_ATmega328P__)
ADMUX = 0x4E;
#elif defined(__AVR_ATmega2560__)
ADCSRB &= ~(1 << MUX5);
ADMUX = 0x5E;
#elif defined(__AVR_ATmega32U4__)
ADCSRB &= ~(1 << MUX5);
ADMUX = 0x5E;
#endif
delayMicroseconds(200);

/* Active le convertisseur analogique -> numérique */
ADCSRA |= (1 << ADEN);
/* Lance une conversion analogique -> numérique */
ADCSRA |= (1 << ADSC);
/* Attend la fin de la conversion */
while(ADCSRA & (1 << ADSC));
/* Récupère le résultat de la conversion */
return ADCL | (ADCH << 8);
}
// ————————————————— FIN Gestion RSSI

void setup(){
Time = 0;
COR = 0;
HOLD = 0;
pinMode(PTT,OUTPUT); //Commande Relais TX
pinMode(K,OUTPUT); //Commande Buzzer
pinMode(Audio1,OUTPUT); //Commande Relais Audio
pinMode(Audio2,OUTPUT); //Commande Relais Audio
pinMode(SQL,INPUT); //Entrée Squelch
Serial.begin(9600);
BT();
digitalWrite(Audio1, HIGH);
digitalWrite(Audio2, HIGH);
digitalWrite(PTT, HIGH);
Serial.println(« // Fin Init // »);
}

void loop(){
if((Time) < (600000)){ // 10 minutes
_delay(0.001);
Time += 1;
Porteuse();
}else{
Serial.print(« Envoi du Call : « );
digitalWrite(PTT, LOW); //commande LOW et HIGH inversée sur tous les relais
digitalWrite(Audio1, LOW);
digitalWrite(Audio2, LOW);
delay(100);
F6KOP();
digitalWrite(Audio1, HIGH);
digitalWrite(Audio2, HIGH);
Serial.println(« F6KOP »);
digitalWrite(PTT, HIGH);
Time = 0;
}
_loop();
}

void Porteuse()
{
etatBouton = digitalRead(SQL);     // lecture de l’état de la presence porteuse
// Si la porteuse a un état différent de celui enregistré ET que cet état est « haut »
if((etatBouton != memoire) && (etatBouton == HIGH))
{
memoire = etatBouton;         // on enregistre l’état du bouton pour le tour suivant
}

if((etatBouton != memoire) && (etatBouton == LOW))
{
Serial.println(« Detection RX, Monté TX »);
digitalWrite(PTT, LOW);
COR = 0;
HOLD = 0;
AntiBavard();
}
}

void AntiBavard()
{
Serial.println(« Démmarage Antibavard »);
while(etatBouton == LOW){
_delay(0.001);
COR += 1;
InRSSI();
etatBouton = digitalRead(SQL);     // lecture de l’état de la presence porteuse
if (etatBouton == HIGH){           // On reset l’antibavard
COR=0;
compteur++;                      // on incrémente le compteur
Serial.println(compteur);
digitalWrite(Audio1, LOW);
digitalWrite(Audio2, LOW);
delay(400); // tempo entre commutation des relais et envoi du S-Metre morse.
Serial.print(« Envoi du SMetre »);
InLevel();
delay(wgap);
if((compteur) > (30)){              // si compteur = 30 on envoi le call
SendK();
//F6KOP();
compteur=0;
}
//SendK(); On n’envoi pas le K mais juste le SMetre
digitalWrite(Audio1, HIGH);
digitalWrite(Audio2, HIGH);
HOT();
//digitalWrite(PTT, LOW);
break;
}
else
{
if ((COR) > (90000)) { //Antibavard 90s
digitalWrite(Audio1, LOW);
digitalWrite(Audio2, LOW);
digitalWrite(PTT, LOW);
delay(100);
Serial.println(« Antibavard ! »);
BT();
digitalWrite(Audio1, HIGH);
digitalWrite(Audio2, HIGH);
digitalWrite(PTT, HIGH);
}
}
}
}

void HOT(){
Serial.println(« HOLD ON TIME »);
while(etatBouton == HIGH){
_delay(0.001);
HOLD += 1;
etatBouton = digitalRead(SQL);     // lecture de l’état de la presence porteuse
if (etatBouton == LOW){
break;
}
if ((HOLD)> (5000)) { //Maintient 5s aprés perte de porteuse
digitalWrite(Audio1, LOW);
digitalWrite(Audio2, LOW);
Serial.println(« K »);
SendK();
digitalWrite(PTT, HIGH);
digitalWrite(Audio1, HIGH);
digitalWrite(Audio2, HIGH);
Serial.println(« Passage RX »);
compteur=0;
break;
}
}
HOLD=0;
}

void _delay(float seconds){
long endTime = millis() + seconds * 1000;
while(millis() < endTime)_loop();
}

void _loop(){
}

/* Fonction loop() */
void InRSSI() {
/* Mesure la tension en VIN et la référence interne à 1.1 volts */
unsigned int raw_vin = analogRead(BROCHE_CAPTEUR_VIN);
unsigned int raw_ref = analogReadReference();
/* Calcul de la tension réel avec un produit en croix */
float real_vin = ((raw_vin * 1.1) / raw_ref) * COEFF_PONT_DIVISEUR_VIN;

/* Affichage */
//Serial.print(F(« RSSI : « ));
//Serial.println(real_vin, 3);
SMetre=real_vin;
delay(100);
}

// ————————————————— Gestion du morse
void dot()
{
// play a dot
tone(K, tonefreq);
delay(dotlength);
noTone(K);
delay(inter);
}

void dash()
{
// play a dash
tone(K, tonefreq);
delay(dashlength);
noTone(K);
delay(inter);
}

void SendK()
{
dash();
dot();
dash();
delay(lgap);
}

void InLevel()
{
if ((SMetre)> (4.3)) { // -70dBm
neuf();
Serial.println( » 9″);
} else {
if ((SMetre)> (4.15)) { //
huit();
Serial.println( » 8″);
} else {
if ((SMetre)> (3.94)) { //
sept();
Serial.println( » 7″);
} else {
if ((SMetre)> (3.77)) { //
six();
Serial.println( » 6″);
} else {
if ((SMetre)> (3.58)) { //
cinq();
Serial.println( » 5″);
} else {
if ((SMetre)> (3.52)) { //
quatre();
Serial.println( » 4″);
} else {
if ((SMetre)> (3.1)) { //
trois();
Serial.println( » 3″);
} else {
if ((SMetre)> (2.6)) { //
deux();
Serial.println( » 2″);
} else {
if ((SMetre)> (2.2)) { //
un();
Serial.println( » 1″);
} else { zero();
Serial.println( » 0″);
}
}
}
}
}
}
}
}
}
}
void F6KOP()
{
dash();
dash();
dot();
dash();
delay(lgap);
cinq();
delay(lgap);
dash();
dash();
dot();
dot();
delay(lgap);
dash();
dot();
delay(lgap);
dash();
dash();
dot();
delay(wgap);
BT();
delay(wgap);
dash();
dash();
dot();
dash();
delay(lgap);
six();
delay(lgap);
dash();
dot();
dash();
delay(lgap);
dash();
dash();
dash();
delay(lgap);
dot();
dash();
dash();
dot();

}

void BT()
{
dash();
dot();
dot();
dot();
dash();
}

void zero()
{
dash();
dash();
dash();
dash();
dash();
}

void un()
{
dot();
dash();
dash();
dash();
dash();
}

void deux()
{
dot();
dot();
dash();
dash();
dash();
}

void trois()
{
dot();
dot();
dot();
dash();
dash();
}

void quatre()
{
dot();
dot();
dot();
dot();
dash();
}

void cinq()
{
dot();
dot();
dot();
dot();
dot();
}

void six()
{
dash();
dot();
dot();
dot();
dot();
}

void sept()
{
dash();
dash();
dot();
dot();
dot();
}

void huit()
{
dash();
dash();
dash();
dot();
dot();
}

void neuf()
{
dash();
dash();
dash();
dash();
dot();
}