Arduino.ru

Благодарю!

Чуток подчистил старый скетч, оставил разбор только верхнего регистра  )))
 

/*
  Простой телеграфный маяк для экспериментов
 
  Исходный код:
  Written by Nicola Salsotto IN3GJH
  https://github.com/NicoVarg99
 
  Модификация сделана:
  UA6HJQ 18.11.2018 (добавлено управление радиостанцией)
  UA6EM 12/04/2019 (добавлен разбор символов нижнего регистра)
  UA6EM & сотоварищи 16/04/2019 (работа с EEPROM -начало,убран блокирующий delay())
 
  Интервал между передачей:
  10мин= 600000 (передача примерно 20 секунд)
  5мин = 300000
  3мин = 180000
  2мин = 120000
*/
 
#include <EEPROM.h>
int eeAddress = 0;    //EEPROM address to start reading from
int eeFlag = 73;      // в ячейке 73 сохраняем флаг ==73, что структура сохранялась
int eeData;           // сюда читаем байт из ячейки флага
struct MyBeacon {
char call_sign[20];
char loc[7];
};
MyBeacon mb = {"UA6EM", "LN14AG"};  // структура для отправки
String my_call;
String my_loc;

#define SPEED (20)  //скорость в WPM
#define DOTLEN (1200/SPEED)
#define DASHLEN (4*(1200/SPEED))
//#define PAUSE (180000)  //пауза между передачами маяка в милисекундах
#define PAUSE (10000)  //пауза между передачами маяка в милисекундах

int txPin=10;       //управление PTT
int ledPin=13;      //мигать встроенным светодиодом или подключить внешний на пин 13
int tonePin=5;      //выход звука
int toneFreq=800;   //Частота звука (выбирайте между 800 - 1500Гц)
unsigned long old_millis;

void sendMsg(char*);
void dash();
void dot();


void setup()
  {
    pinMode(ledPin, OUTPUT);
    pinMode(txPin, OUTPUT);
    Serial.begin(115200);
    old_millis = millis();
   }


void loop()
  {
    if(millis() - old_millis >= PAUSE){
    eeData = EEPROM.read(eeFlag);
    if (eeData == 73){
    EEPROM.get(eeAddress, mb);     // получить данные из EEPROM   
    }
    digitalWrite(txPin, HIGH);
    delay(900);                    //txdelay - задержка после нажатия PTT
    sendMsg(mb);                   //текст маяка - проба
    delay(20);
    digitalWrite(txPin, LOW);
    old_millis = millis();
     }
 // процедура чтения порта будет тут )))
    Serial.println("Введите позывной сигнал");
    delay(3000);
    while(Serial.available()) {
    my_call = Serial.readString();
    }
    Serial.print("Ваш позывной - ");
     Serial.println(my_call);
      Serial.println();
      
      Serial.println("Введите ваш локатор");
      delay(3000);
      while(Serial.available()) {
      my_loc = Serial.readString();
    }
    Serial.print("Ваш локатор - ");
     Serial.println(my_loc);
      Serial.println();

 //    MyBeacon mb = {my_call, my_loc};
   
     
 } // END

 
//*** передаём тире ***
void dash()
  {
    digitalWrite(ledPin, HIGH);
    tone(tonePin, toneFreq);
    delay(DASHLEN);
    digitalWrite(ledPin, LOW);
    noTone(tonePin);
    delay(DOTLEN);
  }

//*** передаём точку ***
void dot()
  {
    digitalWrite(ledPin, HIGH) ;
    tone(tonePin, toneFreq);
    delay(DOTLEN);
    digitalWrite(ledPin, LOW);
    noTone(tonePin);
    delay(DOTLEN);
  }

