Котуинко

[BOB51]

Для написания программ подходит любой из вариантов.
Но в большинстве случаев предпочитаем использовать собственные и/или чужие-доработанные под свое понимание программные модули (библиотеки или еще как их можно называть)...
При повторном использовании только копируем с небольшой доработкой.
То же самое касается и схемотехнических решений.
Тем более сегодня - когда сложность начинки микросхем и сопровождающего программного обеспечения кратно нарастает с каждым годом (а то и чаще).

[roman.com]

Речь идёт о простой Ардуино.
Ардуино не меняется уже много лет...

Аналогично с простым радио модулем.

На самом деле возможностей радио модуля как правило больше... Но на практике ими никто не пользуется. Тогда зачем писать целую библиотеку если можно написать несколько простых функций... Скопировать в любой проект и пользоваться себе на здоровье)).

Итого:

NRF_init(250, 4, 2400); // скорость 250, мощность 4, частота 2400 мгц.
NRF_on(1); //1- on, 0 - off.
NRF_TX(String); // передача данных (текста).
NRF_RX(String); // приём данных (текста).

Все))
Этих функций достаточно для простых поделок на Ардуино.
Термометры... Тахометры... Вольтметры... и т.д.

А кому мало могут дописать дополнительные функции.
Но как правило никому не надо.


И вот мы уже передаём/принимаем данные и выводим на экран))

lcd_init(127); // яркость экрана - 0...255.
lcd_on(1); // 1- on, 0 - off.
NRF_init(250, 4, 2400); // скорость 250, мощность 4, частота 2400 мгц.
NRF_on(1); // 1- on, 0 - off.

NRF_RX(String); // приём данных (текста).
lcd_data(String); // вывод данных (текста) на экран.

Все))
библиотеки не нужны.


При этом читаемость кода не страдает.
Так как все функции тупо копируются в начало кода программы (вместо библиотек).
Их можно не читать. Никто не заставляет))
И там же объявляются все переменные. Или не объявляются)) Переменные могут быть локальные внутри функций.

[Ser60]

[uquote="roman.com",url="/forum/viewtopic.php?p=4752307#p4752307"]Не могу согласиться))ООП как правило пишется под ОС.[/uquote]??? В корне неверное утверждение. Мягко говоря, чтобы не обидеть.

[uquote="roman.com",url="/forum/viewtopic.php?p=4752307#p4752307"]Это не ламерство.
Это называется "оптимизация"))[/uquote]Не понятно в чём вклад разработчика в оптимизацию. Если какие-либо функции библиотеки не используются (не вызываются), компилятор сам их просто не включит в загрузочный файл. Зато достаточно будет добавить в проект один файл библиотеки, может ещё соответствующий файл заголовков и всё.

[uquote="roman.com",url="/forum/viewtopic.php?p=4752307#p4752307"]Так как все функции тупо копируются в начало кода программы...[/uquote]Это и есть ламерский стиль программирования.

[roman.com]

как же всё предсказуемо...
уже наперёд знаешь кто что ответит...
даже скучно...

ладно... пойду дальше заниматься "ламерством"))

p.s.
настоящие профи пишут на уровне процессоров...
но это уже следующий уровень))

[BOB51]

Просто потребность в многофайловых проектах возникает по мере роста их объёма.
Да и вносить корректировки/редактировать под что-либо друго из набора уже выполненных и проверенных решений заметно проще.
Та же котуинка со сменными аппаратными модулями и их программным обеспечением как пример. Но там вроде ж не Си а ассемблер и МК на базе AT89S52...
Ну тогда посмотрим чего получиться в исходнике тех же просточасиков (проект К145/К145М), ежли его одним файлом оформить...
Да и, к примеру, просто поменять управление и индикацию с той К145

K145M.rar

(237.54 КБ) 121 скачивание

к простенькому таймеру

kotum.rar

(116.19 КБ) 120 скачиваний

там вроде просто "многофайловики"...

Да и насчет "просто атмега328"...
Относительно "простенькой" разве что про аттини13 аттини 2313, АТ89С2051 да PIC10F200 так сказать можно ...и то ... смотря как их использовать.

[roman.com]

об этом я и говорю...
чтоб посмотреть весь проект... надо открывать все файлы... отдельно.
а это всего то простенькие часики))


Ну тогда посмотрим чего получится в исходнике тех же просто пультиков, ежли его одним файлом оформить...

Спойлер

Спойлер

всё одним файлом... открыл и сразу видно весь проект.

потребность в многофайловых проектах по мере роста их объёма не возникает.
возникает потребность в дополнительных МК... потому что один МК уже не справляется))

и вот тут уже возникает потребность в многофайловых проектах...
потому что для каждого МК надо писать отдельный файл...

[BOB51]

Можно и так - делаются дополнительные спецкристаллы обработчиков на отдельных "универсальных кирпичиках".
Обычная история.
К примеру те же прикладные программаторы в котуинке...

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

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

Приоткрыл Ваши исходники... от 1000 до 5000 строк кода одним файлом...
Я думал только мои проекты ЖУТЬ, оказалось я не одинок...

