Morstrainer

Encuentra increíble lo rápido que las computadoras se comunican a través de un cable LAN: 10 Mbps, 100 Mbps o incluso 1 Gbps. Como recordatorio: la M significa MEGA, es decir, 1 millón (10 altos 6), el G para GIGA, es decir, 1 mil millones (10 altos 9). Antes de marearse con estas velocidades de transmisión, sugiero que "desaceleremos" juntos y aprendemos a reconocer alrededor de 100 caracteres por minuto con un MorseTrainer de construcción.

Información sobre el código de malecio.

Vale la pena saber sobre la invención de Samuel Morse, encontrará U.A. AT WikipediaDonde también descubrí algunos detalles interesantes. Lo más importante que resumo aquí:

Al principio, la motivación es sin duda la razón por la cual uno debe lidiar con el malecodo hoy, porque el último cambio decidido internacionalmente es solo unos pocos años. Yo mismo lo necesitaba en mi educación aviar, porque la radio incendia, es decir, el transmisor en la onda central y el área de FM, envía un identificador que conduce junto con la frecuencia establecida para la verificación inequívoca. Además de las señales acústicas, tales identificadores, por ejemplo, de incendios iluminados y boyas en el mar de mar, también se pueden emitir como señales ligeras. En el primer plano de nuestros esfuerzos, por lo tanto, la comprensión de un identificador suele ser de dos o tres letras "guilas", por ejemplo, MNE, MNW, MSE y MSW para los cuatro radiopers no dirigidos (NDSB) alrededor de Munich.

El código Morse para cada letra consta de los llamados puntos y accidentes cerebrovasculares, tan cortos y largos. Al hablar, el "DI" o al final "Dit" para el punto, un largo "DAH" para la línea. Así que "di di di di dit" corresponde al maledecodo corto corto corto. Las letras constan de 1 a 4 caracteres, idea original: cuanto más frecuente se produce la letra, más corta el código MORSE. Poco sorprendentemente, así que el punto. Por ti". Los números y los caracteres especiales constan de cinco o incluso más personajes. El personaje especial más famoso conoce a todos los niños, la emergencia internacional di-dit - DAH-DAH-DAH-DI-DI-DIT (., - - -.,). Como veremos, tiene similitud con las libras S-O-S, pero carece de los descansos entre las letras. Salva nuestras almas es el primer "retroceso" conocido.

Por supuesto, qué tan rápido se encuentran los signos "Dados" depende de las capacidades del codificador (transmisores) y el receptor. En nuestro programa, definiremos la longitud un "dit" como variable, que podemos ajustar más tarde si es necesario. Este "DIT" es la unidad básica del tiempo al que se devuelven todas las otras veces: un "DAH“ Tiene una longitud de 3 "dit". Y la longitud de las pausas se encuentra 1 "DIT" entre dos caracteres enviados, 3 "dit" entre las letras en una palabra y 7 dit entre palabras.

Lo que necesitamos

Programa en Python

El primer Morstrainer que me gustaría presentarles, me di cuenta con una PI de Raspberry en el lenguaje de programación Python. El problema puede descomponerse en dos subtareas: primero necesitamos una mesa con las "traducciones". A partir de entonces, los puntos y accidentes cerebrovasculares deben implementarse en tonos o marcas de luz.

En Python hay un tipo de datos llamado "Diccionario", que es ideal para el propósito de la traducción. Así que tenemos la mesa de abajo en un "Diccionario", por ejemplo, con el nombre morse implementar.

Para esta parte, uso el código del programa desde el libro de Michael, cómo aprendí Python, y que todavía lo tomo hoy en día.

