Arduino.ru

Могу помочь куда-нить какую-нить ляьду всунуть, если надо :) Вы какие лямбды предпочитаете в это время года? Какого порядка?

вы лучще про область видимости полученной строки поясните (хочу оформить как функцию)

Вы о каком коде? Я уже в них запутался. И ещё, всё-таки у меня приступы головной боли от Вашего квадратичного решения. Надо делать через таблицу, низзя так.

Что то морзе кодировка у вас какая то странная... Или это так, от балды?

Да тут всё от балды. Перформанс без ТЗ. Или даже хэппенинг...

Можно и через таблицу, но она двухмерная жеж данные и длина получается, как у brokly
Код этот, строку для отправки освобождать не надо, инициировать один раз в setup, значит должна быть глобальная, пока не возникнет необходимость её изменить, отслеживать предполагаю по флагу актуальности

А вообще предполагается следующий алгоритм:
1. При включении считываем данные из EEPROM в структуру
2. Считываем флаг записи структуры в EEPROM
3. Если запись структуры в EEPROM была ранее произведена, то строку формируем из структуры, иначе из строки первичной инициализации структуры

//  Строка для отправки сформируется внутри,
//  а при выходе будет освобождена
//
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;
 volatile 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); // Собрали строку текста Маяка
  }
  }

в смысле от балды, нормальная кодировка,  проверьте (к 5 пину зуммер от системника)

  
#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)  //пауза между передачами маяка в милисекундах

unsigned long old_millis;

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

char thePhrase[] = "ABCDEF GHIJK LMNOP QRSTU VWXYZ 01234 56789";

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

//  B11101000
//   ...-S   <- S - start bit
// (c) sadman41 дописал я - ua6em arduino.ru
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();
}

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

//*** передаём точку ***
// (c) Nicola Salsotto IN3GJH
void dot()
  {
    digitalWrite(ledPin, HIGH) ;
    tone(tonePin, toneFreq);
    delay(DOTLEN);
    digitalWrite(ledPin, LOW);
    noTone(tonePin);
    delay(DOTLEN);
  }