Помимо прочего... не все компиляторы допускают "безгранично растущие" размеры исходников (к примеру те же "ранние ассемблеры").
Да и выискивать нужный участок текстовки проще с двумя отдельно открытыми окнами редактора (еще приятнее на двух мониторах).

[roman.com]

проект не доделан... много ещё нет.
там должно быть ~10.000 строк.
компилятор не ругается... ему пофигу сколько строк))


но главное что и так всё работает.







ну и ладно... когда будет настроение... доделаю.))

[BOB51]

Так и я пока котуинку забросил...
Хорошо хоть архивы вроде не растерял со всеми заменами компов...
Там только базовый блок да три программатора в железе и программах выполнены (ассемблер mcs51).
Леньки однако, да "местные особенности"...

[roman.com]

следующая версия скорее всего будет с защитой от РЕБ))

Спойлер

шифрование... антиспуфинг... ППРЧ... и т.д.
обстановка того требует...

[BOB51]

А на кой такой дурдом то?
Для простейших бытовых устройств или того же расширителя СОМ порта компа?

Не хош влияния ИИ - не подключайся к интернету, не используй мобильную связь.
Обычных проводков что ли мало?
Остальное (ежли не радиоканал) от помех весьма мало зависит.
Относительно "искрового разряда в шины питания" - так то же пройденный этап.
Не вижу в том смысла кухонный таймер от РЭБа защищать.

[roman.com]

во первых в моём компе нет СОМ порта... только виртуальный для прогера))
во вторых речь про устройство на видео...

устройство на видео... предназначено для перевозки грузов...
гражданских грузов в мирное время и военных грузов в военное время.

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

кухонный таймер от РЭБа защищать не надо.)) кухонный таймер работает по проводам.
поэтому антиспуфинг... ППРЧ... отпадает...
а шифрование остаётся... потому что кухонный таймер подключен к интернету.

[BOB51]

Котуинке как раз все равно какой тип СОМ порта - аппаратный или виртуальный (USB-COM переходник).

Насчет тырнета для простого таймера на кухню - это уже из разряда избыточного дурнодома...
Правда кому что удобнее - или простота применения или "только при работе через глобальные (интернет) сети".
В то же время наиболее удачным вариантом является конструкция, которая при полностью автономной работе имеет еще и опционно дополнительный сервисный модуль связи с удаленным контрольным пультом (который всегда можно и исключить).
Варианты интернет (сетевых) приложений частично снимают вопросы интерактива с оператором ("лампочки/кнопочки"). Но то уж за собой и минусы потянет - "несанкционированный доступ" (соответственно необходимость кодирования/шифрования и прочее к функционированию самой конструкции напрямую отношения не имеющее, а вот на затраты средств и времени избыточно кусючее).
Выбор конечно за автором конструкции (ежли заказчик своего требования не выставит - а в качестве заказчика частенько домашнее окружение выступает ).

[roman.com]

сейчас у меня простейшие бытовые устройства работают так...

Спойлер

и опять же...

всё одним файлом... открыл и сразу видно весь проект.

и вот тут уже возникает потребность в многофайловых проектах...
потому что для каждого МК надо писать отдельный файл...

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

вовсе нет.
всё уже написано. осталось только скопировать кусок кода в свой проект.

а вот собственно кусок кода отвечающего за шифрование...

Спойлер

Код: Выделить всё

////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////GS: 
unsigned int u;           // АЦП 
////////////////////////////////// АЦП: -0,000.070c
void adc(unsigned char adc_input)  
{
ADMUX = 0b01000000 | adc_input; // опорное AVCC // канал ADC0...ADC7  
delay_us(10);                   // стабилизация входа    
ADCSRA|=0b01000000;             // старт преобразования 
while (ADCSRA & 0b01000000);    // при завершении преобразования бит сбрасывается аппаратно  
};
////////////////////////////////// GS:
unsigned char xGS = 0; // счёт GS
unsigned char GS = 0;  // буфер GS  
char GS_TX(void){  
    GS = 0;    // сброс буфер GS 
    ///////////////////////////
    for (xGS=0; xGS<8; xGS++) {  // счёт GS  
      adc(7); u=ADCW;            // канал ADC 7
      if (u &= 0x0001) GS |= (1<<xGS); // 0b00000001...0b10000000 
    };
    return GS;
};
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////AES: 
unsigned int xAES = 0;           // счёт xAES
unsigned char xxAES = 0;         // счёт xxAES
unsigned char x_raund = 0;       // счёт raund (Всего 10 раунда)
////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////state:
//state 16 байт 
unsigned char state[] = {
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
};
////////////////////////////////////////////////////////////////////////////////
unsigned char  b_sbox = 0; // буфер b_sbox
//sbox 0...255 (16x16) //256 байт
unsigned char sbox[]= {
0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16
};
////////////////////////////////////////////////////////////////////////////////
unsigned char inv_b_sbox = 0;  // буфер inv_b_sbox
//inv_sbox 0...255 (16x16) //256 байт
unsigned char inv_sbox[]= {
0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb,
0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb,
0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e,
0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25,
0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92,
0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84,
0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06,
0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b,
0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73,
0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e,
0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b,
0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4,
0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f,
0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef,
0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61,
0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d
};
////////////////////////////////////////////////////////////////////////////////
//набор раундовых ключей для AES-256: 15 блоков по 16 байт. //0...239 байт
unsigned char KeySchedule[] = {
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//раунд 0
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//раунд 1
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//раунд 2
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//раунд 3
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//раунд 4
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//раунд 5  
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//раунд 6
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//раунд 7
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//раунд 8
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//раунд 9
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//раунд 10
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//раунд 11
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//раунд 12
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//раунд 13
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 //раунд 14
};
////////////////////////////////////////////////////////////////////////////////
//rcon 1...14  
unsigned char rcon[] = {
0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40 
};
////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////KeyExpansion():
// генерация раундовых ключей
//unsigned char Rows = 0;    // буфер Rows
unsigned int Rows = 0;       // буфер Rows
//unsigned char KE = 0;      // счёт KeyExpansion 
unsigned int KE = 0;         // счёт KeyExpansion 
unsigned char st_rcon = 0;   // счёт rcon

