my link

samedi 19 août 2017

Manipuler: pour s'entrainer à la manipulation

C'est un projet commun avec F5RUJ et moi même.
Nous avons imaginé et élaboré un jeu qui consiste à manipuler correctement les lettres à la pioche.


Alain F5RUJ a fait le plus gros du travail dans la programmation de l'arduino.
Le principe est simple: on manipule une pioche et les lettres s'affichent sur une matrice à led.

Un article est disponible dans l'un des numéro de La PIOCHE de l'UFT en 2017

Comme je vais utiliser cet équipement à l'extérieur, pour des raisons de visibilité, j'ai préféré faire l'affichage sur un écran LCD Alphanumérique. La tonalité sort du haut-parleur.









Le circuit s'alimente avec une pile 9V, via un régulateur 7805. C'est un arduino mini-Pro que j'utilise et des écrans LCD de récupérations. L'audio sort par un GPIO de l'arduino, un signal carré à 700Hz. Une résistance série avec le GPIO, et potentiomètre de 10kOhm logarithmique atténue ce signal carré. C'est un module audio à base de LM386 CMS qu'on trouve sur EBAY qui fait un amplificateur pour le HP de sortie de récupération.
Au fur et à mesure de la manipulation, les caractères ALPHA NUMERIQUES s'affiche sur un écran LCD 2x16 caractères.
Pour optimiser l'affichage, il n'y a pas d'espaces entre les mots.



C'est un prototype qui a des bugs:
- Quand le contact de la pioche est trop longue, le logiciel plante. Il faut attendre un peu, sans manipuler. ça se remet tout seul.

- La fermeture du boitier n'est pas vraiment optimisée, j'ai fini par coller le couvercle pour m'éviter des vis qui dépasses. Mais c'est pas pratique en cas de mise à jour

Sauf si je trouve à l'utilisation que ces bugs sont très gênant, je ne compte pas les corriger.

En tout cas, ça fait un bel atelier de démonstration et de jeu pour les plus jeunes.

Je vais utiliser ces appareils dans des ateliers Radioscoutisme.
Ces ateliers seront agrémenté d'un support disponible ici:

http://www.radioscoutisme.org/phocadownload/ft4codes.pdf








 Code Arduino du décodeur de clef morse (maj 27 aout 2017)

 #include <LedControl.h>
#include <LiquidCrystal.h>
//#include <String.h>
/*
Le rôle initial de ce programme Inspiré du travail de Budd Churchward  - WB7FHC est de transformer et d'afficher une lettre manipulée en Morse
avec une pioche ou un manipulateur double contact suivi d'un keyer.
L'affichage doit se faire sur une matrice de LEDs de 8x8 ou un afficheur à plusieurs lignes.
L'appareil est destiné à l'apprentissage de la manipulation correcte, quelle que soit la vitesse. On peut envisager de le transformer en décodeur.
Il constitue également un buzzer en lui adjoignant un amplificateur BF.
A partir du logiciel d'Alain F5RUJ, modifié pour un affichage LCD.
Pour avoir un espace, il faut exceptionnellement avoir l'équivalent de 4 dah, au lieu de 3.

Aduino PIN 0 serial RX
Aduino PIN 1 serial TX

Aduino PIN 2 Entrée Manip Morse

Utilise un écran 16 char x 2 lignes
// cablage LCD sur l'arduino
GND           - LCD PIN 1 GND
+5V           - LCD PIN 2 VCC
Rvar          - LCD PIN 3 Vo contrast
Aduino PIN 5  - LCD PIN 4 RS
GND           - LCD PIN 5 R/W
Aduino PIN 6  - LCD PIN 6 Enable
Aduino PIN 7  - LCD PIN 11 D4
Aduino PIN 8  - LCD PIN 12 D5
Aduino PIN 9  - LCD PIN 13 D6
Aduino PIN 10 - LCD PIN 14 D7
R             - LCD PIN 15 +5V Anode Retroéclairage
GND           - LCD PIN 16 GND Cathode "

// CW OUTPUT
Aduino PIN 12 Audio OUT HPsortie
Aduino PIN 13 sortie 0/1 vers buzzer

*/