// *** функция разбора и передачи строки ***
// void sendMsg(char *str){
//  Строка для отправки сформируется внутри,
//  а при выходе будет освобождена
//
void sendMsg(MyBeacon & mbStr) {
  static const char middle[] = "BEACON QRA is"; // серёдка сообщения
  static const int8_t sizeMiddle = strlen(middle);  // длина серёдки сообщения
  static const int8_t repeatCounter = 2;  // сколько раз повторять позывной и ... тот хвост
  //  
  // strSize - длина строки для отправки по sms, включая терминальный ноль.
  const int8_t strSize = sizeMiddle + (strlen(mbStr.call_sign) + strlen(mbStr.loc) + 2) * repeatCounter + 1;
  char str[strSize];
  //
  // Заполняем строку
  str[0] = '\0';
  for (int8_t i = 0; i < repeatCounter; i++) {
    strcat(str, mbStr.call_sign);
    strcat(str, " ");
  }
  strcat(str, middle);
  for (int8_t i = 0; i < repeatCounter; i++) {
    strcat(str, " ");
    strcat(str, mbStr.loc); // Собрали строку текста Маяка
  }
  //
  //  Теперь отправляем строку str как там надо
  //
  // Serial.println(str);
  // String str1 = str;
  // str1.toUpperCase();
  // Serial.println(str1);

  delay(500);
  for(int8_t i=0;i<strlen(str);i++)
  {
    switch (toupper(str[i]))  // тут я рыбу заворачивал )))
    {
    case 'A':
      dot();dash();break;
    case 'B':
      dash();dot();dot();dot();break;
    case 'C':
      dash();dot();dash();dot();break;
    case 'D':
      dash();dot();dot();break;
    case 'E':
      dot();break;
    case 'F':
      dot();dot();dash();dot();break;
    case 'G':
      dash();dash();dot();break;
    case 'H':
      dot();dot();dot();dot();break;
    case 'I':
      dot();dot();break;
    case 'J':
      dot();dash();dash();dash();break;
    case 'K':
      dash();dot();dash();break;
    case 'L':
      dot();dash();dot();dot();break;
    case 'M':
      dash();dash();break;
    case 'N':
      dash();dot();break;
    case 'O':
      dash();dash();dash();break;
    case 'P':
      dot();dash();dash();dot();break;
    case 'Q':
      dash();dash();dot();dash();break;
    case 'R':
      dot();dash();dot();break;
    case 'S':
      dot();dot();dot();break;
    case 'T':
      dash();break;
    case 'U':
      dot();dot();dash();break;
    case 'V':
      dot();dot();dot();dash();break;
    case 'W':
      dot();dash();dash();break;
    case 'X':
      dash();dot();dot();dash();break;
    case 'Y':
      dash();dot();dash();dash();break;
    case 'Z':
      dash();dash();dot();dot();break;
    case ' ':
      delay(DOTLEN*5);break;
    case '.':
      dot();dash();dot();dash();dot();dash();break;
    case ',':
      dash();dash();dot();dot();dash();dash();break;
    case ':':
      dash();dash();dash();dot();dot();break;
    case '?':
      dot();dot();dash();dash();dot();dot();break;
    case '\'':
      dot();dash();dash();dash();dash();dot();break;
    case '-':
      dash();dot();dot();dot();dot();dash();break;
    case '/':
      dash();dot();dot();dash();dot();break;
    case '(':
    case ')':
      dash();dot();dash();dash();dot();dash();break;
    case '\"':
      dot();dash();dot();dot();dash();dot();break;
    case '@':
      dot();dash();dash();dot();dash();dot();break;
    case '=':
      dash();dot();dot();dot();dash();break;
    case '0':
     dash();dash();dash();dash();dash();break;
    case '1':
     dot();dash();dash();dash();dash();break;
    case '2':
     dot();dot();dash();dash();dash();break;
    case '3':
     dot();dot();dot();dash();dash();break;
    case '4':
     dot();dot();dot();dot();dash();break;
    case '5':
     dot();dot();dot();dot();dot();break;
    case '6':
     dash();dot();dot();dot();dot();break;
    case '7':
     dash();dash();dot();dot();dot();break;
    case '8':
     dash();dash();dash();dot();dot();break;
    case '9':
     dash();dash();dash();dash();dot();break;

    }
    delay(2*DOTLEN);
   }
  } // окончание функции передачи текста маяка

Да, я знаю. Вчера уже понял, когда ноут сложил, а сегодня с утра начали о формате хранения спорить, поэтому решил не спешить, а посмотреть, чем дело кончится. А вообще -  надо как-то вот так:

