Arduino.ru

да уж всё разжевали, постараюсь сам

да нет, просто подвис )))

Ну, так соханяйте на здоровье. Вместо строки №34 постаьте EEPROM.put - она сохранит за милую душу

Если хранить строку передачи, то во внешнем EEPROM . Да эта такая микросхема которая идет вместе с часамии. Воткнул другой ЕЕPROM пошла другая передача.  А вот что бы заливать во внутреенее EEPROM или в PROGMEM все равно надо снимать блок.

Да ладно тебе, квон,усложнять. Оне же, радиогубители, могут просто настучать ключом строку прямо в еепром. Даже сериал не понадобится. 

Вчерне работает, теперь буду прикручивать сериал и сохранение, да, работает потому, что в EEPROM по нужным адресам данные сохнанились от прежнего скетча, в котором пробовал запись-чтение )))

/*
  Простой телеграфный маяк для экспериментов
 
  Исходный код:
  Written by Nicola Salsotto IN3GJH
  https://github.com/NicoVarg99
 
  Модификация сделана:
  UA6HJQ 18.11.2018 (добавлено управление радиостанцией)
  UA6EM 12/04/2019 (добавлен разбор символов нижнего регистра)
  UA6EM & сотоварищи (работа с EEPROM -начало)
 
  Интервал между передачей:
  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"};  // структура для отправки

#define SPEED (20)  //скорость в WPM
#define DOTLEN (1200/SPEED)
#define DASHLEN (3*(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);
     }
 // процедура чтения порта будут тут )))
     
 } // 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);
  delay(500);
  for(int8_t i=0;i<strlen(str);i++)
  {
    switch (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 '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);
   }
  } // окончание функции передачи текста маяка

Так тем первым постом и хотел об этом сказать, что чтение-сохранение структуры оказывается как два пальца об асфальт )))

Я вот смотрю на Ваше строки 125-280 и меня как-то дрожь пробирает. А что нельзя написать короткую функцию (строк 30 может), которая бы отправляля любой сообщение (любую строку)?

пока даже не представляю как, в этих строках идёт побуквенный разбор, в начальном скетче были только заглавные, это уже я немного разнообразил )))

вот подзавис, читаю в из порта в String переменную и, как эти переменные передать в структуру, опять преобразовывать?

Serial.println("Введите позывной сигнал");
    delay(3000);
    while(Serial.available()) {
    my_call = Serial.readString(); 
    } 
    Serial.print("Ваш позывной - ");
     Serial.println(my_call);
      Serial.println();

Pascal style

не могу знать, я бы написал аналогично, автор итальянец, вверху скетча указан

И не просто дрожь, а тихий ужас.) Делается байтовая таблица кодов Морзе. Из кода символа таблично получашь код Морзе, дальше формируешь - пиликаешь либо щёлкаешь.)

без примера не пойму, хотя как Дед говорит - и так сойдёт...

особо не искал, но из тех роликов, что на ютубе демонстрировали маячки, там вообще дикий ужас
 

Кодировка такая

_A           B01100000
_B           B10001000
_C           B10101000
_D           B10010000
_E           B01000000
_F           B00101000
_G           B11010000

У них длина должна быть разная. Ещё нужен один параметр.

_A           B01100000
_B           B10001000
_C           B10101000
_D           B10010000
_E           B01000000
_F           B00101000
_G           B11010000

Сжальтесь, этот гвоздь не в ту стену )))

Въехал! Но конец кода ловить видимо сложновато будет

Жесть в общем. И память поди жрёт немерянно. Можно же написать коротенькую программку, ей передаёшю строку, а она радостно отправляет

6690 и 20% озу .. особо не вникал, может азбука Морзе сформирована по каким-то законам, этот набор точек и тире, но что-то сомневаюсь, к примеру  обратный слэш в жизни никогда не слышал, не учил, не передавал, а он есть оказывается , ТИГРОМУХ вон все 32 килобайта под завязку съедает, но правда и GPS модуль парсит и далее телеграфом, но там еще и ватчдог и еще кое что для экономии энергии )))

Пример такой:

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

morseCode_t morseCode[]= {
  {'A', 2, B00000001},
  {'B', 4, B00001110},
   ...
};

char thePhrase[]="ABrAcAdABrA";

while (*thePhrase) {
  for (uint8_t i = 0; i < sizeof(letters); i++) {
    if (*thePhrase == 0x20) { delay(DOTLEN*5); break; }
    if (*thePhrase == morseCode[i].letter) {
       for (uint8_t l = 0; l < morseCode[i].lenght; l++) {
           bitRead(morseCode[i].sequence, l) ? dot() : dash();
       }
    }
  }
  thePhrase++;
}

наверно так?
 

morseCode_t morseCode[]= {
  {'A', 2, B00000001},
  {'a', 2, B00000001},
  {'B', 4, B00001110},
  {'b', 4, B00001110},
  {'C', 4, B00001010},
  {'c', 4, B00001010},
   ...
};

Можно и так. Но достаточно одной sequence. Например 'A' = B01100000 = .- последняя 1 - признак конца последовательности.)
Ну а извлечение из таблицы - обычная перекодировка.

откуда знаем, что это последняя? sadman41 предлагает задавать длину и, мне это нравится

Двойной проход по байту... если ещё в прогмем засунуть. Ну, не знаю. Выигрыш 50/50. Разве что для пущего изумления публики.

это понятно, что если за единицей следуют нули, то это был порог, но простого способа парсить биты не знаю, так. чтобы пару строк

morseCode_t morseCode[]= {
  {'A', 2, B00000001},
  {'a', 2, B00000001},
  {'B', 4, B00001110},
  {'b', 4, B00001110},
  {'C', 4, B00001010},
  {'c', 4, B00001010},
   ...
};

Тут вообще tolower()/toupper() в применение просится, коли нет различий между строчными и прописными.

По первой единице можно, да. Только формировать неудобно будет последовательности и один бит выпадает. Скоко там в коде Морзе максимальное кол-во тире-точек в символе?

https://dic.academic.ru/dic.nsf/sea/124/АЗБУКА     7 бит хватит на все. А совсем экзотику можно закодировать отдельно. Вот только для экзотики одинарных значков не окажется.

5? есть еще россыпь точек, но она двойная, тогда шесть, но это типа когда ошибочный символ передан, забить его, нам оно не надо...
лучше скажите ка переменную типа String в структуру засунуть

Типа этого выходит что ли...

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

//  B11101000 
//   ...-S   <- S - start bit
morseCode_t morseCode[]= {
  {'A', B01100000},
  {'B', B11101000},
   ...
};

...

    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 && !currentBit) { continue; }
           sequenceStarted = true;
           currentBit ? dot() : dash();
       }
    }

Или более "человечней":

  ...
//                B00011110 
// start bit S ->     S...-  
morseCode_t morseCode[]= {
  {'A', B00000110},
  {'B', B00011110},
   ...
};

...
    
    if (toupper(*thePhrase) == morseCode[i].letter) {
       uint8_t sequenceStarted = false;
       for (int8_t l = 7; l >= 0; l++) {
           uint8_t currentBit = bitRead(morseCode[i].sequence, l);
           if (!sequenceStarted && !currentBit) { continue; }
           sequenceStarted = true;
           currentBit ? dot() : dash();
       }
    }

Вобщем, что более понятней - то и берите. 

Ну зачем так сложно составляем обычную таблицу перевода этого в 1 байт кода Морзе.

Ну а дальше организуется morzeSeial, в котором код пробела это некоторая пауза длительностью передачи знака с кодом как не странно 0х00 или 0х01

- . - - -

наскока меня учили в Камышинской учебке, у кода морзе есть только 1 значимая величина - длительность точки,

остальные - производные 

длительность тире = 2 точки  Upd: 3 точки. 

интервал между посылками в букве = 1 точка

интервал между буквами - 1 тире 

интервал между группами (5 символов (у военных)) - 2 тире.  

не успеваешь принимать, тебе присылають 33, что в мяхком переводе означает "Смените радиста, ватьмашу"

ЗЫ. Надо же, проанализировал щас свои нутренние ащющения, дак всё почти забыл, и коды, и сокращения, типа QSA?, RK, и т.д а напевы для каждой буквы, все эти "баа-ки-те-кут", "гаа-гаа-рин", "доо-ми-ки" на всю жизнь в память въелись, даже алкоголем не вытравишь

Тире - 3 точки. Интервалы - это минимум при скоростном приёме/передаче. В реале (эфире) может быть любая галиматня.) У некоторых  автоматических ключей дительности даже внутри знака (точки/тире) могут отличаться друг от дружки. 

я мог, канеш, запамятовать, но, памойму, сётаки 2.  

Щас практикующие радисты нас рассудют. 

Upd. Хотя вики, говорит, что да, три.  Всё забыл. Нада напица.  :(

ну так это вроде даже и подтверждения не требует, дело это когда копаешь от сих и до обеда )))
А про Стринг, принял из сериала строкой, запомнил в переменную, далее для простоты хочу закинуть эту переменную в поле структуры char и уже эту структуру сохранить в EEPROM, благо это элементарно всего одна команда )))

Да, тире в классике - равно трём точкам, а когда не равно (для ручного ключа) это называется почерк, по нему радист и узнавался, подделывается довольно сложно, к примеру тире в букве Ф по длительности может быть равна 6 точкам, звучит на слух ОЧЕНЬ красиво

Есть виброплексы у которых длительность уменьшается с каждой посылкой. Вот это почерк.)

 ну не с утра жеж ))) PS да и не стоит оно того

я тоже на пиле мог лить ...
Убивал бы сразу за такой почерк )))

  ...
//                B00011110 
// start bit S ->     S...-  
morseCode_t morseCode[]= {
  {'A', B00000110},
  {'B', B00011110},
   ...
};

...
    
    if (toupper(*thePhrase) == morseCode[i].letter) {
       uint8_t sequenceStarted = false;
       for (int8_t l = 7; l >= 0; l++) {
           uint8_t currentBit = bitRead(morseCode[i].sequence, l);
           if (!sequenceStarted && !currentBit) { continue; }
           sequenceStarted = true;
           currentBit ? dot() : dash();
       }
    }

не совсем понятно, если стартовый бит переход от 0 к 1 то 'B' видимо надо закодировать как B00011000?
Разбор в верхнего бита идёт?

Вот польстился на EEEPROM.get() EEPROM.put(), а оказалось "за морем телушка полушка да рубль перевоз" )))
Но зато и форума выливается полностью новый код маячка

всё равно 2 байта на знак тратить придёца.  кодируй лучше тогда 11 тире 1 точка, между ними нули-разделители.  Тогда надо будет найти первый ненулевой бит и начать передачу.

Е - 0b1

И - 0b101

O - 0b11011011  

памойму, любой знак в 2 байта укладёца 

у мня есть код для AT24C32, которые массово на модулях DS3231 стоят, если в проекте есть RTC, то 4 кБ EEPROM никада лишними не будуть.  Дать?  Туды можно пхать всё что угодно, он на шаблонах

я подумаю, правда оно и так работает, но коли советуете ответить 'автопробегом по бездорожью' надо ответить, для маяка городить весь алфавит не требуется только латынь и цифры достаточно...засада в оперативной смене информации более актуальна, практиковал, становишься на стыке 4-х квадратов LOC и тебе пересунуться полсотни метров и ты уже в другом квадрате )))

morseCode_t morseCode[]= {
  {'A', 2, B00000001},
  {'a', 2, B00000001},
  {'B', 4, B00001110},
  {'b', 4, B00001110},
  {'C', 4, B00001010},
  {'c', 4, B00001010},
   ...
};

Нет, буквы -лишиние. Коллега правильно сказал - по индексу в таблице они достаются.

Наверное, всё же, в постановке задачи надо определить алфавит, в противном случае непонятно - сколько символов необходимо, как они наложатся на ASCII-table. Без этого у каждого будет своё видение на оптимальный формат списка последовательностей тиреточек.

Дай, положу в копилку.

Как с этими строками всё неоднозначно )))