// .................................................................... Directives de compilation

#define vers "Manipuler LCD F5RUJ F4EGX"


// Pour l'écran LCD
LiquidCrystal aff(5,6,7,8,9,10); // .............. L'afficheur



#define LEDPIN 13 // Allume une LED quand on appuie
#define BUZPIN 12 // Délivre du 700 Hz quand on appuie
//#define CLK 10
//#define CS 9
#define DAT 8 // 3 broches pour le 7912 afficheur matrice de LEDS
// .................................................................... Variables globales fonctionnelles

#define PIOCHE 2   // Broche sur laquelle on branche le manipulateur (Si LCD)
//#define PIOCHE 7   // Broche sur laquelle on branche le manipulateur
int pic = 1;      // Stocke la valeur lue sur la broche

int PosXaff = 0;
int PosYaff = 0;

/*
 La table suivante correspond à l'ordre des lettres transformées en binaire à partir de leur image en Morse, avec dit = 1 et dah = 0.
On ajoute à gauche un bit de start, pour ne pas avoir par exemple 2 zéros (M) qui ne serait pas différenciable avec un seul zéro (T).
De cette façon T = 0B10 (2) et M = 0B100 (4); Quant à E il devient 0B11 (3).
*/
char tablecar[]="##TEMNAIOGKDWRUS##QZYCXBJP#L#FVH09#8###7#(#ç#/=61#à##+è#2##é3#45";
char cartrouve = ' '; // .............................................. Stocke le caractère décodé
int nombre = 0; // .................................................... Stocke le nombre binaire créé par dit/dah successifs
boolean justefait = true; // .......................................... Trois drapeaux utiles à la programmation
boolean carfait = true;
boolean ditoudah = true;
// .................................................................... Variables de durée pour la reconnaissance des points et traits, espaces etc.
int dahmoyen = 240;
int dit = 80;
int ditvrai = dit;
int picdelai = 2; // .................................................. Passage d'une position à l'autre de la pioche
long tempsbas = 0; // ................................................. Durée du son quand la pioche est basse
long tempshaut = 0; // ................................................ Durée du silence quand la pioche est haute
long toptempsbas = 0; // .............................................. Début chrono pioche appuyée
long toptempshaut = 0; // ............................................. Début chrono pioche relevée
long T1,T2=0; // Timers d'extiction
bool allume = false;
//LedControl lc = LedControl(DAT,CLK,CS,1); // .......................... Création de l'objet matrice de Leds

// .................................................................... Tableaux des lettres en matrice