for (uint8_t l = 0; l < 8; l++) {
    uint8_t currentBit = bitRead(morseCode[i].sequence, l);
    if (!sequenceStarted) {
       sequenceStarted = currentBit; 
       continue; 
     }
     currentBit ? dot() : dash() ;            
}

Давно это было... Откопал в архиве.

/*
 * Генерация Морзе
 * // доступные процедуры
 * morze_init - инициализация блока 
 * morze_stop 
 * morze_start , без параметра будет установлен SOS
 * morze_proc - обработка, должно крутиться в лупе
 * SIGN_xxxx - макросы вывода сигналов
 * 
 */

#define _POINT_DELAY        100               // по умолчанию вспышка 25 миллисекунд для точки
#define _TIRE_DELAY         _POINT_DELAY * 3   // по умолчанию вспышка 100 миллисекунд для тире 
#define _POINT_TIRE_DELAY   _POINT_DELAY       // по умолчанию пауза между точками и тире в букве 175 миллисекунд  
#define _SIMB_DELAY         _POINT_DELAY * 3   // по умолчанию пауза между буквами 1250 миллисекунд
#define _LEXEM_DELAY        _POINT_DELAY * 7   // по умолчанию пауза между словами

uint16_t point_delay = _POINT_DELAY; // задержки морзянки
uint16_t tire_delay = _TIRE_DELAY;
uint16_t pt_delay = _POINT_TIRE_DELAY;
uint16_t simb_delay = _SIMB_DELAY;
uint16_t lex_delay = _LEXEM_DELAY;
bool morseStarted = false;

#define STRING_SIZE        4                 // максимальный размер передаваемой лексемы

//#define SIGN_ON     digitalWrite(LED_BUILTIN, HIGH)  // макрос включения 
//#define SIGN_OFF    digitalWrite(LED_BUILTIN, LOW)  // макрос включения 
//#define SIGN_INIT   pinMode(LED_BUILTIN, OUTPUT) // инициализация

//ТАБЛИЦА ГЕНЕРАЦИИ БУКВЫ АЗБУКИ МОРЗЕ
//                    ''    
//                    0     1     2      3      4       5     6      7       8     9
//                    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
// описание буквы 0-точка, 1 -тире 
const PROGMEM uint8_t symb[]={B00000, 
                   B11111,B01111,B00111,B00011,B00001,B00000,B10000,B11000,B11100,B11110,
                   B00001,B01000,B01010,B00100,B00000,B00010,B00110,B00000,B00000,B00111,
                   B00101,B00100,B00011,B00010,B00111,B00110,B01101,B00010,B00000,B00001,
                   B00001,B00001,B00011,B01001,B01011,B01100};
// описание буквы длинна буквы
const PROGMEM uint8_t  msc[]={B00000,
                   B10000,B10000,B10000,B10000,B10000,B10000,B10000,B10000,B10000,B10000,
                   B00010,B01000,B01000,B00100,B00001,B01000,B00100,B01000,B00010,B01000,
                   B00100,B01000,B00010,B00010,B00100,B01000,B01000,B00100,B00100,B00001,
                   B00100,B01000,B00100,B01000,B01000,B01000};

// настройки индикации морзе предполагается изменять по XBEE, поэтому переменные

bool is_on = false;
uint8_t morze_buf[STRING_SIZE+1]; // буфер отправляемого слова 

volatile unsigned long morze_timer = 0; // таймер засечки периода отправки знака
volatile unsigned long morze_delay = 0; // продолжительность текущей паузы
volatile uint8_t morze_mask; // маска отправки
volatile uint8_t morze_counter = 0xFF; // номер отправляемого символа

void set_delay(uint32_t delay){ // установка задержки
   morze_delay = delay;
   morze_timer = millis();
}

void morze_stop(){ // остановить морзянку
   SIGN_INIT;
   is_on = false;
   SIGN_OFF;
   morze_delay = 0;
   morze_mask = 0;
   morze_counter = 0xFF;
   morseStarted = false;
}

