|
|
|
/** @file functions.c
|
|
|
|
* @brief Diverse Funktionen
|
|
|
|
* @author Tom, DL7BJ
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "functions.h"
|
|
|
|
|
|
|
|
// EEProm
|
|
|
|
uint8_t Dummy;
|
|
|
|
uint8_t ee_Dummy EEMEM = 0x55; // Dummy for Address 0
|
|
|
|
uint8_t ee_TRX EEMEM = 0; // TRX 1 oder 2 oder beide
|
|
|
|
uint8_t ee_KeyerMode EEMEM = 1; // Iambic A, Iambic B oder Ultimatic
|
|
|
|
uint8_t ee_SidetoneEnabled EEMEM = 1; // Mithörton eingeschaltet
|
|
|
|
uint8_t ee_WpMBpM EEMEM = 0; // WpM oder BpM Anzeige
|
|
|
|
uint8_t ee_Reverse EEMEM = 0; // linkes/rechtes Paddle vertauschen
|
|
|
|
uint8_t ee_WinkeyerEnabled EEMEM = 0; // Winkeyer Emulation
|
|
|
|
uint8_t ee_Ratio EEMEM = 30; // Punkt/Strich Verhältnis 1:3
|
|
|
|
uint8_t ee_Memory EEMEM = 0; // Punkt/Strich Speicher
|
|
|
|
uint16_t ee_SidetoneFreq EEMEM = 600; // Frequenz des Mithörtons
|
|
|
|
uint8_t ee_WpM EEMEM = 12; // WpM
|
|
|
|
uint8_t ee_RiseTime EEMEM = 5; // Anstiegszeit Sinuston
|
|
|
|
uint8_t ee_RiseTimeCounter EEMEM = 5; // Anzahl Sinusschwingungen für den Anstieg
|
|
|
|
uint8_t ee_DebounceTime EEMEM = 6; // Entprellzeit für Straight Key Eingang
|
|
|
|
|
|
|
|
|
|
|
|
// Stringkonstanten für VT100 Terminals
|
|
|
|
char CLRSCR[] = "\033[2J";
|
|
|
|
|
|
|
|
/** @brief Ein paar Millisekunden warten
|
|
|
|
*
|
|
|
|
* Dieser Variable muss atomar sein, weil es eine 16Bit Variable ist,
|
|
|
|
* die im Timer 0 verwendet wird.
|
|
|
|
* @param Zeit in Millisekunden, die gewartet werden soll
|
|
|
|
* @return void
|
|
|
|
*/
|
|
|
|
void DelayMilliSeconds(uint16_t ms)
|
|
|
|
{
|
|
|
|
t_delayms = 0;
|
|
|
|
// ResetMilliSeconds();
|
|
|
|
//ATOMIC_BLOCK(ATOMIC_FORCEON) {
|
|
|
|
while(t_delayms < ms);
|
|
|
|
//}
|
|
|
|
}
|
|
|
|
/** @brief Wert des Zählers für Millisekunden lesen
|
|
|
|
*
|
|
|
|
* Dieser Variable muss atomar sein, weil es eine 16Bit Variable ist,
|
|
|
|
* die im Timer 0 verwendet wird.
|
|
|
|
* @param none
|
|
|
|
* @return milliseconds
|
|
|
|
*/
|
|
|
|
uint16_t GetMilliSeconds(void)
|
|
|
|
{
|
|
|
|
uint16_t m;
|
|
|
|
ATOMIC_BLOCK(ATOMIC_FORCEON){
|
|
|
|
m = t_delayms;
|
|
|
|
}
|
|
|
|
return m;
|
|
|
|
}
|
|
|
|
/** @brief Setzt den Zähler für Millisekunden auf 0
|
|
|
|
*
|
|
|
|
* Dieser Variable muss atomar sein, weil es eine 16Bit Variable ist,
|
|
|
|
* die im Timer 0 verwendet wird.
|
|
|
|
* @param none
|
|
|
|
* @return none
|
|
|
|
*/
|
|
|
|
void ResetMilliSeconds(void)
|
|
|
|
{
|
|
|
|
//ATOMIC_BLOCK(ATOMIC_FORCEON){
|
|
|
|
t_delayms = 0;
|
|
|
|
//}
|
|
|
|
}
|
|
|
|
/** @brief SREG wieder herstellen und Interrupts erlauben
|
|
|
|
* @param none
|
|
|
|
* @return none
|
|
|
|
*/
|
|
|
|
void IntEnable(void)
|
|
|
|
{
|
|
|
|
SREG = sreg_tmp;
|
|
|
|
sei();
|
|
|
|
}
|
|
|
|
/** @brief SREG sichern und Interrupts verbieten
|
|
|
|
* @param none
|
|
|
|
* @return none
|
|
|
|
*/
|
|
|
|
void IntDisable(void)
|
|
|
|
{
|
|
|
|
sreg_tmp = SREG;
|
|
|
|
cli();
|
|
|
|
}
|
|
|
|
|
|
|
|
/** \brief EEPROM schreiben
|
|
|
|
*/
|
|
|
|
void WriteEEprom(void)
|
|
|
|
{
|
|
|
|
cli();
|
|
|
|
eeprom_write_byte(&ee_Dummy,0x55);
|
|
|
|
eeprom_write_byte(&ee_WpM, bConfig.WpM);
|
|
|
|
eeprom_write_byte(&ee_KeyerMode, bConfig.KeyerMode);
|
|
|
|
eeprom_write_word(&ee_SidetoneFreq, bConfig.SidetoneFreq);
|
|
|
|
eeprom_write_byte(&ee_TRX, bConfig.TRX);
|
|
|
|
eeprom_write_byte(&ee_SidetoneEnabled, bConfig.SidetoneEnabled);
|
|
|
|
eeprom_write_byte(&ee_WpMBpM, bConfig.WpMBpM);
|
|
|
|
eeprom_write_byte(&ee_Reverse, bConfig.Reverse);
|
|
|
|
eeprom_write_byte(&ee_WinkeyerEnabled, bConfig.WinkeyerEnabled);
|
|
|
|
eeprom_write_byte(&ee_Ratio, bConfig.Ratio);
|
|
|
|
eeprom_write_byte(&ee_Memory, bConfig.Memory);
|
|
|
|
eeprom_write_byte(&ee_RiseTime, bConfig.RiseTime);
|
|
|
|
eeprom_write_byte(&ee_RiseTimeCounter, bConfig.RiseTimeCounter);
|
|
|
|
eeprom_write_byte(&ee_DebounceTime, bConfig.DebounceTime);
|
|
|
|
sei();
|
|
|
|
}
|
|
|
|
|
|
|
|
void ReadEEpromWpM(void)
|
|
|
|
{
|
|
|
|
cli();
|
|
|
|
bConfig.WpM = eeprom_read_byte(&ee_WpM);
|
|
|
|
sei();
|
|
|
|
}
|
|
|
|
|
|
|
|
void WriteEEpromWpM(void)
|
|
|
|
{
|
|
|
|
cli();
|
|
|
|
eeprom_write_byte(&ee_WpM, bConfig.WpM);
|
|
|
|
sei();
|
|
|
|
}
|
|
|
|
|
|
|
|
void ReadEEprom(void)
|
|
|
|
{
|
|
|
|
sprintf(sdebug,"EEprom lesen\r\n");
|
|
|
|
SerialWriteString(sdebug);
|
|
|
|
cli();
|
|
|
|
bConfig.WpM = eeprom_read_byte(&ee_WpM);
|
|
|
|
bConfig.KeyerMode = eeprom_read_byte(&ee_KeyerMode);
|
|
|
|
bConfig.SidetoneFreq = eeprom_read_word(&ee_SidetoneFreq);
|
|
|
|
bConfig.TRX = eeprom_read_byte(&ee_TRX);
|
|
|
|
bConfig.SidetoneEnabled = eeprom_read_byte(&ee_SidetoneEnabled);
|
|
|
|
bConfig.WpMBpM = eeprom_read_byte(&ee_WpMBpM);
|
|
|
|
bConfig.Reverse = eeprom_read_byte(&ee_Reverse);
|
|
|
|
bConfig.WinkeyerEnabled = eeprom_read_byte(&ee_WinkeyerEnabled);
|
|
|
|
bConfig.Ratio = eeprom_read_byte(&ee_Ratio);
|
|
|
|
bConfig.Memory = eeprom_read_byte(&ee_Memory);
|
|
|
|
bConfig.RiseTime = eeprom_read_byte(&ee_RiseTime);
|
|
|
|
bConfig.RiseTimeCounter = eeprom_read_byte(&ee_RiseTimeCounter);
|
|
|
|
bConfig.DebounceTime = eeprom_read_byte(&ee_DebounceTime);
|
|
|
|
sei();
|
|
|
|
if(bConfig.WpM > 50) {
|
|
|
|
bConfig.WpM = 15;
|
|
|
|
WriteEEpromWpM();
|
|
|
|
}
|
|
|
|
if(bConfig.RiseTime > 10) {
|
|
|
|
bConfig.RiseTime = 10;
|
|
|
|
WriteEEprom();
|
|
|
|
}
|
|
|
|
if(bConfig.RiseTimeCounter > 6) {
|
|
|
|
bConfig.RiseTimeCounter = 6;
|
|
|
|
WriteEEprom();
|
|
|
|
}
|
|
|
|
if(bConfig.DebounceTime > 22) {
|
|
|
|
bConfig.DebounceTime = 25;
|
|
|
|
WriteEEprom();
|
|
|
|
}
|
|
|
|
sprintf(sdebug,"WpM : %i\r\n", bConfig.WpM);
|
|
|
|
SerialWriteString(sdebug);
|
|
|
|
sprintf(sdebug,"SidetoneFreq: %ul\r\n", bConfig.SidetoneFreq);
|
|
|
|
SerialWriteString(sdebug);
|
|
|
|
sprintf(sdebug,"WpMBpM : %i\r\n", bConfig.WpMBpM);
|
|
|
|
SerialWriteString(sdebug);
|
|
|
|
}
|
|
|
|
|
|
|
|
void SerialWriteChar(unsigned char data)
|
|
|
|
{
|
|
|
|
while(!(UCSR0A & (1<<UDRE0)));
|
|
|
|
UDR0 = data;
|
|
|
|
}
|
|
|
|
void SerialWriteString(char *s)
|
|
|
|
{
|
|
|
|
while(*s != 0x00)
|
|
|
|
SerialWriteChar(*s++);
|
|
|
|
}
|
|
|
|
|
|
|
|
/** @brief Read port pin of morse keys
|
|
|
|
*
|
|
|
|
* This function reads the input of
|
|
|
|
* the Paddle or Straight key.
|
|
|
|
* @params: Pin to read
|
|
|
|
* @return: State of pin
|
|
|
|
*/
|
|
|
|
uint8_t ReadKeyPin(uint8_t pin)
|
|
|
|
{
|
|
|
|
return(PIND & (1<<pin));
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
** SideToneOn
|
|
|
|
*/
|
|
|
|
void SideToneOn(void)
|
|
|
|
{
|
|
|
|
state_sidetoneoff = 0;
|
|
|
|
StateRiseTime = bConfig.RiseTime;
|
|
|
|
StateRiseTimeCounter = 0;
|
|
|
|
icnt = 0;
|
|
|
|
sbi(TIMSK1,OCIE1A);
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
** SideToneOff
|
|
|
|
*/
|
|
|
|
void SideToneOff(void)
|
|
|
|
{
|
|
|
|
state_sidetoneoff = 1;
|
|
|
|
StateRiseTime = 0;
|
|
|
|
StateRiseTimeCounter = 0;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
** TXKey
|
|
|
|
**
|
|
|
|
** Tastung TRX1, TRX2 oder beide
|
|
|
|
*/
|
|
|
|
void TXKey(uint8_t State, uint8_t SendingType)
|
|
|
|
{
|
|
|
|
if((State) && (KeyState == 0))
|
|
|
|
{
|
|
|
|
if(KeyTX)
|
|
|
|
{
|
|
|
|
SideToneOn();
|
|
|
|
sbi(PORTC,MORSE_LED);
|
|
|
|
KeyState = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if((State == 0) && (KeyState))
|
|
|
|
{
|
|
|
|
if(KeyTX)
|
|
|
|
{
|
|
|
|
SideToneOff();
|
|
|
|
cbi(PORTC,MORSE_LED);
|
|
|
|
}
|
|
|
|
KeyState = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/** \brief StraigtKey
|
|
|
|
*
|
|
|
|
* Check Straightkey
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
void CheckStraightKey(void)
|
|
|
|
{
|
|
|
|
if(PIND & (1<<STRAIGHT_KEY))
|
|
|
|
{
|
|
|
|
TXKey(0,MAN);
|
|
|
|
StateStraightKeyPressed = NO_KEY_PRESSED;
|
|
|
|
} else {
|
|
|
|
if(StateStraightKeyPressed == NO_KEY_PRESSED)
|
|
|
|
{
|
|
|
|
StateStraightKeyPressed = KEY_PRESSED_DEBOUNCE;
|
|
|
|
TimerStraightKeyPressed = 0;
|
|
|
|
}
|
|
|
|
if(StateStraightKeyPressed == KEY_PRESSED)
|
|
|
|
{
|
|
|
|
TXKey(1,MAN);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/** \brief CheckPaddles
|
|
|
|
**
|
|
|
|
*/
|
|
|
|
void CheckPaddles(void)
|
|
|
|
{
|
|
|
|
CheckDitPaddle();
|
|
|
|
CheckDahPaddle();
|
|
|
|
}
|
|
|
|
/** \brief CheckDitPaddle
|
|
|
|
*
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
void CheckDitPaddle(void)
|
|
|
|
{
|
|
|
|
static uint8_t pinvalue = 0;
|
|
|
|
|
|
|
|
if(PaddleMode == PADDLE_NORMAL) // no reverse paddle
|
|
|
|
pinvalue = PIND & (1<<LEFT_PADDLE);
|
|
|
|
else
|
|
|
|
pinvalue = PIND & (1<<RIGHT_PADDLE); // reverse paddle
|
|
|
|
|
|
|
|
if(pinvalue == 0) // ditpaddle pressed
|
|
|
|
{
|
|
|
|
if(StatePaddleKeyPressed == NO_KEY_PRESSED) // First time, start debounce
|
|
|
|
{
|
|
|
|
StatePaddleKeyPressed = KEY_PRESSED_DEBOUNCE;
|
|
|
|
TimerPaddleKeyPressed = 0;
|
|
|
|
}
|
|
|
|
if(StatePaddleKeyPressed == KEY_PRESSED) // Debounce ok
|
|
|
|
{
|
|
|
|
DitBuffer = 1;
|
|
|
|
StatePaddleKeyPressed = NO_KEY_PRESSED;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
** CheckDahPaddle
|
|
|
|
*/
|
|
|
|
void CheckDahPaddle(void)
|
|
|
|
{
|
|
|
|
static uint8_t pinvalue = 0;
|
|
|
|
|
|
|
|
if(PaddleMode == PADDLE_NORMAL) // no reverse paddle
|
|
|
|
pinvalue = PIND & (1<<RIGHT_PADDLE);
|
|
|
|
else
|
|
|
|
pinvalue = PIND & (1<<LEFT_PADDLE); // reverse paddle
|
|
|
|
|
|
|
|
if(pinvalue == 0)
|
|
|
|
{
|
|
|
|
if(StatePaddleKeyPressed == NO_KEY_PRESSED)
|
|
|
|
{
|
|
|
|
StatePaddleKeyPressed = KEY_PRESSED_DEBOUNCE;
|
|
|
|
TimerPaddleKeyPressed = 0;
|
|
|
|
}
|
|
|
|
if(StatePaddleKeyPressed == KEY_PRESSED) // Debounce ok
|
|
|
|
{
|
|
|
|
if(DahBuffer == 0)
|
|
|
|
{
|
|
|
|
DahCounter++;
|
|
|
|
DitCounter = 0;
|
|
|
|
}
|
|
|
|
DahBuffer = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/** @brief Schleife für die Dauer eines Zeichenelements Dit oder Dah
|
|
|
|
*
|
|
|
|
* Bei einer Geschwindigkeit von 12WpM (60BpM) hat ein Dit
|
|
|
|
* eine Länge von 100ms, ein Dah eine Länge von 300ms. In
|
|
|
|
* dieser Zeit müssen die Paddle Eingänge weiter abgefragt
|
|
|
|
* werden, damit keine Zeichen verloren gehen.
|
|
|
|
*
|
|
|
|
* @param len Count of dits * weigthing / 50
|
|
|
|
* @param AddMiliSeconds Increase pausing between elements
|
|
|
|
* @param SendingType AUTO or MAN
|
|
|
|
* @return none
|
|
|
|
*/
|
|
|
|
void ElementLoop(uint8_t len, uint8_t AddMilliSeconds, uint8_t SendingType)
|
|
|
|
{
|
|
|
|
uint16_t LoE; // lengths of one element in ms
|
|
|
|
uint16_t ticks; // lengths of elements + AddMilliSeconds in ms
|
|
|
|
|
|
|
|
if((len == 0) || (len < 0))
|
|
|
|
return;
|
|
|
|
|
|
|
|
LoE = 1200/WpM; // Calculate length of one element
|
|
|
|
ticks = LoE * len + AddMilliSeconds; //
|
|
|
|
t_elementlength = 0; // Reset Timer 0 variable
|
|
|
|
while(t_elementlength < ticks)
|
|
|
|
{
|
|
|
|
|
|
|
|
if((KeyerMode == IAMBIC_A) && (!(PIND & (1<<LEFT_PADDLE))) && (!(PIND & (1<<RIGHT_PADDLE))))
|
|
|
|
IambicFlag = 1;
|
|
|
|
|
|
|
|
if(SendStatus == SENDING_DIT)
|
|
|
|
CheckDahPaddle();
|
|
|
|
else if(SendStatus == SENDING_DAH)
|
|
|
|
CheckDitPaddle();
|
|
|
|
else {
|
|
|
|
CheckDahPaddle();
|
|
|
|
CheckDitPaddle();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if((KeyerMode == IAMBIC_A) && (IambicFlag) && (PIND & (1<<LEFT_PADDLE)) && (PIND & (1<<RIGHT_PADDLE)))
|
|
|
|
{
|
|
|
|
IambicFlag = 0;
|
|
|
|
DitBuffer = 0;
|
|
|
|
DahBuffer = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
** void SendDit(uint8_t SendingType)
|
|
|
|
*/
|
|
|
|
void SendDit(uint8_t SendingType)
|
|
|
|
{
|
|
|
|
SendStatus = SENDING_DIT;
|
|
|
|
TXKey(1,SendingType);
|
|
|
|
ElementLoop(1,0,SendingType);
|
|
|
|
TXKey(0,SendingType);
|
|
|
|
ElementLoop(1,0,SendingType);
|
|
|
|
}
|
|
|
|
/** \brief Send a dah
|
|
|
|
** A Dah with weight = 50 has the length of 3 Dits.
|
|
|
|
*/
|
|
|
|
void SendDah(uint8_t SendingType)
|
|
|
|
{
|
|
|
|
SendStatus = SENDING_DAH;
|
|
|
|
TXKey(1,SendingType);
|
|
|
|
ElementLoop(3,0,SendingType);
|
|
|
|
TXKey(0,SendingType);
|
|
|
|
ElementLoop(3,0,SendingType);
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
** Set sidetone frequency
|
|
|
|
*/
|
|
|
|
void SetFrequency(uint16_t f)
|
|
|
|
{
|
|
|
|
IntDisable();
|
|
|
|
OCR1A = (F_CPUPRESIN / f) - 1;
|
|
|
|
IntEnable();
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
** Output a tone width frequency f and duration duration
|
|
|
|
**
|
|
|
|
*/
|
|
|
|
void Tone(uint16_t f, uint8_t duration)
|
|
|
|
{
|
|
|
|
SetFrequency(f);
|
|
|
|
SideToneOn();
|
|
|
|
DelayMilliSeconds(duration);
|
|
|
|
SideToneOff();
|
|
|
|
SetFrequency(bConfig.SidetoneFreq);
|
|
|
|
}
|
|
|
|
void Boop(void)
|
|
|
|
{
|
|
|
|
Tone(600,100);
|
|
|
|
}
|
|
|
|
void Beep(void)
|
|
|
|
{
|
|
|
|
Tone(1200,100);
|
|
|
|
}
|
|
|
|
void BeepBoop(void)
|
|
|
|
{
|
|
|
|
sbi(PORTB,AUDIO_EN);
|
|
|
|
DelayMilliSeconds(10);
|
|
|
|
Beep();
|
|
|
|
DelayMilliSeconds(100);
|
|
|
|
Boop();
|
|
|
|
}
|
|
|
|
|
|
|
|
void SendChar(unsigned char c)
|
|
|
|
{
|
|
|
|
switch(c)
|
|
|
|
{
|
|
|
|
// Buchstaben
|
|
|
|
case 'A': SendDit(AUTO); SendDah(AUTO); break;
|
|
|
|
case 'B': SendDah(AUTO); SendDit(AUTO); SendDit(AUTO); SendDit(AUTO); break;
|
|
|
|
case 'C': SendDit(AUTO); SendDah(AUTO); SendDit(AUTO); SendDah(AUTO); break;
|
|
|
|
case 'D': SendDah(AUTO); SendDit(AUTO); SendDit(AUTO); break;
|
|
|
|
case 'E': SendDit(AUTO); break;
|
|
|
|
case 'F': SendDit(AUTO); SendDah(AUTO); SendDit(AUTO); SendDit(AUTO); break;
|
|
|
|
case 'G': SendDah(AUTO); SendDah(AUTO); SendDit(AUTO); break;
|
|
|
|
case 'H': SendDit(AUTO); SendDit(AUTO); SendDit(AUTO); SendDit(AUTO); break;
|
|
|
|
case 'I': SendDit(AUTO); SendDit(AUTO); break;
|
|
|
|
case 'J': SendDit(AUTO); SendDah(AUTO); SendDah(AUTO); SendDah(AUTO); break;
|
|
|
|
case 'K': SendDah(AUTO); SendDit(AUTO); SendDah(AUTO); break;
|
|
|
|
case 'L': SendDit(AUTO); SendDah(AUTO); SendDit(AUTO); SendDit(AUTO); break;
|
|
|
|
case 'M': SendDah(AUTO); SendDah(AUTO); break;
|
|
|
|
case 'N': SendDah(AUTO); SendDit(AUTO); break;
|
|
|
|
case 'O': SendDah(AUTO); SendDah(AUTO); SendDah(AUTO); break;
|
|
|
|
case 'P': SendDit(AUTO); SendDah(AUTO); SendDah(AUTO); SendDit(AUTO); break;
|
|
|
|
case 'Q': SendDah(AUTO); SendDah(AUTO); SendDit(AUTO); SendDah(AUTO); break;
|
|
|
|
case 'R': SendDit(AUTO); SendDah(AUTO); SendDit(AUTO); break;
|
|
|
|
case 'S': SendDit(AUTO); SendDit(AUTO); SendDit(AUTO); break;
|
|
|
|
case 'T': SendDah(AUTO); break;
|
|
|
|
case 'U': SendDit(AUTO); SendDit(AUTO); SendDah(AUTO); break;
|
|
|
|
case 'V': SendDit(AUTO); SendDit(AUTO); SendDit(AUTO); SendDah(AUTO); break;
|
|
|
|
case 'W': SendDit(AUTO); SendDah(AUTO); SendDah(AUTO); break;
|
|
|
|
case 'X': SendDah(AUTO); SendDit(AUTO); SendDit(AUTO); SendDah(AUTO); break;
|
|
|
|
case 'Y': SendDah(AUTO); SendDit(AUTO); SendDah(AUTO); SendDah(AUTO); break;
|
|
|
|
case 'Z': SendDit(AUTO); SendDit(AUTO); SendDah(AUTO); SendDah(AUTO); break;
|
|
|
|
// Zahlen
|
|
|
|
case '0': SendDah(AUTO); SendDah(AUTO); SendDah(AUTO); SendDah(AUTO); SendDah(AUTO); break;
|
|
|
|
case '1': SendDit(AUTO); SendDah(AUTO); SendDah(AUTO); SendDah(AUTO); SendDah(AUTO); break;
|
|
|
|
case '2': SendDit(AUTO); SendDit(AUTO); SendDah(AUTO); SendDah(AUTO); break;
|
|
|
|
case '3': SendDit(AUTO); SendDit(AUTO); SendDit(AUTO); SendDah(AUTO); SendDah(AUTO); break;
|
|
|
|
case '4': SendDit(AUTO); SendDit(AUTO); SendDit(AUTO); SendDit(AUTO); SendDah(AUTO); break;
|
|
|
|
case '5': SendDit(AUTO); SendDit(AUTO); SendDit(AUTO); SendDit(AUTO); SendDit(AUTO); break;
|
|
|
|
case '6': SendDah(AUTO); SendDit(AUTO); SendDit(AUTO); SendDit(AUTO); SendDit(AUTO); break;
|
|
|
|
case '7': SendDah(AUTO); SendDah(AUTO); SendDit(AUTO); SendDit(AUTO); SendDit(AUTO); break;
|
|
|
|
case '8': SendDah(AUTO); SendDah(AUTO); SendDah(AUTO); SendDit(AUTO); SendDit(AUTO); break;
|
|
|
|
case '9': SendDah(AUTO); SendDah(AUTO); SendDah(AUTO); SendDah(AUTO); SendDit(AUTO); break;
|
|
|
|
// Sonderzeichen
|
|
|
|
case '=': SendDah(AUTO); SendDit(AUTO); SendDit(AUTO); SendDit(AUTO); SendDah(AUTO); break;
|
|
|
|
case '/': SendDah(AUTO); SendDit(AUTO); SendDit(AUTO); SendDah(AUTO); SendDit(AUTO); break;
|
|
|
|
case '.': SendDit(AUTO); SendDah(AUTO); SendDit(AUTO); SendDah(AUTO); SendDit(AUTO); SendDah(AUTO); break;
|
|
|
|
case ',': SendDah(AUTO); SendDah(AUTO); SendDit(AUTO); SendDit(AUTO); SendDah(AUTO); SendDah(AUTO); break;
|
|
|
|
case '?': SendDit(AUTO); SendDit(AUTO); SendDah(AUTO); SendDah(AUTO); SendDit(AUTO); SendDit(AUTO); break;
|
|
|
|
case '@': SendDit(AUTO); SendDah(AUTO); SendDah(AUTO); SendDit(AUTO); SendDah(AUTO); SendDit(AUTO); break;
|
|
|
|
}
|
|
|
|
ElementLoop(3,0,WpM);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|