unsigned char lettre [37][8]={
  0x3E, 0x63, 0x6F, 0x69, 0x6F, 0x60, 0x3E, 0x00, // Char 064 (@)
  0x18, 0x3C, 0x66, 0x66, 0x7E, 0x66, 0x66, 0x00, // Char 065 (A)
  0x7E, 0x33, 0x33, 0x3E, 0x33, 0x33, 0x7E, 0x00, // Char 066 (B)
  0x1E, 0x33, 0x60, 0x60, 0x60, 0x33, 0x1E, 0x00, // Char 067 (C)
  0x7C, 0x36, 0x33, 0x33, 0x33, 0x36, 0x7C, 0x00, // Char 068 (D)
  0x7F, 0x31, 0x34, 0x3C, 0x34, 0x31, 0x7F, 0x00, // Char 069 (E)
  0x7F, 0x31, 0x34, 0x3C, 0x34, 0x30, 0x78, 0x00, // Char 070 (F)
  0x1E, 0x33, 0x60, 0x60, 0x67, 0x33, 0x1F, 0x00, // Char 071 (G)
  0x66, 0x66, 0x66, 0x7E, 0x66, 0x66, 0x66, 0x00, // Char 072 (H)
  0x3C, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3C, 0x00, // Char 073 (I)
  0x0F, 0x06, 0x06, 0x06, 0x66, 0x66, 0x3C, 0x00, // Char 074 (J)
  0x73, 0x33, 0x36, 0x3C, 0x36, 0x33, 0x73, 0x00, // Char 075 (K)
  0x78, 0x30, 0x30, 0x30, 0x31, 0x33, 0x7F, 0x00, // Char 076 (L)
  0x63, 0x77, 0x7F, 0x7F, 0x6B, 0x63, 0x63, 0x00, // Char 077 (M)
  0x63, 0x73, 0x7B, 0x6F, 0x67, 0x63, 0x63, 0x00, // Char 078 (N)
  0x3E, 0x63, 0x63, 0x63, 0x63, 0x63, 0x3E, 0x00, // Char 079 (O)
  0x7E, 0x33, 0x33, 0x3E, 0x30, 0x30, 0x78, 0x00, // Char 080 (P)
  0x3C, 0x66, 0x66, 0x66, 0x6E, 0x3C, 0x0E, 0x00, // Char 081 (Q)
  0x7E, 0x33, 0x33, 0x3E, 0x36, 0x33, 0x73, 0x00, // Char 082 (R)
  0x3C, 0x66, 0x30, 0x18, 0x0C, 0x66, 0x3C, 0x00, // Char 083 (S)
  0x7E, 0x5A, 0x18, 0x18, 0x18, 0x18, 0x3C, 0x00, // Char 084 (T)
  0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x7E, 0x00, // Char 085 (U)
  0x66, 0x66, 0x66, 0x66, 0x66, 0x3C, 0x18, 0x00, // Char 086 (V)
  0x63, 0x63, 0x63, 0x6B, 0x7F, 0x77, 0x63, 0x00, // Char 087 (W)
  0x63, 0x63, 0x36, 0x1C, 0x1C, 0x36, 0x63, 0x00, // Char 088 (X)
  0x66, 0x66, 0x66, 0x3C, 0x18, 0x18, 0x3C, 0x00, // Char 089 (Y)
  0x7F, 0x63, 0x46, 0x0C, 0x19, 0x33, 0x7F, 0x00, // Char 090 (Z)
  0x3E, 0x63, 0x67, 0x6F, 0x7B, 0x73, 0x3E, 0x00, // Char 048 (0)
  0x18, 0x38, 0x58, 0x18, 0x18, 0x18, 0x7E, 0x00, // Char 049 (1)
  0x3C, 0x66, 0x06, 0x1C, 0x30, 0x66, 0x7E, 0x00, // Char 050 (2)
  0x3C, 0x66, 0x06, 0x1C, 0x06, 0x66, 0x3C, 0x00, // Char 051 (3)
  0x0E, 0x1E, 0x36, 0x66, 0x7F, 0x06, 0x0F, 0x00, // Char 052 (4)
  0x7E, 0x60, 0x7C, 0x06, 0x06, 0x66, 0x3C, 0x00, // Char 053 (5)
  0x1C, 0x30, 0x60, 0x7C, 0x66, 0x66, 0x3C, 0x00, // Char 054 (6)
  0x7E, 0x66, 0x06, 0x0C, 0x18, 0x18, 0x18, 0x00, // Char 055 (7)
  0x3C, 0x66, 0x66, 0x3C, 0x66, 0x66, 0x3C, 0x00, // Char 056 (8)
  0x3C, 0x66, 0x66, 0x3E, 0x06, 0x0C, 0x38, 0x00, // Char 057 (9)
};

unsigned char ponctu[18][8]={
{0x0,0x18,0x18,0x0,0x0,0xC18,0x18,0x0}, // : 0
{0,0x18,0x18,0,0,0x18,0x18,0x30}, // ; 1
{0,0,0x7E,0,0,0x7E,0,0}, // = 2
{0x3C,0x66,0x06,0x0C,0x18,0,0x18,0x18}, // ? 3
{0,0,0,0,0,0x18,0x18,0}, // . 4
{0,0,0,0,0,0x18,0x18,0x30}, // , 5
{0x30,0x30,0x60,0,0,0,0,0}, // ' 6
{0x0C,0x18,0x30,0x30,0x30,0x18,0x0C,0}, // ( 7
{0x30,0x18,0x0C,0x0C,0x0C,0x18,0x30,0}, // ) 8
{0x6C,0x6C,0x6C,0,0,0,0,0}, // " 9
{0x03,0x06,0x0C,0x18,0x30,0x60,0x40,0}, // / 10
{0x18,0x3C,0x3C,0x18,0x18,0,0x18,0}, // ! 11
{0x10,0x10,0x10,0xFE,0x10,0x10,0x10,0}, // + 12
{0,0,0,0x7E,0,0,0,0}, // - 13
{0x18,0x3E,0x60,0x3C,0x06,0x7C,0x18,0},  // $ 14
{0x3E,0x63,0x6F,0x69,0x6F,0x60,0x3E,0x00}, // Char 064 (@)
{0x00,0xA6,0xA9,0xA9,0xAF,0xA9,0x49,0x00},  // Char VA
{0x020,0x28,0xF8,0x29,0x2A,0x0C,0x0A,0x09}  // Char +K 426
};