uint8_t simb_check(char in) { // проверка-корректировка символов в существующий диапазон
   uint8_t out = 0;
   if (in < '0') {
      //...
   } else if (in <= '9') { 
      return in - 0x2F; // если цифра , то корректируем на 0x2F;
   } else if (in < 'A') {
      //...
   } else if (in <= 'Z') { 
      return in - 0x36; // заглавные буквы до Z, в нашей таблице с 11 до 37      
   } else if (in < 'a') {
     // ...
   } else if (in <= 'z') { 
      return in - 0x56; // маленькие, передаем как заглавные буквы до z, в нашей таблице с 11 до 37   
   }
   return 0;
}

void morze_init(String & lex) {
   morze_stop();
   uint8_t i=0;   
   while ((i<lex.length()) && (i < STRING_SIZE)) {
      morze_buf[i] = simb_check(lex[i]);
      i++;
   }
   if (i < STRING_SIZE) morze_buf[i] = 0; 
}

void morze_init(){
   String lex = F("SOS");
   morze_init(lex);
}

bool morze_start(){ // запустить морзянку
   if (morseStarted == false) {
      morze_stop();
      morseStarted = true;
      if (morze_buf[0]>0) {
          set_delay(1); 
          return true;
      } else {
          morze_stop();
          return false;
      }
   }
}

bool morze_start(String lex){
   morze_init(lex);
   return morze_start();
}

void morze_proc(){ // цикл сигнализации 
   if ((morze_delay != 0) && (millis() - morze_timer >= morze_delay)) { // работаем
      static char cur_simb;
      if (morze_mask == 0) { // буква уже передана 
         set_delay(simb_delay); // пауза между буквами
         //Serial.println();
         if ((morze_counter >= STRING_SIZE) || (morze_buf[morze_counter]==0)) { // конец буфера 
            if (morze_counter > 1) set_delay(lex_delay); //если в буфере больше одной буквы  
            morze_counter = 0; // снова в начало буфера
         } else morze_counter++; // или к следующему символу
         cur_simb = morze_buf[morze_counter];
         morze_mask = pgm_read_byte_near(msc+cur_simb); // загрузить маску
         cur_simb = pgm_read_byte_near(symb+cur_simb); // загрузить последовательность точек тире
      } else if (!(is_on)) { // если не светится
         SIGN_ON;
         is_on = true;
         if (morze_mask & cur_simb) { 
            set_delay(tire_delay); // тире
            //Serial.print('-');
         } else {
            set_delay(point_delay); // точка
            //Serial.print('.');
         }
      } else {
         SIGN_OFF;
         is_on = false;
         morze_mask >>= 1; // маску к сл. знаку текущей буквы
         set_delay(pt_delay); // пауза между точками и тире
      }
   }
}

Вдруг кому пригодится. Не оптимально, но на тичеринг я не претендую.

for (uint8_t l = 0; l < 8; l++) {
    uint8_t currentBit = bitRead(morseCode[i].sequence, l);
    if (!sequenceStarted) {
       sequenceStarted = currentBit; 
       continue; 
     }
     currentBit ? dot() : dash() ;            
}

Да, заработало, еще бы поправить указатель в строке сдвигать для чтения следующего байта

thePhrase++ для сдвига указателя и нужно было.

Так будет проще?

char thePhrase[] = "Yabcdefgh";

void printStr(char* _thePhrase) {
  while (*_thePhrase) {
    Serial.print(*_thePhrase);
    _thePhrase++;
  }
}

void setup() {
  Serial.begin(9600);
  printStr(thePhrase);
}

void loop() {}

#define SPEED (20)  //скорость в WPM
#define DOTLEN (1200/SPEED)
#define DASHLEN (4*(1200/SPEED))
//#define PAUSE (180000)  //пауза между передачами маяка в милисекундах
#define PAUSE (10000)  //пауза между передачами маяка в милисекундах

int txPin=10;       //управление PTT
int ledPin=13;      //мигать встроенным светодиодом или подключить внешний на пин 13
int tonePin=5;      //выход звука
int toneFreq=800;   //Частота звука (выбирайте между 800 - 1500Гц)
unsigned long old_millis;

char thePhrase[] = "UA6EM.UA6EM.BEACON.QRA.IS.LN14AG.LN14AG";

typedef struct {
  char letter;
  uint8_t sequence;
} morseCode_t;