/*
 *
 *
 * (c) sadman41  arduino.ru
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 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;
 volatile 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); // Собрали строку текста Маяка
  }
  //thePhrase = str;
 }


// (c) brokly arduino.ru

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;               
              }
              mask<<=1;
              while(mask){
                 (morseCode[i].sequence & mask) ? dot() : dash();
                 mask<<=1;               
              }
              break;
           }
        }
      }
     _thePhrase++;
     delay(2*DOTLEN);
   }
}


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);
    sendBeacon(thePhrase);
    old_millis = millis();
    digitalWrite(txPin, LOW);
  }
}

А что мешает сунуть во флеш вашу таблицу ? Кстати в моем примере , в озу , эта таблица не занимает ни байта. 

// (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);
   }
}

Вы зачем мне этот бред приписываете что значит "(c) brokly arduino.ru" ? Я возмущенн !!!! Такой пурги я не писал !

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;               
              }
              mask<<=1;
              while(mask){
                 (morseCode[i].sequence & mask) ? dot() : dash();
                 mask<<=1;               
              }
              break;
           }
        }
      }
     _thePhrase++;
     delay(2*DOTLEN);
   }
}

Вот правильное, обратите внимание на строку 12, вот поэтому у вас фигня получается.

// (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);
   }
}

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;               
              }
              mask<<=1;
              while(mask){
                 (morseCode[i].sequence & mask) ? dot() : dash();
                 mask<<=1;               
              }
              break;
           }
        }
      }
     _thePhrase++;
     delay(2*DOTLEN);
   }
}

вот этот код пробовал из поста #148 потом уже импровизировал, я ставлю (c) чтобы первоисточник искать шибче

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);
   }
}

ОК, понял.) Вы всегда пишете через жо? Ну ведь слева направо писать как то понятнее всёж таки? Нежели по арабски.) В чём преимущество? Хотя, дело хозяйское, конечно.

Не могу смотреть на эти мучения... :(

//ТАБЛИЦА ГЕНЕРАЦИИ БУКВЫ АЗБУКИ МОРЗЕ
//                    ''    
//                    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 morseCode[]={B10000000, 
                   B00000100,B00001100,B00011100,B00111100,B01111100,B11111100,B11110100,B11100100,B11000100,B10000100,
                   B01100000,B11101000,B10101000,B11010000,B11000000,B10111000,B10010000,B11111000,B11100000,B00011000,
                   B01010000,B11011000,B00100000,B10100000,B00010000,B10011000,B01001000,B10110000,B11110000,B01000000,
                   B01110000,B01111000,B00110000,B01101000,B00101000,B11001000};

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

void sendBeacon(char* _thePhrase) {
   while (*_thePhrase) {
     if (*_thePhrase==' '){
        delay(3*DOTLEN);
     } else {
        uint8_t buff=getMorzeSeq(*_thePhrase);
        uint8_t mask=1;
        while(!(buff & mask)){
           mask<<=1;               
        }
        mask<<=1;
        while(mask){
           (buff & mask) ? dot() : dash();
           mask<<=1;               
        }
        break;
     }
     _thePhrase++;
     delay(2*DOTLEN);
   }
}

уже нет )))

CW хорош, мы единственные с Михаилом UA1QV в истории ВДВ кто сделал канал связи на 1000км при мощности передатчика 1 ватт!!!

Ну я то немного другим боком к этому Морзе. Есть такая хрень "приводной маяк" называется. В аэропортах, аэродромах и вертодромах устанавливается. Сигнальные огни, опять же для всяких авиаций. Там нужно. Правда фразы короткие там, но это ничего не менят. У световых указателей еще тайминги отличаются.

//ТАБЛИЦА ГЕНЕРАЦИИ БУКВЫ АЗБУКИ МОРЗЕ
//                    ''    
//                    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 morseCode[]={B10000000, 
                   B00000100,B00001100,B00011100,B00111100,B01111100,B11111100,B11110100,B11100100,B11000100,B10000100,
                   B01100000,B11101000,B10101000,B11010000,B11000000,B10111000,B10010000,B11111000,B11100000,B00011000,
                   B01010000,B11011000,B00100000,B10100000,B00010000,B10011000,B01001000,B10110000,B11110000,B01000000,
                   B01110000,B01111000,B00110000,B01101000,B00101000,B11001000};

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

void sendBeacon(char* _thePhrase) {
   while (*_thePhrase) {
     if (*_thePhrase==' '){
        delay(3*DOTLEN);
     } else {
        uint8_t buff=getMorzeSeq(*_thePhrase);
        uint8_t mask=1;
        while(!(buff & mask)){
           mask<<=1;               
        }
        mask<<=1;
        while(mask){
           (buff & mask) ? dot() : dash();
           mask<<=1;               
        }
        break;
     }
     _thePhrase++;
     delay(2*DOTLEN);
   }
}

Прям как Евгений Петрович хотел )))
А начиналось с малого, с хранения даных, которые могут меняться в EEPROM и реплики Евгения, ЧТО для структуры есть простые команды EEPROM.get() и  EEPROM.put() и  даные очень хорошо укладывались в структуру, то-есть позывной, текстовка, локатор размещения...а код маяка уже был (чужой), кривописанный по Вашим определениям но работающий как швейцарские часы )))

Это не я, sadman41 предложил два решения, там где справа на лево были ошибки или я кода совсем не понял, взял за основу слева на право сам то я такое разве бы смог написать, да ни в жисть )))

Один фиг этот код блокирующий. Не употребимо в реальной жизни.

Дак, а неблокирующий в чём проблема написать?

отписка ,задолбало)

У кого проблемма? Я чуть выше дал неблокирующий :)

а что там блокирующего?

Дык любой delay().

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

del

Ну а каким чудным образом делается задержка без делеев? Аналогично.)

struct MyBeacon {
  char call_sign[20];
  char loc[7];
};


//
//	Строка для отправки сформируется внутри,
//	а при выходе будет освобождена
//
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);
}

void setup(void) {
	Serial.begin(115200);
	MyBeacon mb = {"UA6EM", "LN14AE"}; // структура для отправки 
	sendMsg(mb);
}

void loop(void){}

UA6EM UA6EM BEACON QRA is LN14AE LN14AE

Только я не очень понимаю какую экономию дает этот пример ? Если оперативки, то экономии нет ваапче.

А там речь не шла об экономии. Спросили как формировать "переменную строку", чтобы её можно было eeprom.put'ом в епром пихать, я показал как можно сделать.

а пальцем показать слабо?

  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; }
              mask<<=1;
              while(mask){ (morseCode[i].sequence & mask) ? dot() : dash();  mask<<=1; }
              break; }  }  }
     _thePhrase++;  delay(2*DOTLEN);
   } }

Што-то я никак не пойму - куда делись года блистательной практики на ассемблере? Или не было их таки?

а в ассемблере (это тот который DEBUG) есть типы данных? ))) там ты бог

Перенёс скетчи в раздел проекты, здесь флуд можно и почистить, по не относящемуся к EEPROM

Может не в масть, но если в EEPROM организовать чтото на подобии файловой системы?

Гуглил на эту тему, много рассуждений на эту тему, даже вроде как библиотеки есть.

С одного форума

Например, разбиваете Вашу ЭППЗУ на блоки равного размера.

Самый первый обзываете суперблоком и пишете туда размер одного блока, их количество, сколько свободных блоков осталось и ещё может что.

Следом в одном или нескольких блоках размещаете битовую карту занятых блоков (бит сброшен - блок занят).

Каждый блок состоит из номера следующего блока и данных.

В следующем после битовой карты блоке размещается каталог, содержащий записи вида: номер первого блока/размер информации.

Для добавления нового Value ищете первую свободную запись в каталоге, если нет, добавляете к каталогу ещё один блок.

Далее находите столько номеров свободных блоков, сколько требуется для размещения Value, записывается информацию в эти блоки, располагая их цепочкой, вносите изменения в битовую карту и суперблок. Ключом будет являтся номер первого блока в цепочке.

Для перечисления просматриваете каталог.

Удаление Value также не представляет сложности.

И еще немного

В нормальных ассемблерах, разумеется есть. И простые типы, и структуры - всё там есть.

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

ЗЫ А ассемблеру учился у Питера Нортона

PPS примера, как сделать функцию не блокирующей, так и не последовало )))

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

так как тебе предлагають блоки одинакового размера, то это нистрашна. 

большой блок - не экономное расходование памяти, малый, потребуется выделение нескольких блоков, панацеи нет?

Ну так там не только о функции нужно думать, а и том что вы будете делать вне её. А в самой функции вы должны запоминать текущую ситуацию, с тем что бы продолжать с неё при последующем вызове.
Для примера.
 

// send char, true - end
bool MorseChar(uint8_t chr)
{
  static uint8_t dat;

  if (!dat) {                           //new uint8_t, if ready
    if (chr == ' ')
      dat = 1<<7;                       //pause
    else
      dat = pgm_read_byte(&(morse_tab[HEX_CHAR_TO_BIN(chr)]));
  }
  if (MorseDat(dat))                    //send
    dat = 0;
  return !dat;
}


// send morse data, true - end
static bool MorseDat(uint8_t dat)
{
  static uint8_t dat01;
  static uint8_t seq;

  if (!seq) {
    if (!dat01)
      dat01 = dat;

    if (dat01 == 1<<7)
      seq = B00001000;                  //pause
    else if (dat01 & 1<<7)
      seq = B11110000;                  //dash
    else
      seq = B11000000;                  //dot
  }
  if (MorseSequence(seq)) {             //send
    seq = 0;
    dat01 <<= 1;
  }
  return !dat01 && !seq;
}


// send sequence, true - ready
static bool MorseSequence(uint8_t seq)
{
  static uint8_t sequence;

  if (!sequence)
    sequence = seq;
  off(MORSE);
  if (sequence != 1<<7 && sequence & 1<<7)
    on(MORSE);
  sequence <<= 1;
  return !sequence;
}

я и говорю, будет такая борьба за мир, что камня на камне не останется...

открыл ветку в проектах, там скетч привели простого маячка, строк 80 всего, с учетом, что генерация частоты средствами таймера ардуины, запоминают знаки непосредственно в точках и тире (строками в духмерном массиве), да не экономно вроде, но простота подкупает
 

А в приведенном мной  примере от brokly нет смысла борьбы c делеями, даже если буду прикручивать дисплей, можно его обработку зацепить за прерывание

Ну дак правильно. У каждого свои приоритеты. Кому то нужно впихнуть невпихуемое, а кому то нужно тяп-ляп и в продакшен.) Как правило, все эти маячки на каких нибудь Тини13, вот и думайте.)

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

FAT на дисках живет же. А текст в #182 очень сильно на него смахивает.

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

Делей, в любом случае зло. А запускать что то в прерывании, из-за того что не понимаешь как избавится от делеев, ваабще курьез. В прерываниях то предется жить без делеев. Так можно из-за делеев до FreeRTOS и yield докатится. Вобщем, Евгений, вы не правы.

Многие этого не понимают и "в борьбе обретают право своё" :)

Тогда уж лучше SPIFFS, только вот встроеный епром, как правило, маловат для этого.

Тааак, понятно, пятница :)

Это еще так ... пятница в соседней теме :)

А позвольте тут с вами не согласица. 

а с этим полностью согласица. 

Будет использоваться раза 3-4 в год, выехал на точку, забил позывной и координаты и всё, устройство пиликает круглосуточно пару-тройку дней и, до следующей поездки, да, частоты на синтезатор программируются в setup, далее он работает автономно