unsigned char accent[4][8] = {
{0x0C,0x10,0x78,0xCC,0xFC,0xC0,0x78,0}, // é 0
{0x60,0x10,0x3C,0x66,0x7E,0x60,0x3C,0}, // è 1
{0x10,0x08,0x3C,0x06,0x3E,0x66,0x3F,0}, // à 2
{0x3C,0x42,0xC0,0xC0,0x46,0x3C,0x18,0x30} // ç 3
};

unsigned char smiley[1][8] = {
0x7E,0x81,0xA5,0x81,0xBD,0x99,0x81,0x7E
};


// ........................................................................................ Zone des procédures majeures

void setup() {
aff.begin(16,2);
pinMode(PIOCHE, INPUT_PULLUP); // ...................................... Pullup évite une résistance de "tirage" vers le 5V
pinMode(LEDPIN,OUTPUT); pinMode (BUZPIN,OUTPUT);
digitalWrite(LEDPIN,LOW); digitalWrite(BUZPIN,LOW);
// ..................................................................... Setup pour la matrice de LEDs
//pinMode(CLK,OUTPUT); pinMode(CS,OUTPUT); pinMode(DAT,OUTPUT);
//lc.shutdown(0,false); lc.setIntensity(0,1); lc.clearDisplay(0);
// ..................................................................... Version 0.0 : Setup affichage série
Serial.begin(9600);
Serial.println(vers);
aff.print("Manipuler");
aff.setCursor(0,1);
aff.print("F5RUJ F4EGX");
aff.setCursor(0,0);
delay(1000);
    tone(BUZPIN,659,100);    delay(175);
    tone(BUZPIN,659,100);    delay(250);
    tone(BUZPIN,659,100);    delay(150);
    tone(BUZPIN,523,100);    delay(150);
    tone(BUZPIN,659,100);    delay(250);
    tone(BUZPIN,784,100);    delay(500);
    tone(BUZPIN,196,100);    delay(500);
aff.clear();
aff.print(">");
strcpy(tablecar, "##TEMNAIOGKDWRUS##QZYCXBJP#L#FVH09#8###7#(#ç#/-61#à##+è#2##é3#45");
}

/*
 La boucle principale, très courte, teste en permanence la position de la pioche et envoie vers l'une ou l'autre des procédures correspondantes.
 Les drapeaux ci-dessus permettront de déterminer où l'on en est dans le décodage de la lettre. La lettre sera terminée quand le temps haut
 sera supérieur à un dah de longueur moyenne.
 */

void loop()
{
 pic = digitalRead(PIOCHE);
 if (!pic)  clebasse();
 if (pic)   clehaute();
}

// .......................................................................................... Zone des procédures appelées

void clebasse() // .......................................................................... Clef appuyée
{
digitalWrite(LEDPIN,1); tone (BUZPIN, 700); // .............................................. Allume et couine
//lc.clearDisplay(0);
if (toptempshaut > 0) toptempshaut = 0; // .................................................. Remet à 0 le départ du temps clef relevée
if (toptempsbas == 0) toptempsbas = millis(); // ............................................ Initialise le temps clef appuyée
carfait = false; ditoudah = false; delay (picdelai); // .................... Caractère non terminé et on ne sait pas encore si c'est dit ou dah
if (nombre == 0) nombre = 1; // ............................................ On ajoute le bit de départ si le caractère est égal à 0 (nouveau caractère)
}