//  B11101000 
//   ...-S   <- S - start bit
morseCode_t morseCode[]= {
  {'A', B01100000},  {'B', B11101000},  {'C', B10101000},
  {'D', B11010000},  {'E', B11000000},  {'F', B10111000},
  {'G', B10010000},  {'H', B11111000},  {'I', B11100000},
  {'J', B00011000},  {'K', B01010000},  {'L', B11011000},
  {'M', B00100000},  {'N', B10100000},  {'O', B00010000},
  {'P', B10011000},  {'Q', B01001000},  {'R', B10110000},
  {'S', B11110000},  {'T', B01000000},  {'U', B01110000},
  {'V', B01111000},  {'W', B00110000},  {'X', B01101000},
  {'Y', B00101000},  {'Z', B11001000},  {'0', B00000100},
  {'1', B00001100},  {'2', B00011100},  {'3', B00111100},
  {'4', B01111100},  {'5', B11111100},  {'6', B11110100},
  {'7', B11100100},  {'8', B11000100},  {'9', B10000100},
  {' ', B10000000},
};

void setup() {
    pinMode(ledPin, OUTPUT);
    pinMode(txPin, OUTPUT);
    Serial.begin(115200);
    old_millis = millis();
}

//*** передаём тире ***
void dash()
  {
    digitalWrite(ledPin, HIGH);
    tone(tonePin, toneFreq);
    delay(DASHLEN);
    digitalWrite(ledPin, LOW);
    noTone(tonePin);
    delay(DOTLEN);
  }

//*** передаём точку ***
void dot()
  {
    digitalWrite(ledPin, HIGH) ;
    tone(tonePin, toneFreq);
    delay(DOTLEN);
    digitalWrite(ledPin, LOW);
    noTone(tonePin);
    delay(DOTLEN);
  }

void sendBeacon(char* _thePhrase) {
  while (*_thePhrase) {
        for(int8_t i=0; i<sizeof(thePhrase); i++)
       {if(*_thePhrase == ".") delay(15*DOTLEN);
        if (toupper(*_thePhrase) == morseCode[i].letter) {
        uint8_t sequenceStarted = false;
         for (uint8_t l = 0; l < 8; l++) {
         uint8_t currentBit = bitRead(morseCode[i].sequence, l);
        if (!sequenceStarted) {
        sequenceStarted = currentBit; 
        continue; 
              }
     currentBit ? dot() : dash() ;            
             }
           }
          }
     _thePhrase++;
     delay(2*DOTLEN);
 }
}

void loop() {
 if(millis() - old_millis >= PAUSE){
     sendBeacon(thePhrase);
     old_millis = millis();
 }
}

Ну, избавьтесь же Вы от букв. Зачем они Вам? Это И доп. расход памяти, И доп. расход времени на их поиск

Кстати, глянул на поиск - там у Вас вообще что-то странное написано в #105 (строки 64-79)

del

А проверять нечего, там ж очевидно ерунда написана в #112 в строках №№67-83 Вы за логикой-то проследите!

del

Может как то так (не проверял)

void sendBeacon(char* _thePhrase) {
   while (*_thePhrase) {
      for(int8_t i=0;i<strlen(_thePhrase);i++){
         if (toupper(*_thePhrase) == morseCode[i].letter) {
            uint8_t buff=morseCode[i].sequence;
            uint8_t sequenceMask=B10000000;
            uint8_t lengthMask=B01111111;
            while(buff & lengthMask){
               if(buff & sequenceMask){ 
                  dot();
                  buff-=sequenceMask;
               } else {
                  dash() ;            
               }
               sequenceMask>>=1;
               lengthMask-=sequenceMask;
            }
            break;
          }
      }
     _thePhrase++;
   }
}

brokly, ну вот смотри. в строке №4 ты берёте morseCode[i]. При этом i у тебя изменяется от 0 до длины сообщения. Тебя это не смущает? А если длина сообщения мбольше длины массива morseCode? Или меньше? Тут напутано с логикой.

Брукли, там просто strlen() не пришей к кобыле хвост... Товарищ методом научного коммунизма пишет скетч. Интересно, чем это закончится.

Я исправился

Сплошные костыли правда...но работает )))