void KeyExpansion(void) { 
st_rcon = 0;                        // сброс счёт rcon

for (KE=0; KE<192; KE = KE + 32) { // блоки по 32 байт. //0...239 байт	
		
//KeySchedule_1...14: 
for (xAES=0; xAES<4; xAES++) {        
KeySchedule[xAES+32+KE] = KeySchedule[xAES+28+KE]; // KeySchedule_0 > KeySchedule_1 (-4)   
};

Rows = KeySchedule[32+KE];               // KeySchedule_1>>> 
KeySchedule[32+KE] = KeySchedule[33+KE];
KeySchedule[33+KE] = KeySchedule[34+KE];
KeySchedule[34+KE] = KeySchedule[35+KE];
KeySchedule[35+KE] = Rows;

for (xAES=0; xAES<4; xAES++) {         // sbox > KeySchedule_1[16...19]
b_sbox = KeySchedule[xAES+32+KE];	
KeySchedule[xAES+32+KE] = sbox[b_sbox];// буфер b_sbox
};

for (xAES=0; xAES<4; xAES++) {        // KeySchedule_1[16...19] ^ KeySchedule_0[0...3]
KeySchedule[xAES+32+KE] ^= KeySchedule[xAES+KE];	  
};

//0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40//(256) 
KeySchedule[32+KE] ^= rcon[st_rcon];  // // счёт rcon [1...10]
st_rcon ++;         // счёт rcon

//
for (xAES=0; xAES<4; xAES++) {        // KeySchedule_1[16...19] > KeySchedule_1[20...23] 
KeySchedule[xAES+36+KE] = KeySchedule[xAES+32+KE];	  
};
for (xAES=0; xAES<4; xAES++) {        // KeySchedule_1[20...23] ^ KeySchedule_0[4...7]
KeySchedule[xAES+36+KE] ^= KeySchedule[xAES+4+KE];	  
};
//
for (xAES=0; xAES<4; xAES++) {        // KeySchedule_1[20...23] > KeySchedule_1[24...27] 
KeySchedule[xAES+40+KE] = KeySchedule[xAES+36+KE];	  
};
for (xAES=0; xAES<4; xAES++) {        // KeySchedule_1[24...27] ^ KeySchedule_0[8...11]
KeySchedule[xAES+40+KE] ^= KeySchedule[xAES+8+KE];	  
};
//
for (xAES=0; xAES<4; xAES++) {        // KeySchedule_1[24...27] > KeySchedule_1[28...31] 
KeySchedule[xAES+44+KE] = KeySchedule[xAES+40+KE];	  
};
for (xAES=0; xAES<4; xAES++) {        // KeySchedule_1[28...31] ^ KeySchedule_0[12...15]
KeySchedule[xAES+44+KE] ^= KeySchedule[xAES+12+KE];	  
};


//
for (xAES=0; xAES<4; xAES++) {         // sbox > KeySchedule_1[16...19]
b_sbox = KeySchedule[xAES+44+KE];	
KeySchedule[xAES+48+KE] = sbox[b_sbox];// буфер b_sbox
};
for (xAES=0; xAES<4; xAES++) {        // KeySchedule_1[28...31] ^ KeySchedule_0[12...15]
KeySchedule[xAES+48+KE] ^= KeySchedule[xAES+16+KE];	  
};

//
for (xAES=0; xAES<4; xAES++) {        // KeySchedule_1[20...23] > KeySchedule_1[24...27] 
KeySchedule[xAES+52+KE] = KeySchedule[xAES+48+KE];	  
};
for (xAES=0; xAES<4; xAES++) {        // KeySchedule_1[24...27] ^ KeySchedule_0[8...11]
KeySchedule[xAES+52+KE] ^= KeySchedule[xAES+20+KE];	  
};

//
for (xAES=0; xAES<4; xAES++) {        // KeySchedule_1[24...27] > KeySchedule_1[28...31] 
KeySchedule[xAES+56+KE] = KeySchedule[xAES+52+KE];	  
};
for (xAES=0; xAES<4; xAES++) {        // KeySchedule_1[28...31] ^ KeySchedule_0[12...15]
KeySchedule[xAES+56+KE] ^= KeySchedule[xAES+24+KE];	  
};

//
for (xAES=0; xAES<4; xAES++) {        // KeySchedule_1[24...27] > KeySchedule_1[28...31] 
KeySchedule[xAES+60+KE] = KeySchedule[xAES+56+KE];	  
};
for (xAES=0; xAES<4; xAES++) {        // KeySchedule_1[28...31] ^ KeySchedule_0[12...15]
KeySchedule[xAES+60+KE] ^= KeySchedule[xAES+28+KE];	  
};

};	
////////////////////////////////////////////////////////////////////////////////
//KeySchedule_1...14: 
for (xAES=0; xAES<4; xAES++) {        
KeySchedule[xAES+32+KE] = KeySchedule[xAES+28+KE]; // KeySchedule_0 > KeySchedule_1 (-4)   
};

Rows = KeySchedule[32+KE];               // KeySchedule_1>>> 
KeySchedule[32+KE] = KeySchedule[33+KE];
KeySchedule[33+KE] = KeySchedule[34+KE];
KeySchedule[34+KE] = KeySchedule[35+KE];
KeySchedule[35+KE] = Rows;

for (xAES=0; xAES<4; xAES++) {         // sbox > KeySchedule_1[16...19]
b_sbox = KeySchedule[xAES+32+KE];	
KeySchedule[xAES+32+KE] = sbox[b_sbox];// буфер b_sbox
};

for (xAES=0; xAES<4; xAES++) {        // KeySchedule_1[16...19] ^ KeySchedule_0[0...3]
KeySchedule[xAES+32+KE] ^= KeySchedule[xAES+KE];	  
};

//0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40//(256) 
KeySchedule[32+KE] ^= rcon[st_rcon];  // // счёт rcon [1...10]
st_rcon ++;         // счёт rcon

//
for (xAES=0; xAES<4; xAES++) {        // KeySchedule_1[16...19] > KeySchedule_1[20...23] 
KeySchedule[xAES+36+KE] = KeySchedule[xAES+32+KE];	  
};
for (xAES=0; xAES<4; xAES++) {        // KeySchedule_1[20...23] ^ KeySchedule_0[4...7]
KeySchedule[xAES+36+KE] ^= KeySchedule[xAES+4+KE];	  
};
//
for (xAES=0; xAES<4; xAES++) {        // KeySchedule_1[20...23] > KeySchedule_1[24...27] 
KeySchedule[xAES+40+KE] = KeySchedule[xAES+36+KE];	  
};
for (xAES=0; xAES<4; xAES++) {        // KeySchedule_1[24...27] ^ KeySchedule_0[8...11]
KeySchedule[xAES+40+KE] ^= KeySchedule[xAES+8+KE];	  
};
//
for (xAES=0; xAES<4; xAES++) {        // KeySchedule_1[24...27] > KeySchedule_1[28...31] 
KeySchedule[xAES+44+KE] = KeySchedule[xAES+40+KE];	  
};
for (xAES=0; xAES<4; xAES++) {        // KeySchedule_1[28...31] ^ KeySchedule_0[12...15]
KeySchedule[xAES+44+KE] ^= KeySchedule[xAES+12+KE];	  
};

};
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////Key:
unsigned char Key_N_ = 0;   //Key_N_ = 0,1 -Номер Key -начальное 0
unsigned char b_Key_N_ = 2; //0,1 -Буфер Номер Key -начальное 2  
////////////////////////////////////////Key: 
unsigned char  K_int[] = {
////////////////////////////////////////0...15
////////////////vektor_0: 16 байт 
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0xFF, //1472/16=92(0xC5)//UDP
////////////////////////////////////////16...47
////////////////Key_0: 32 байт  
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
////////////////////////////////////////48...63
////////////////vektor_1: 16 байт 
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0xFF, //1472/16=92(0xC5)//UDP
////////////////////////////////////////64...95
////////////////Key_1: 32 байт 
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
////////////////////////////////////////96...127
////////////////Pas: 32 байт  
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0  
};
////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////bK_int:
unsigned char bK_int[] = {
////////////////////////////////////////0...31
////////////////Key_0: 32 байт  
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
////////////////////////////////////////32...63
////////////////Key_1: 32 байт 
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
////////////////////////////////////////64...95
////////////////Pas: 32 байт  
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
////////////////////////////////////////96...99
////////////////crc: 4 байт  
0,0,0,0
};
////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////счёт vektor_0:
void vektor_0(void) {
  if (K_int[8] == 0) { //проверка MAX K_int[] больше    
    for (xAES=15; xAES>7; xAES--) {        
      if (K_int[xAES] == 0xFF) {K_int[xAES]=0;}  
      else {K_int[xAES]++; xAES=1;}; 
    };
  };
  //if (K_int[8] != 0) {error_vektor = 1;};// установка флаг error_vektor
  if (K_int[8] != 0) {vektor_full = 1;}; // флаг vektor_full
};	
////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////счёт vektor_1:
void vektor_1(void) {  
  if (K_int[56] == 0) { //проверка MAX K_int[] больше    
    for (xAES=63; xAES>55; xAES--) {        
      if (K_int[xAES] == 0xFF) {K_int[xAES]=0;}  
      else {K_int[xAES]++; xAES=1;}; 
    };
  };
  //if (K_int[56] != 0) {error_vektor = 1;};// установка флаг error_vektor
  if (K_int[56] != 0) {vektor_full = 1;}; // флаг vektor_full
};	
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////Key_0 > KeySchedule:
void Key_0_Key(void) {
for (xAES=0; xAES<32; xAES++) {        
KeySchedule[xAES] = K_int[xAES+16];     // K_int > KeySchedule   
};
///////////////////////////////
KeyExpansion();	                        // генерация раундовых ключей
};
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////Key_1 > KeySchedule:
//Key_1 > KeySchedule: 32 байт 
void Key_1_Key(void) {
for (xAES=0; xAES<32; xAES++) {        
KeySchedule[xAES] = K_int[xAES+64];     // K_int > KeySchedule    
};
///////////////////////////////
KeyExpansion();	                        // генерация раундовых ключей
};
////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////SubBytes():
void SubBytes(void) { 
  for (xAES=0; xAES<16; xAES++) {        // sbox > state[0...15]
    b_sbox = state[xAES];	         // буфер b_sbox
    state[xAES] = sbox[b_sbox];	
  };
};
////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////InvSubBytes():
void InvSubBytes(void) { 
  for (xAES=0; xAES<16; xAES++) {       // inv_sbox > state[0...15]
    inv_b_sbox = state[xAES];           // буфер inv_b_sbox
    state[xAES] = inv_sbox[inv_b_sbox];	
  };
};
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////ShiftRows():
//unsigned int Rows = 0;                // буфер Rows
void ShiftRows(void) { 
Rows = state[1]; 
state[1] = state[5]; 
state[5] = state[9]; 
state[9] = state[13]; 
state[13] = Rows;

Rows = state[2]; 
state[2] = state[10]; 
state[10] = Rows;
Rows = state[6]; 
state[6] = state[14]; 
state[14] = Rows;

Rows = state[3]; 
state[3] = state[15]; 
state[15] = state[11];
state[11] = state[7];
state[7] = Rows;
};
////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////InvShiftRows():
//unsigned int Rows = 0;                // буфер Rows
void InvShiftRows(void) { 
Rows = state[1]; 
state[1] = state[13]; 
state[13] = state[9]; 
state[9] = state[5]; 
state[5] = Rows;

Rows = state[2]; 
state[2] = state[10]; 
state[10] = Rows;
Rows = state[6]; 
state[6] = state[14]; 
state[14] = Rows;

Rows = state[3]; 
state[3] = state[7]; 
state[7] = state[11];
state[11] = state[15];
state[15] = Rows;
};
////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////MixColumns():
unsigned char state_0 = 0;       // буфер state
unsigned char state_1 = 0;       // буфер state
unsigned char state_2 = 0;       // буфер state
unsigned char state_3 = 0;       // буфер state
//////////////////////////////////
unsigned char bMix = 0; 
void Mix(void) {
   if (bMix & 0x80)  bMix = ( bMix << 1 ) ^ 0x1b; //0x1B//P(x)=x^8+x^4+x^3+x+1
   else              bMix =   bMix << 1;
};
//////////////////////////////////
void MixColumns(void) { 
for (xAES=0; xAES<16; xAES=xAES+4) { // state[0...15] // 1 цикл = 0,000.4 c 
////////////////////////////////// state[0]:
//*2 //n*{02} 
bMix = state[xAES]; Mix(); state_0 = bMix;
//*3 //n*{02} + n*{01}
bMix = state[xAES+1]; Mix(); state_0 ^= bMix;
state_0 ^= state[xAES+1];  
//*1 //n*{01}
state_0 ^= state[xAES+2];  
//*1 //n*{01}
state_0 ^= state[xAES+3];  
////////////////////////////////// state[1]:
//*1 //n*{01}
state_1 = state[xAES];  
//*2 //n*{02}
bMix = state[xAES+1]; Mix(); state_1^= bMix;
//*3 //n*{02} + n*{01}
bMix = state[xAES+2]; Mix(); state_1^= bMix;
state_1 ^= state[xAES+2];
//*1 //n*{01}
state_1 ^= state[xAES+3];  
////////////////////////////////// state[2]:
//*1 //n*{01}
state_2 = state[xAES];
//*1 //n*{01}
state_2 ^= state[xAES+1]; 
//*2 //n*{02}
bMix = state[xAES+2]; Mix(); state_2^= bMix;
//*3 //n*{02} + n*{01}
bMix = state[xAES+3]; Mix(); state_2^= bMix;
state_2 ^= state[xAES+3];  
////////////////////////////////// state[3]:
//*3 //n*{02} + n*{01}
bMix = state[xAES]; Mix(); state_3 = bMix;
state_3 ^= state[xAES];
//*1 //n*{01}
state_3 ^= state[xAES+1]; 
//*1 //n*{01}
state_3 ^= state[xAES+2];
//*2 //n*{02}
bMix = state[xAES+3]; Mix(); 
state_3 ^= bMix;
////////////////////////////////// state_0,1,2,3 > state[0...3]:
state[xAES] = state_0; state[xAES+1] = state_1; state[xAES+2] = state_2; state[xAES+3] = state_3;       
////////////////////////////////// 
};
};
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////InvMixColumns():
void InvMixColumns(void) { 
for (xAES=0; xAES<16; xAES=xAES+4) { // state[0...15]// 1 цикл = 0,001.5 c
////////////////////////////////// state[0]:
//*e //n*{02}*{02}*{02} + n*{02}*{02} + n*{02}
bMix = state[xAES]; Mix(); Mix(); Mix(); state_0 = bMix;
bMix = state[xAES]; Mix(); Mix(); state_0 ^= bMix;
bMix = state[xAES]; Mix(); state_0 ^= bMix;
//*b //n*{02}*{02}*{02} + n*{02} + n*{01}
bMix = state[xAES+1]; Mix(); Mix(); Mix(); state_0 ^= bMix;
bMix = state[xAES+1]; Mix(); state_0 ^= bMix;
state_0 ^=  state[xAES+1];  
//*d //n*{02}*{02}*{02} + n*{02}*{02} + n*{01}
bMix = state[xAES+2]; Mix(); Mix(); Mix(); state_0 ^= bMix;
bMix = state[xAES+2]; Mix(); Mix(); state_0 ^= bMix;
state_0 ^= state[xAES+2];   
//*9 //n*{02}*{02}*{02} + n*{01}
bMix = state[xAES+3]; Mix(); Mix(); Mix(); state_0 ^= bMix;
state_0 ^= state[xAES+3];  
////////////////////////////////// state[1]:
//*9 //n*{02}*{02}*{02} + n*{01}
bMix = state[xAES]; Mix(); Mix(); Mix(); state_1 = bMix;
state_1 ^= state[xAES]; 
//*e //n*{02}*{02}*{02} + n*{02}*{02} + n*{02}
bMix = state[xAES+1]; Mix(); Mix(); Mix(); state_1 ^= bMix;
bMix = state[xAES+1]; Mix(); Mix(); state_1 ^= bMix;
bMix = state[xAES+1]; Mix(); state_1 ^= bMix;
//*b //n*{02}*{02}*{02} + n*{02} + n*{01}
bMix = state[xAES+2]; Mix(); Mix(); Mix(); state_1 ^= bMix;
bMix = state[xAES+2]; Mix(); state_1 ^= bMix;
state_1 ^= state[xAES+2];   
//*d //n*{02}*{02}*{02} + n*{02}*{02} + n*{01}
bMix = state[xAES+3]; Mix(); Mix(); Mix(); state_1 ^= bMix;
bMix = state[xAES+3]; Mix(); Mix(); state_1 ^= bMix;	
state_1 ^= state[xAES+3];  
////////////////////////////////// state[2]:
//*d //n*{02}*{02}*{02} + n*{02}*{02} + n*{01}
bMix = state[xAES]; Mix(); Mix(); Mix(); state_2 = bMix;
bMix = state[xAES]; Mix(); Mix(); state_2 ^= bMix;
state_2 ^= state[xAES];  
//*9 //n*{02}*{02}*{02} + n*{01}
bMix = state[xAES+1]; Mix(); Mix(); Mix(); state_2 ^= bMix;
state_2 ^= state[xAES+1];   
//*e //n*{02}*{02}*{02} + n*{02}*{02} + n*{02}
bMix = state[xAES+2]; Mix(); Mix(); Mix(); state_2 ^= bMix;	
bMix = state[xAES+2]; Mix(); Mix(); state_2 ^= bMix;
bMix = state[xAES+2]; Mix(); state_2 ^= bMix;
//*b //n*{02}*{02}*{02} + n*{02} + n*{01}
bMix = state[xAES+3]; Mix(); Mix(); Mix(); state_2 ^= bMix;
bMix = state[xAES+3]; Mix(); state_2 ^= bMix;	
state_2 ^= state[xAES+3];   
////////////////////////////////// state[3]:
//*b //n*{02}*{02}*{02} + n*{02} + n*{01}
bMix = state[xAES]; Mix(); Mix(); Mix(); state_3 = bMix;	
bMix = state[xAES]; Mix(); state_3 ^= bMix;	
state_3 ^= state[xAES]; 
//*d //n*{02}*{02}*{02} + n*{02}*{02} + n*{01}
bMix = state[xAES+1]; Mix(); Mix(); Mix(); state_3 ^= bMix;	
bMix = state[xAES+1]; Mix(); Mix(); state_3 ^= bMix;	
state_3 ^= state[xAES+1]; 
//*9 //n*{02}*{02}*{02} + n*{01}
bMix = state[xAES+2]; Mix(); Mix(); Mix(); state_3 ^= bMix;	
state_3 ^= state[xAES+2];
//*e //n*{02}*{02}*{02} + n*{02}*{02} + n*{02}
bMix = state[xAES+3]; Mix(); Mix(); Mix(); state_3 ^= bMix;	
bMix = state[xAES+3]; Mix(); Mix(); state_3 ^= bMix;	
bMix = state[xAES+3]; Mix(); state_3 ^= bMix;	
////////////////////////////////// state_0,1,2,3 > state[0...3]:
state[xAES] = state_0; state[xAES+1] = state_1; state[xAES+2] = state_2; state[xAES+3] = state_3;       
////////////////////////////////// 
};
};
////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////AddRoundKey():
void AddRoundKey(void) { 
xxAES = (x_raund << 4);       
  for (xAES=0; xAES<16; xAES++) {        
    state[xAES] ^= KeySchedule[xxAES];   // state ^ KeySchedule
    xxAES ++;       
  };
 };