void clehaute() // .................................................................... Clef relevée
// C'est la procédure essentielle pour décoder la lettre. En raison de la durée de la position appuyée (tempsbas) on saura si c'est un dit ou un dah
{
digitalWrite(LEDPIN,0); noTone(BUZPIN); // ............................................ Eteint la LED et fait silence
//if (allume == true) {T2=millis(); if (T2>(T1+15000)){lc.clearDisplay(0); allume = false;}}
if (toptempshaut == 0) toptempshaut = millis();
tempshaut = millis() - toptempshaut; if (tempshaut < 10) return; // .................... Mesure du temps position haute
if (tempshaut > (dahmoyen * 4)) espace();
// ................................... Si la durée en position haute est longue, le caractère est terminé et on peut imprimer (éventuellement) un espace
if (toptempsbas>0) {tempsbas = millis() - toptempsbas; toptempsbas=0;}
// ................................... Mesure du temps position basse pour déterminer si c'est dit ou dah
if (!ditoudah) shiftbits(); // ....... On compose le caractère bit par bit en ajoutant 1 ou 0 et en décalant à gauche
if(!carfait)
  {
   if (tempshaut >= (dahmoyen)) {printcaractere(); carfait = true; nombre=0;}
   tempsbas = 0;
  }
}

void shiftbits() // ..................................................................... On décale les bits vers la gauche
{
if (tempsbas < ditvrai/2) return; // .................................................... C'est une erreur
nombre = nombre << 1; // ................................................................ On décale vers la gauche
if (tempsbas < dit) // .................................................................. Si c'est un dit on ajoute 1, sinon on ne fait rien
   {nombre++; ditvrai = (tempsbas+ditvrai) / 2;} // ..................................... On réajuste la durée dit et dah
else {dahmoyen = (tempsbas + dahmoyen) / 2;  // ....... On fait la moyenne entre le dernier dah et le dah moyen, puis on calcule le dit moyen
     dit = dahmoyen / 3; ditvrai = dit; dit = dit* 2; // .. On allonge la variable dit pour que la comparaison soit pertinente avec tempsbas.
     }
ditoudah = true; // ..................................................................... On sait si c'est l'un ou l' autre.
}

void printcaractere()
{
if (nombre > 63) {printponctuation(); return;}
cartrouve = tablecar[nombre];
if(nombre==45) cartrouve='/';
if(nombre==47) cartrouve='6';
if(nombre==48) cartrouve='1';
if(nombre==50) cartrouve='à';
if(nombre==53) cartrouve='+';
if(nombre==54) cartrouve='è';
if(nombre==56) cartrouve='2';
if(nombre==60) cartrouve='3';
if(nombre==46) cartrouve='=';
if(nombre==62) cartrouve='4';
if(nombre==63) cartrouve='5';
Serial.print(nombre);Serial.print(" - ");Serial.print(tablecar[nombre]); Serial.print(" - ");
afficher(); // ............................................................................ On affiche le caractère trouvé sur une matrice de LEDS
justefait=false; // ....................................................................... On recommence un nouveau caractère
}

void printponctuation()
/* On fait de cette façon pour éviter d'avoir une table de caractères trop longue et pleine de cases vides,
la ponctuation étant codée avec de nombreux points et traits. On pourrait l'étendre aux lettres accentuées*/
{
  switch (nombre) {
    case 71:
      cartrouve = ':';
      break;
    case 76:
      cartrouve = ',';
      break;
    case 82:
      cartrouve = ')';
      break;
    case 84:
      cartrouve = '!';
      break;
    case 85:
      cartrouve = ';';
      break;
    case 94:
      cartrouve = '-';
      break;
    case 97:
      cartrouve = 39;    // Apostrophe
      break;
    case 101:
      cartrouve = '@';
      break;
    case 106:
      cartrouve = '.';
      break;
    case 109:
      cartrouve = '"';
      break;
    case 115:
      cartrouve = '?';
    case 122:
      cartrouve = 'ù';
      break;
     case 246:
      cartrouve = '$';
      break;
     case 426:
      cartrouve = 'µ';
      break;
      default:
      cartrouve = '#';    // On ne sait pas ce que c'est!
      break;
  }
  afficher();// ......................................................... On affiche le caractère trouvé sur une matrice de LEDS
}