#----------------------------------------------------------------
 # Dateiname: morsen.py
 # Text durch Morsezeichen darstellen.
 #
 # Michael Weigend: Raspberry Pi programmieren mit Python, mitp 2013
 # 3.13.2
 # 28.10.2013
 #----------------------------------------------------------------
 ​
 morse = {"a":".-", "b":"-...", "c":"-.-.", "d":"-..", "e":".", "f": "..-.", "g":"--.", "h":"....",
          "i":"..", "j":".---", "k":"-.-", "l":".-..", "m":"--", "n":"-.", "o":"---", "p":".--.",
          "q":"--.-", "r":".-.", "s":"...", "t":"-","u":"..-", "v":"...-", "w":".--", "x":"-..-",
          "y":"-.--", "z":"--..", "ä":".-.-", "ö":"---.", "ü":"..--", "ß":"...--.", " ":" "} 
 ​
 text = input("Geben Sie einen Text ein: ")
 morsetext = []
 for buchstabe in text:
     if buchstabe in morse.keys():
         morsetext.append(morse[buchstabe]) 
 ​
 for m in morsetext:
     print(m, end=" ") 

Las letras se utilizan dentro del "Diccionario" como la clave (llaves). Detrás del colon, el código MORSE se encuentra como valor (valor) con puntos y guiones.

Dado que solo usamos letras minúsculas en el diccionario, el método de cadena inferior () que crea una copia de las cadenas de letras pequeñas para no tener brechas cuando ingrese accidentalmente una letra mayúscula.

En el bucle para FOR, cada letra del texto ingresado se convierte individualmente y se adjunta a la lista de Morsetext inicialmente vacía. Posteriormente, los elementos de la lista están impresos.

Para la salida como una señal de sonido o de luz, conectamos un LED y / o un zumbador a un pasador de GPIO (aquí GPIO24) y cambiamos a High I (LED.ON ()) o BAJO (LED.FF ()). Con la función Sleep () desde el módulo de tiempo, determinamos la duración de la señal o pausa. Como se mencionó anteriormente, todos los tiempos se refieren a la longitud de un "DIT", que definimos como DIT variable = 0.2. Como recordatorio: el punto decimal está en Python del punto decimal. Y puede variar este valor más tarde, si desea escuchar los signos Morse más rápido.

#! /usr/bin/python3
 # Morsen_LED.py
 # Programmidee und Algorithmus: Nele Marie Klipp, Enrichment-Kurs 2016/17
 # angepasst an gpiozero: Bernd Albrecht, Kursleiter
 #
 ​
 from time import time, sleep
 from gpiozero import LED
     
 DIT = 0.2
 led = LED(24)
 ​
 MORSECODE = {"a" : ".-" , "b" : "-...", "c" : "-.-.", "d" : "-.." , "e" : ".", "f" : "..-." , "g" : "--." , "h" : "...." ,
            "i" : ".." , "j" : ".---" , "k" : "-.-" , "l" : ".-.." , "m" : "--" , "n" : "-." , "o" : "---" , "p" : ".--." ,
            "q" : "--.-" , "r" : ".-." , "s" : "..." , "t" : "-", "u" : "..-" , "v" : "...-" , "w" : ".--" , "x" : "-...-",
            "y" : "-.--" , "z" : "--.." ,  "1" : ".----" , "2" : "..---" , "3" : "...--" , "4" : "....-" ,
            "5" : "....." , "6" : "-...." , "7" : "--..." , "8" : "---.." , "9" : "----." , "0" : "-----" }
 ​
 def morse(letter):
      print(letter,MORSECODE[letter])
      for a in MORSECODE[letter]:
          if a == ".":
             # print('drin Punkt')
             led.on()
             sleep(DIT)
             led.off()
             sleep(DIT)
          else:
             # print('drin Strich')
             led.on()
             sleep(3*DIT)
             led.off()
             sleep(DIT)
      sleep(3*DIT)
 ​
 def send(text):
     for letter in text:
          if letter in MORSECODE.keys(): 
             morse(letter)
          else:
              sleep(7*DIT)
              print(" ")
 ​
 print('Was soll gesendet werden?\n')
 ​
 Eingabe=input('Text: \n').lower()
 print(Eingabe)
 send(Eingabe)

Descargar código fuente morsen_led.py

Programa en C ++

Para realizar nuestro MorseTrainer con un micro controlador compatible con Arduino, tenemos que elegir otro enfoque, porque C ++ no conoce ningún diccionario como un tipo de datos. Alternativamente, usaremos una lista de señales Morse en su lugar, que luego accedemos a las letras individuales en el código de malecio a través del índice.