////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////Шифрование:
void encrypt(void) { 
x_raund = 0;                   
AddRoundKey(); 

for (x_raund=1; x_raund<14; x_raund++) { //x_raund=1...x_raund=14
SubBytes();
ShiftRows();
MixColumns();
AddRoundKey(); 
};

x_raund = 14;                   
SubBytes();
ShiftRows();
AddRoundKey(); 
};
////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////Расшифрование: 
void decrypt(void) { 
x_raund = 14;          	
AddRoundKey(); 

for (x_raund=13; x_raund>0; x_raund--) { //x_raund=13...x_raund=1
InvShiftRows();
InvSubBytes();
AddRoundKey(); 
InvMixColumns();
};

x_raund = 0;  
InvShiftRows();
InvSubBytes();
AddRoundKey(); 
};
////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////gamma TX:
unsigned char TX_gamma_st = 0; //счёт gamma TX
//////////////////////////////////////////////////////////////////шифрование TX:
void AES_TX(void) {
//выбор ключей:
//b_Key_N_ = 0,1 -Буфер Номер Key 
if (b_Key_N_ != Key_N_){
/////////////////////////////////// b_Key_N_ != Key_N_  :
//////////////////////////Key_N == 0
if (Key_N_ == 0){
  Key_0_Key();     // Key_0 > KeySchedule
};
//////////////////////////Key_N == 1
if (Key_N_ == 1){
  Key_1_Key();      //Key_1 > KeySchedule
};
////////////////////////////////// Key_N_ > b_Key_N_
b_Key_N_ = Key_N_;
};
///////////////////////////////////////////////////////  	
//////////////////////////////////vektor:  
//TX_int[0] = ID_Source; 
//TX_int[1]...TX_int[15] = vektor[1]...vektor[15];  
/////////////////////////////////////////////////////// 
//vektor > state 
for (xAES=0; xAES<16; xAES++) {        
  state[xAES] = TX_int[xAES];    // TX_int > state      
};
//Блок простой замены:
encrypt(); // encrypt
//vektor > TX_int 
for (xAES=0; xAES<16; xAES++) {        
  TX_int[xAES] = state[xAES];    // state > TX_int           
};
///////////////////////////////////////////////////////  	
for (TX_gamma_st = 16; TX_gamma_st < TX_len; TX_gamma_st = TX_gamma_st + 16) {
///////////////////////////////////////////////////////  	
//Блок гаммы:
///////////////////////////////////////////////////////TX: vektor > state:
//////////////////////////Key_N == 0  
if (Key_N_ == 0){
/////////////////////////RX: флаг error_vektor:          
//vektor_TX_0 ++ 
vektor_0();                                        // счёт vektor_0 
//vektor > state 
for (xAES=0; xAES<16; xAES++) {        
  state[xAES] = K_int[xAES];                       // vektor_0 > state      
};
};
//////////////////////////Key_N == 1 
if (Key_N_ == 1){
/////////////////////////RX: флаг error_vektor:           
//vektor_TX_1 ++ 
vektor_1();                                        // счёт vektor_1  
//vektor > state 
for (xAES=0; xAES<16; xAES++) {        
  state[xAES] = K_int[xAES+48];                    // vektor_1 > state      
};
};
/////////////////////////////////////////////////////// 
//Блок простой замены:
encrypt(); // encrypt
//цикл шифрования:
for (xAES=0; xAES<16; xAES++) {        
  TX_int[xAES+TX_gamma_st] ^= state[xAES]; // state ^ TX_int             
};
};//TX_gamma_st + 16         
///////////////////////////////////////////////////////  	
};//AES_TX
////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////gamma RX:
unsigned char RX_gamma_st = 0; //счёт gamma RX
//////////////////////////////////////////////////////////////////////vektor_RX:
unsigned char vektor_RX[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; //16 байт 
///////////////////////////////////////////////////////////////расшифрование RX:
void AES_RX(void) {
/////////////////////////////////////////////////////// 
//////////////////////////////////vektor:  
//TX_int[0] = ID_Source; 
//TX_int[1]...TX_int[15] = vektor[1]...vektor[15];  
/////////////////////////////////////////////////////// 
//Входной блок > state 
for (xAES=0; xAES<16; xAES++) {        
  state[xAES] = TX_int[xAES];    // TX_int > state         
};
//Блок простой замены: 
decrypt(); // decrypt
//vektor > vektor_RX 
for (xAES=0; xAES<16; xAES++) {        
  vektor_RX[xAES] = state[xAES]; // state > vektor_RX          
};
//vektor > RX_int 
for (xAES=0; xAES<16; xAES++) {        
  TX_int[xAES] = vektor_RX[xAES];  // vektor_RX > TX_int        
};
///////////////////////////////////////////////////////  	
for (RX_gamma_st = 16; RX_gamma_st < RX_len; RX_gamma_st = RX_gamma_st + 16) {
///////////////////////////////////////////////////////  	
//Блок гаммы:
//////////////////////////////////////////////////////// 
//vektor_RX ++ 
for (xAES=15; xAES>7; xAES--) {        
  if (vektor_RX[xAES] == 0xFF) {vektor_RX[xAES]=0;}  
  else {vektor_RX[xAES]++; xAES=1;}; 
};
//vektor_RX > state 
for (xAES=0; xAES<16; xAES++) {        
  state[xAES] = vektor_RX[xAES]; // vektor_RX > state         
};
////////////////////////////////////////////////////////
//Блок простой замены: 
encrypt(); // encrypt
//цикл расшифрования:
for (xAES=0; xAES<16; xAES++) {        
  TX_int[xAES+RX_gamma_st] ^= state[xAES];  // TX_int ^ state           
};
};
};
////////////////////////////////////////////////////////////////////////////////

как видим ничего сложного нет.
обычный AES256.
и затраты... и времени... совсем небольшие))