void espace()
{
if(justefait) return; // ................................................ Si on a déjà imprimé un espace on ne fait rien
justefait = true; // De cette façon on n'imprimera plus d'espace
//ci-dessous pour avoir un espace
//aff.setCursor(PosXaff,PosYaff); aff.print(" ");  PosXaff++;      if(PosXaff>15) {PosXaff=0;if(PosYaff==0){PosYaff=1;}else{PosYaff=0;}}
//cartrouve = ' '; // afficher();  Inopportun avec matrice de LEDS
}

void afficher()
// ....................................................................... A modifier en fonction de l'affichage
{
Serial.println(cartrouve); // Version Beta 0.0
//if (cartrouve == ' '); return; // N'affiche pas d'espace sur matrice de LEDS
// Tester les caractères accentués ou spéciaux
//if (cartrouve == '#') {aff_car(0,*smiley); return;}
//if(nombre==122){aff_car(16,*ponctu); return;} //VA
//if(nombre==426){aff_car(17,*ponctu); return;} //+K
//if (nombre==59) {aff_car(0,*accent); return;}
//if (nombre==54) {aff_car(1,*accent); return;}
//if (nombre == 50) {aff_car(2,*accent); return;}
//if (nombre == 43) {aff_car(3,*accent); return;}

// Tester la pontuation
if (isPunct(cartrouve))
  {
   int caractere = 255;
   switch (cartrouve)
   {
    case ',' : caractere = 5; aff.setCursor(PosXaff,PosYaff); aff.print(cartrouve); aff.setCursor(PosXaff+1,PosYaff); aff.print(' ');  PosXaff++; if(PosXaff>15) {PosXaff=0;if(PosYaff==0){PosYaff=1;}else{PosYaff=0;}} break;
    case ':' : caractere = 0; aff.setCursor(PosXaff,PosYaff); aff.print(cartrouve); aff.setCursor(PosXaff+1,PosYaff); aff.print(' '); PosXaff++; if(PosXaff>15) {PosXaff=0;if(PosYaff==0){PosYaff=1;}else{PosYaff=0;}} break;
    case ';' : caractere = 1; aff.setCursor(PosXaff,PosYaff); aff.print(cartrouve); aff.setCursor(PosXaff+1,PosYaff); aff.print(' '); PosXaff++;if(PosXaff>15) {PosXaff=0;if(PosYaff==0){PosYaff=1;}else{PosYaff=0;}}  break;
    case '.' : caractere = 4; aff.setCursor(PosXaff,PosYaff); aff.print(cartrouve); aff.setCursor(PosXaff+1,PosYaff); aff.print(' ');  PosXaff++;if(PosXaff>15) {PosXaff=0;if(PosYaff==0){PosYaff=1;}else{PosYaff=0;}}  break;
    case '?' : caractere = 3; aff.setCursor(PosXaff,PosYaff); aff.print(cartrouve); aff.setCursor(PosXaff+1,PosYaff); aff.print(' '); PosXaff++;  if(PosXaff>15) {PosXaff=0;if(PosYaff==0){PosYaff=1;}else{PosYaff=0;}} break;
    case '\'': caractere = 6; aff.setCursor(PosXaff,PosYaff); aff.print(cartrouve); aff.setCursor(PosXaff+1,PosYaff); aff.print(' ');  PosXaff++; if(PosXaff>15) {PosXaff=0;if(PosYaff==0){PosYaff=1;}else{PosYaff=0;}}  break;
    case '"' : caractere = 9; aff.setCursor(PosXaff,PosYaff); aff.print(cartrouve); aff.setCursor(PosXaff+1,PosYaff); aff.print(' ');  PosXaff++;if(PosXaff>15) {PosXaff=0;if(PosYaff==0){PosYaff=1;}else{PosYaff=0;} } break;
    case '(' : caractere = 7; aff.setCursor(PosXaff,PosYaff); aff.print(cartrouve); aff.setCursor(PosXaff+1,PosYaff); aff.print(' ');  PosXaff++; if(PosXaff>15) {PosXaff=0;if(PosYaff==0){PosYaff=1;}else{PosYaff=0;}}  break;
    case ')' : caractere = 8; aff.setCursor(PosXaff,PosYaff); aff.print(cartrouve); aff.setCursor(PosXaff+1,PosYaff); aff.print(' ');  PosXaff++; if(PosXaff>15) {PosXaff=0;if(PosYaff==0){PosYaff=1;}else{PosYaff=0;}}  break;
    case '/' : caractere = 10; aff.setCursor(PosXaff,PosYaff); aff.print(cartrouve); aff.setCursor(PosXaff+1,PosYaff); aff.print(' ');  PosXaff++; if(PosXaff>15) {PosXaff=0;if(PosYaff==0){PosYaff=1;}else{PosYaff=0;}} break;
    case '!' : caractere = 11; aff.setCursor(PosXaff,PosYaff); aff.print(cartrouve); aff.setCursor(PosXaff+1,PosYaff); aff.print(' ');  PosXaff++;if(PosXaff>15) {PosXaff=0;if(PosYaff==0){PosYaff=1;}else{PosYaff=0;}}  break;
    case '+' : caractere = 12; aff.setCursor(PosXaff,PosYaff); aff.print(cartrouve); aff.setCursor(PosXaff+1,PosYaff); aff.print(' ');  PosXaff++;if(PosXaff>15) {PosXaff=0;if(PosYaff==0){PosYaff=1;}else{PosYaff=0;}}   break;
    case '-' : caractere = 13; aff.setCursor(PosXaff,PosYaff); aff.print(cartrouve); aff.setCursor(PosXaff+1,PosYaff); aff.print(' ');  PosXaff++;if(PosXaff>15) {PosXaff=0;if(PosYaff==0){PosYaff=1;}else{PosYaff=0;}}   break;
    case '=' : caractere = 2; aff.setCursor(PosXaff,PosYaff); aff.print(cartrouve); aff.setCursor(PosXaff+1,PosYaff); aff.print(' ');  PosXaff++; if(PosXaff>15) {PosXaff=0;if(PosYaff==0){PosYaff=1;}else{PosYaff=0;}}  break;
    case '$' : caractere = 14; aff.setCursor(PosXaff,PosYaff); aff.print(cartrouve); aff.setCursor(PosXaff+1,PosYaff); aff.print(' ');  PosXaff++; if(PosXaff>15) {PosXaff=0;if(PosYaff==0){PosYaff=1;}else{PosYaff=0;}}  break;
    case '@' : caractere = 15; aff.setCursor(PosXaff,PosYaff); aff.print(cartrouve); aff.setCursor(PosXaff+1,PosYaff); aff.print(' ');  PosXaff++;if(PosXaff>15) {PosXaff=0;if(PosYaff==0){PosYaff=1;}else{PosYaff=0;}}  break;
    default  : caractere = 255; break;
   }
//  if (caractere == 255) {aff_car(0,*smiley); return;}
//  aff_car( caractere,*ponctu); return;
  }

// Lettre
if (isalpha(cartrouve))
  {
   byte x = cartrouve-64;
//   aff_car(x,*lettre); 
     aff.setCursor(PosXaff,PosYaff);
     aff.print(cartrouve);
     aff.setCursor(PosXaff+1,PosYaff);
     aff.print(' ');
     PosXaff++;
     if(PosXaff>15) {PosXaff=0;if(PosYaff==0){PosYaff=1;}else{PosYaff=0;}}
     //aff.scrollDisplayLeft();
  }
// Chiffre
if (isDigit(cartrouve))
  {
  byte x = cartrouve-21;
//  aff_car(x,*lettre); return;
     aff.setCursor(PosXaff,PosYaff);
     aff.print(cartrouve);
     aff.setCursor(PosXaff+1,PosYaff);
     aff.print(' ');
     PosXaff++;
     if(PosXaff>15) {PosXaff=0;if(PosYaff==0){PosYaff=1;}else{PosYaff=0;}}
     //aff.scrollDisplayLeft();
   }


 
}