Дык я и не пытался это править :) Проглядел:) Я только бред с отправкой буквы поправил :) Я туда даже не смотрел :) Там явно таблица нужна. Как ее сделать я чуток выше нарисовал.

Ну если очень надо так то наверное имеет смысл "strlen(_thePhrase)" заменить на "sizeof(morseCode)/sizeof(morseCode[0])" :)

Да, нет в этом никакого смысла. Имеет смысл делать таблицей, как у Вас.

Чтобы таблица была покороче, можно начинать её с нужного символа, а из элемента строки его вычитать. И всё будет по уму.

Тут ведь из-за этого цикла получается квадратичное время (длина строки Х длину таблицы). А нафига?

String::c_str()

О... да мы еще не дошли до верхней половины ASCII. Вроде как кириллица тоже морзянкой отбивается.

Там сопоставлены русским буквам англицкие, и помоему знаки добавлены и пару букв. Это будет еще кусок таблицы и все.

Дет, это ему не поможет в поиске конца массива структур :)

Для Маяка не актуально, там только латиница

Склоняюсь, что надо ставить 8 символьный дисплейчик на две строки, пару кнопок и энкодер, то-есть, полностью автономное устройство делать

Показательный пост прямо: как при отсутствии внятного ТЗ можно два дня делать получасовую работу.

Да. Куды я влез своими куриными мозгами. Узбагоюсь, пожалуй. 

ТЗ и скетчи вещи несовместимые, не убивай свободного художника )))

 а мне и не нужен конец массива структур, мне надо писать в структуру отдельные элементы и, похоже массивы char[] в структуре тоже надо собирать посимвольно, что совсем не комильфо

А раз не нужен, то и нефига его в цикле перебирать... Так мучаетесь, аж больно. Что нужно то, конкретнее, я уж готов сам написать.

И ни на что это не похоже... ваще.

Сделай нам красиво, Брукли.

Красиво - не смогу :( 

Может это я туплю ? Ну так объясните

   while (*_thePhrase) { // ползем по стрингу
      for(int8_t i=0;i<strlen(_thePhrase);i++){ // А ВОТ ЭТО ЧТО ДЕЛАЕМ ?  
          //...
       }
     _thePhrase++;
   }

Какие же это мучения - это "наслажденье битвой жизни" )))
Евгению Петровичу не понравилось в исходном тексте, что разбор выполнен через CASE, это попытка от этого уйти, а основное - иметь возможность внесения текста с терминала и сохранение-чтение в-из EEPROM

не верю ))) не может человек надевающий такие гламурные очки не сделать красиво ....

А мне кажется, ему другое не понравилось....

      for(int8_t i=0;i<strlen(_thePhrase);i++){ // А ВОТ ЭТО ЧТО ДЕЛАЕМ ?  

Ну что же тут непонятного?

«Пока враг изучает наши карты, мы меняем ландшафт, причем вручную.
Враг теряется на незнакомой местности и переходит в полную небоеспособность.
В этом смысл. В этом наша стратегия».

Я сегодня не пил, может поэтому не понимаю ?

   while (*_thePhrase) { // ползем по стрингу
      for(int8_t i=0;i<strlen(_thePhrase);i++){ // А ВОТ ЭТО ЧТО ДЕЛАЕМ ?  
          //...
       }
     _thePhrase++;
   }

там чуток по другому, а как вытащить элемент массива? tks sadman41
как ниже даже работает и буковки не пропускает

void sendBeacon(char* _thePhrase) {
  while (*_thePhrase) {
        for(int8_t i=0; i<sizeof(thePhrase); i++)
       {if(*_thePhrase == ".") delay(15*DOTLEN);
        if (toupper(*_thePhrase) == morseCode[i].letter) {
        uint8_t sequenceStarted = false;
         for (uint8_t l = 0; l < 8; l++) {
         uint8_t currentBit = bitRead(morseCode[i].sequence, l);
        if (!sequenceStarted) {
        sequenceStarted = currentBit; 
        continue; 
              }
     currentBit ? dot() : dash() ;            
             }
           }
          }
     _thePhrase++;
     delay(2*DOTLEN);
 }
}

давайте заслушаем начальника транспортного цеха...

Тогда вот первоисточник: https://www.youtube.com/watch?v=w0vi2fL2hMg

Аааа кажись въехал.

Я правильно понял, что первая единица слева это признак начала точек с тире, а следующие биты  1-точка, 0-тире ?

Урааа !!!!

я думаю да

Ну да. Квон идею толкнул, я её вкодил. Не с первого раза удачно, конечно.

void sendBeacon(char* _thePhrase) {
   while (*_thePhrase) {
      for(int8_t i=0;i<sizeof(morseCode)/sizeof(morseCode[0]);i++){
         if (toupper(*_thePhrase) == morseCode[i].letter) {
            uint8_t mask=1;
            while(!(morseCode[i].sequence & mask)){
               mask<<=1;               
            }
            mask<<=1;
            while(mask){
               (morseCode[i].sequence & mask) ? dot() : dash();
               mask<<=1;               
            }
            break;
          }
      }
     _thePhrase++;
   }
}

Так красиво ?

А то, то что я там выше нахреначил выглядит несколько по другому, там кодировка слева направо, 0-точка, 1-тире, а последняя единичка - конец. Работать будет быстрее, поскольку не перебирает все восемь бит в символе, но обработка посложнее.

Идеала-то нет. Пусть выбирает ua6em - ему же дописывать ;)