из плюсов:
-отпадает необходимость в блоке точного времени. т.к. время синхронизируется по компьютеру.
-отпадает необходимость постоянно бегать на кухню и смотреть показания кухонного таймера. т.к. время кухонного таймера можно посмотреть в компьютере.
-отпадает необходимость вручную устанавливать время кухонного таймера. т.к. время кухонного таймера можно установить в компьютере.
-отпадает необходимость в блоке питания кухонного таймера. т.к. питание кухонный таймер получает по проводам.
-если таймер находится на кухне а мы в комнате... то мы можем не услышать звук кухонного таймера. в этом случае кухонный таймер отправляет пакет на сервер который находится в комнате и в котором установлен бузер. так мы гарантированно услышим кухонный таймер.
-и т.д.

короче... одни плюсы))


из минусов:
-надо тянуть провода по всему дому.

но это не очень большая плата за удобства.))

[BOB51]

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

Однако городить полноценную внутри домовую/внутриквартирную сеть ради пары простых приборчиков для домашнего хозяйства это не слишком оправдано.
Но и не исключается, если такая сеть уже ранее сделана и самоделка является дополнением к уже ранее созданному.
Я ж сетевыми вариантами не занимаюсь - разве что небольшие проекты с вынесенными датчиками и/или функциональными блоками.