// ....................................................................... Procédures relatives à la matrice de LEDS
//void aff_car (int j, unsigned char *table)
//{
//  unsigned char i,c;
//  for(i=0;i<=7;i++)
//  {digitalWrite(CS,LOW);
//  matriceLED_ligne(i+1); // ................................. Adresse de la ligne
//  c = table[j*8 + i];  matriceLED_ligne(c); // ............ La valeur de la ligne
//    digitalWrite(CS,HIGH);} allume = true; T1 = millis();
//}
////
//void matriceLED_ligne(unsigned char DATA) // .............. Afiche une rangée
//{    
//  digitalWrite(CS,LOW);    
//  for(int j=8;j>=1;j--)
//    {      
//     digitalWrite(CLK,LOW);
//     digitalWrite(DAT,DATA & B10000000);// ................ Extrait le bit de poids fort puis décale à gauche
//     DATA = DATA<<1;
//     digitalWrite(CLK,HIGH);
//    }                               
//}













Code OpenSCAD pour le boitier du décodeur de clef morse:
//manipDecode
// boitier pour le manip avec décodage LCD
$fn=50;

couvercle=1;
evider=1;
bvide=52;


difference(){


        //boite
        hull(){
            if(couvercle==1){
            translate([0,0,-26])cylinder(r=55/2, h=35);
            translate([138,-55/2,-26])cube([2,55,35]);
            }
        }
union(){
        translate([30,0,0])LCD();
        HP();
        translate([133,0,2])potar();
        translate([0,-bvide/2,-22])cube([135,bvide,22]);
        translate([-20,0,-30])cylinder(r=3/2, h=30, center=true);  //vis fixation HP
        translate([-20,0,-19.5])cylinder(r=3.5, h=2, center=true);  //vis fixation HP
       translate([22,-20,0])cylinder(r=3/2, h=80, center=true);  //vis fixation gauche
        translate([22,20,0])cylinder(r=3/2, h=80, center=true);  //vis fixation gauche
        translate([135,-20,0])cylinder(r=3/2, h=80, center=true);  //vis fixation droite
        translate([135,20,0])cylinder(r=3/2, h=80, center=true);  //vis fixation droite
        translate([135,15,-12])rotate([0,90,0])cylinder(r=3/2, h=80, center=true);  //passage cable manip
        translate([135,-5,-12])rotate([0,90,0])cylinder(r=6/2, h=80, center=true);  //passage cable pile
        translate([135,-15,-12])rotate([0,90,0])cylinder(r=6/2, h=80, center=true);  //passage cable pile

        }
translate([-45,-100/2,-22])cube([200,100,0.1]);       
}