Это , да ! Я рад что он, оказывается, не мучается :) А только мучает нас :)

ну я то не программист, мне казалось, что для вас это - легким движением...
пытаюсь честно успевать за Вами записывать

Так более правильно:

void sendBeacon(char* _thePhrase) {
   while (*_thePhrase) {
      for(int8_t i=0;i<sizeof(morseCode)/sizeof(morseCode[0]);i++){
         if (toupper(*_thePhrase) == morseCode[i].letter) {
            uint8_t mask=1;
            while(!(morseCode[i].sequence & mask)){
               mask<<=1;               
            }
            mask<<=1;
            while(mask){
               (morseCode[i].sequence & mask) ? dot() : dash();
               mask<<=1;               
            }
            break;
          }
      }
     _thePhrase++;
     delay(2*DOTLEN);
   }
}

А где тут программирование? Ни малехонького класса, ни завалящей лямбда-функции. Так, перестановка байт местами. Третий класс по простой бытовой логике.

За нами нужно не записывать, а ДОПИСЫВАТЬ :)

Да , без лямбд ни разу не программирование. Даже классов нет... А уж квоновских и подавно :)

  а если получаем пробел, можно вставить задержку в 5 длительностей точек?

void sendBeacon(char* _thePhrase) {
   while (*_thePhrase) {
     if (toupper(*_thePhrase)==' '){
        delay(3*DOTLEN);
     } else {
        for(int8_t i=0;i<sizeof(morseCode)/sizeof(morseCode[0]);i++){
           if (toupper(*_thePhrase) == morseCode[i].letter) {
              uint8_t mask=1;
              while(!(morseCode[i].sequence & mask)){
                 mask<<=1;               
              }
              while(mask){
                 (morseCode[i].sequence & mask) ? dot() : dash();
                 mask<<=1;               
              }
              break;
           }
        }
      }
     _thePhrase++;
     delay(2*DOTLEN);
   }
}

Заменил - гонит вообще пургу, вернул назад старую функцию

 а вот так работает, но на пробеле паузы по 3 секунды

// (c) brokly arduino.ru
void sendBeacon(char* _thePhrase) {
   while (*_thePhrase) {
      for(int8_t i=0;i<sizeof(morseCode)/sizeof(morseCode[0]);i++){
        if (toupper(*_thePhrase)==' '){
        delay(1*DOTLEN);
     }
         if (toupper(*_thePhrase) == morseCode[i].letter) {
            uint8_t mask=1;
            while(!(morseCode[i].sequence & mask)){
               mask<<=1;               
            }
            mask<<=1;
            while(mask){
               (morseCode[i].sequence & mask) ? dot() : dash();
               mask<<=1;               
            }
            break;
          }
      }
     _thePhrase++;
     delay(2*DOTLEN);
   }
}

ПС:http://maxima-library.org/new-books-2/bl/25465?layout=series