Por el bien de la simplicidad, muestro el principio solo sobre la base de las letras sin umlauts, números y caracteres especiales.

 String morseTable[] = { ".-", "-...", "-.-.", "-..", ".", "..-.", "--.", "....", "..", ".---", "-.-", ".-..", "--", "-.", "---", ".--.", "--.-", ".-.", "...", "-", "..-", "...-", ".--", "-..-", "-.--", "--.."};

Ahora solo tengo que asignar el índice 0 a la letra A, etc. hasta el índice 25 para la letra Z; ¡Así que 26 letras, índice de 0 a 25!

En la tabla ASCII, encuentro códigos ASCII de 65 a 90 para letras mayúsculas A a Z y 97 a 122 para letras pequeñas A a Z. Después de ingresar las letras en el monitor en serie, se verifica si el valor ASCII está entre los números mencionados. Luego, el índice se determina mediante la resta de 65 y 97 y se elimina el código MORSE de la lista. De acuerdo con el número de signos Morse de una letra, el bucle para la salida de la luz o las señales de sonido se ejecuta a cuatro a cuatro veces. Me gustaría mencionar un tropiezo: en el punto de la consulta o la puntada. If (Morsechar [I] == ''.) Primero había utilizado doble coma altamente, porque el código de Morsecode se almacena como una cadena en la lista. Pero los caracteres individuales de la "cadena" son, caracteres ', tan simples altamente comas para usar.

Aquí está el código de nuestro ARDUINO MORSTRAINER:

 /* Morse-Trainer mit Arduino
  * Buzzer und LED an Pin 13
  */
 ​
 int ledPin = 13;
 int dit = 200;
 int dah = 3 * dit;
 int oneChar;
 String morseChar;
 String morseTable[] = { ".-", "-...", "-.-.", "-..", ".", "..-.", "--.", "....", "..", ".---", "-.-", ".-..", "--", "-.", "---", ".--.", "--.-", ".-.", "...", "-", "..-", "...-", ".--", "-..-", "-.--", "--.."};
 ​
 void setup() {
   pinMode(ledPin, OUTPUT);
   digitalWrite(ledPin, HIGH);   
   delay(1000);  
   digitalWrite(ledPin, LOW);   
   Serial.begin(9600);
   while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }  
   Serial.println("\nEnter group of characters in Serial Monitor");
   Serial.println();  
 }  // end setup()
 ​
 void loop () {
   // get any incoming bytes:
   if (Serial.available() > 0) {
     oneChar = Serial.read();
     Serial.print(char(oneChar));
     Serial.print("   ");    
     morseCode();
  }
 }  // end loop()
 ​
 void morseCode() {
   if (oneChar >= 65 && oneChar <= 90) {
     morseChar=morseTable[oneChar-65]; }  
   else if (oneChar >= 97 && oneChar <= 122) {
     morseChar=morseTable[oneChar-97]; }
   else {
     morseChar=" ";}
   Serial.println(morseChar);
   outputMorse();
   Serial.println();
 }
 ​
 void outputMorse() {
   int len = morseChar.length();
 // Serial.print( "morseChar.length = ");
 // Serial.println(len);
   for (int i=0; i<len; i++) {
 //   Serial.print(morseChar[i]);      
     if (morseChar[i]=='.') {      //reminder: "String" with characters '.' and '-'
       digitalWrite(ledPin, HIGH);   
       delay(dit);  
       digitalWrite(ledPin, LOW);   
       delay(dit);   }
     if (morseChar[i]=='-') {      //reminder: "String" with characters '.' and '-'
       digitalWrite(ledPin, HIGH);   
       delay(dah);  
       digitalWrite(ledPin, LOW);   
       delay(dit);   }  
     else {
       delay(7*dit);}  
    }
     delay(dah);
  }

Descargar código fuente Morstrainer.ino

Descripción general Morsecode

Para reconocer los signos Morse, la tabla que se muestra de arriba ayuda, que se ordenó alfabéticamente, desafortunadamente poco. Por lo tanto, aquí de nuevo la "reversión" de la mesa Morse. Sugerencia: Comience con las letras que tienen un máximo de tres caracteres. Especialmente en los meses de verano, sin duda recordará el e i s más rápido. Divertirse.