Касательно "единого массива текста" - все же значительно более удобен вариант из нескольких файлов.
Редактирование "выкусь - копировать - вставить" или вставка целым блоком "библиотеки" похожи, но не совсем одно и то же.

[roman.com]

многие говорят что это всё просто игрушки...
а я говорю что это на самом деле реально удобно.
удобно когда лёжа на диване можно управлять всеми бытовыми приборами в доме.

Спойлер

и для этого не требуется больших затрат.
достаточно несколько МК.

Касательно "единого массива текста" - все же значительно более удобен вариант из одного файла.
Удобно когда всё под рукой.
В отличии от бибилиотек (которые написаны отдельный файлом) в одном файле проще и быстрей что-то отредактировать.
Достаточно просто переместиться в начало файла и внести изменения. Чем просматривать каждую отдельную библиотеку.

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

[BOB51]

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

Однако система выноса в отдельный файл текста обработчика алгоритма и/или аппаратного модуля достаточно удобна.
Помимо прочего такой подход приучает выделять задачу, а не размешивать по всей программе в разных местах (если таковое не вынужденная мера).

[veso74]

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

Вы написали код для себя, и вряд ли кто-то попытается понять, что код делает. Вряд ли кто-то позаимствует у вас кусок кода. Предпочтут написать прогр, коду самостоятельно, напр. используя если есть алгоритм и описание. (Напр. если вижу в C-файлы goto..., их сразу закрываю . Личное мнение).

[BOB51]

Многое зависит и от сложности как самой основной программы, так и ее составлящих.
То же обслуживание интерактива может быть как простейшим, так и весьма навороченным, обработчики вывода на дисплей также различны. что касается коммуникационных модулей - то их порой вообще в разных участках программы можно встретить.
Постепенно от подпрограммы (функции) и до отдельного файла (или класса) переход будет происходить.
Всему свое время.

А вот насчет "вспомнить прошлый код"...

Это таки весьма жутковатая история/перспектива...
Особо ежли больше года прошло да распечаток с хорошим описанием нету...
Зато пару раз вспомнил и отметил забытое описание понятнее сделаешшш!

[главный колбасист]

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

А потом куча болезней из за гиподинамии.