module LCD(){
    translate([0,-18.5,0]){
    color("green", 1.0) translate([-1,-0.4,-5.5+1.75])cube([82,37,5.5]);
    color("grey", 1.0) translate([6,31,-15])cube([42,4,15]);
    color("blue", 1.0) translate([2.5,5.5,0])cube([75,26,10]);
    color("grey", 1.0) translate([-1,5.5,0])cube([82,26,6]);
    }
}


module HP(){
   translate([0,0,7])rotate([0,180,0]){
        cylinder(r=bvide/2, h=7);
        cylinder(r=33/2, h=16);
         if(evider==1){color("LemonChiffon"){
            cylinder(r=bvide/2, h=26);

            for (transl = [8 : 5 : 25])
            for (angl = [0 : 30 : 360])  rotate([0,0,(angl)])translate([transl,0,-15])cylinder(r=3/2, h=20);
            }
  }
   }
}

module potar()
{translate([0,9,-5])rotate([0,0,180])color("DarkSlateGray"){
        cube([18,27,10]);
        translate([9,9,0])cylinder(r=10.5/2, h=20);
        translate([9,9,0])cylinder(r=6.4/2, h=45);
       
       
    }
   // if(evider==1){color("LemonChiffon"){translate([-9,0,15])cylinder(r=25/2, h=20, center=true);}}
}

Aucun commentaire:

Enregistrer un commentaire