Например TDA7294

Форум РадиоКот • Просмотр темы - Котуинко
Форум РадиоКот
Здесь можно немножко помяукать :)

Текущее время: Вс дек 28, 2025 02:05:28

Часовой пояс: UTC + 3 часа


ПРЯМО СЕЙЧАС:



Начать новую тему Ответить на тему  [ Сообщений: 2326 ]     ... , , , 114, , ,  
Автор Сообщение
Не в сети
 Заголовок сообщения: Re: Котуинко
СообщениеДобавлено: Чт окт 09, 2025 00:35:49 
Друг Кота
Аватар пользователя

Карма: 96
Рейтинг сообщений: 1494
Зарегистрирован: Вт мар 16, 2010 22:02:27
Сообщений: 15331
Откуда: ДОНЕЦК
Рейтинг сообщения: 0
Для написания программ подходит любой из вариантов.
Но в большинстве случаев предпочитаем использовать собственные и/или чужие-доработанные под свое понимание программные модули (библиотеки или еще как их можно называть)...
При повторном использовании только копируем с небольшой доработкой.
То же самое касается и схемотехнических решений.
Тем более сегодня - когда сложность начинки микросхем и сопровождающего программного обеспечения кратно нарастает с каждым годом (а то и чаще).


Вернуться наверх
 
Не в сети
 Заголовок сообщения: Re: Котуинко
СообщениеДобавлено: Чт окт 09, 2025 01:00:58 
Друг Кота

Карма: -1
Рейтинг сообщений: 86
Зарегистрирован: Вт мар 13, 2012 12:16:13
Сообщений: 8887
Откуда: .ru
Рейтинг сообщения: 0
Речь идёт о простой Ардуино.
Ардуино не меняется уже много лет...

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

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

Итого:

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

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

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

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

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); // вывод данных (текста) на экран.

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

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


Вернуться наверх
 
Не в сети
 Заголовок сообщения: Re: Котуинко
СообщениеДобавлено: Чт окт 09, 2025 03:06:18 
Друг Кота
Аватар пользователя

Карма: 75
Рейтинг сообщений: 621
Зарегистрирован: Ср дек 24, 2008 09:58:58
Сообщений: 3764
Рейтинг сообщения: 2
Медали: 3
Мявтор 1-й степени (1) Мявтор 2-й степени (1) Мявтор 3-й степени (1)
Не могу согласиться))ООП как правило пишется под ОС.
??? В корне неверное утверждение. Мягко говоря, чтобы не обидеть.

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

Так как все функции тупо копируются в начало кода программы...
Это и есть ламерский стиль программирования.


Вернуться наверх
 
Не в сети
 Заголовок сообщения: Re: Котуинко
СообщениеДобавлено: Чт окт 09, 2025 10:06:43 
Друг Кота

Карма: -1
Рейтинг сообщений: 86
Зарегистрирован: Вт мар 13, 2012 12:16:13
Сообщений: 8887
Откуда: .ru
Рейтинг сообщения: 0
как же всё предсказуемо...
уже наперёд знаешь кто что ответит...
даже скучно...
:tea:
ладно... пойду дальше заниматься "ламерством"))
:tea:
p.s.
настоящие профи пишут на уровне процессоров...
но это уже следующий уровень))


Вернуться наверх
 
Эиком - электронные компоненты и радиодетали
Не в сети
 Заголовок сообщения: Re: Котуинко
СообщениеДобавлено: Чт окт 09, 2025 10:40:08 
Друг Кота
Аватар пользователя

Карма: 96
Рейтинг сообщений: 1494
Зарегистрирован: Вт мар 16, 2010 22:02:27
Сообщений: 15331
Откуда: ДОНЕЦК
Рейтинг сообщения: 0
Просто потребность в многофайловых проектах возникает по мере роста их объёма.
Да и вносить корректировки/редактировать под что-либо друго из набора уже выполненных и проверенных решений заметно проще.
Та же котуинка со сменными аппаратными модулями и их программным обеспечением как пример. Но там вроде ж не Си а ассемблер и МК на базе AT89S52...
Ну тогда посмотрим чего получиться в исходнике тех же просточасиков (проект К145/К145М), ежли его одним файлом оформить...
Да и, к примеру, просто поменять управление и индикацию с той К145
Вложение:
K145M.rar [237.54 KiB]
Скачиваний: 51

к простенькому таймеру
Вложение:
kotum.rar [116.19 KiB]
Скачиваний: 46

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


Вернуться наверх
 
Не в сети
 Заголовок сообщения: Re: Котуинко
СообщениеДобавлено: Чт окт 09, 2025 13:53:03 
Друг Кота

Карма: -1
Рейтинг сообщений: 86
Зарегистрирован: Вт мар 13, 2012 12:16:13
Сообщений: 8887
Откуда: .ru
Рейтинг сообщения: 0
об этом я и говорю...
чтоб посмотреть весь проект... надо открывать все файлы... отдельно.
а это всего то простенькие часики))
:facepalm:

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

СпойлерИзображение

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


Вложения:
модель.c [53.58 KiB]
Скачиваний: 59
пульт.c [213.43 KiB]
Скачиваний: 50
Вернуться наверх
 
Не в сети
 Заголовок сообщения: Re: Котуинко
СообщениеДобавлено: Чт окт 09, 2025 14:35:27 
Друг Кота
Аватар пользователя

Карма: 96
Рейтинг сообщений: 1494
Зарегистрирован: Вт мар 16, 2010 22:02:27
Сообщений: 15331
Откуда: ДОНЕЦК
Рейтинг сообщения: 0
Можно и так - делаются дополнительные спецкристаллы обработчиков на отдельных "универсальных кирпичиках".
Обычная история.
К примеру те же прикладные программаторы в котуинке...
:tea:
Только вот зачем такие картинки рисовать, когда и обыкновенных схемных обозначений достаточно?
Напоминает старые схемы к автоэлектрике - сплошные рисунки с весьма сложным восприятием сути простейших решений.
Лучше уж стандартную блок-схему начертить для общего восприятия.
8)
У Вас каждый модуль комплекта - готовое изделие при центральном модуле обработчика данных, выполняющего всего лишь одну функцию обработки
В моих "часиках" иной вариант - единый аппаратный модуль с несколькими вариантами программной реализации разных по функциям устройств (каждое со своей программой обслуживания).
8)
Приоткрыл Ваши исходники... от 1000 до 5000 строк кода одним файлом...
Я думал только мои проекты ЖУТЬ, оказалось я не одинок...
:))
Помимо прочего... не все компиляторы допускают "безгранично растущие" размеры исходников (к примеру те же "ранние ассемблеры").
Да и выискивать нужный участок текстовки проще с двумя отдельно открытыми окнами редактора (еще приятнее на двух мониторах).
:roll:


Вернуться наверх
 
Не в сети
 Заголовок сообщения: Re: Котуинко
СообщениеДобавлено: Чт окт 09, 2025 15:31:47 
Друг Кота

Карма: -1
Рейтинг сообщений: 86
Зарегистрирован: Вт мар 13, 2012 12:16:13
Сообщений: 8887
Откуда: .ru
Рейтинг сообщения: 0
проект не доделан... много ещё нет.
там должно быть ~10.000 строк.
компилятор не ругается... ему пофигу сколько строк))
:tea:

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







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


Последний раз редактировалось roman.com Чт окт 09, 2025 15:58:54, всего редактировалось 2 раз(а).

Вернуться наверх
 
Не в сети
 Заголовок сообщения: Re: Котуинко
СообщениеДобавлено: Чт окт 09, 2025 15:56:02 
Друг Кота
Аватар пользователя

Карма: 96
Рейтинг сообщений: 1494
Зарегистрирован: Вт мар 16, 2010 22:02:27
Сообщений: 15331
Откуда: ДОНЕЦК
Рейтинг сообщения: 0
Так и я пока котуинку забросил...
Хорошо хоть архивы вроде не растерял со всеми заменами компов...
Там только базовый блок да три программатора в железе и программах выполнены (ассемблер mcs51).
Леньки однако, да "местные особенности"...
8)


Вернуться наверх
 
Не в сети
 Заголовок сообщения: Re: Котуинко
СообщениеДобавлено: Чт окт 09, 2025 15:59:27 
Друг Кота

Карма: -1
Рейтинг сообщений: 86
Зарегистрирован: Вт мар 13, 2012 12:16:13
Сообщений: 8887
Откуда: .ru
Рейтинг сообщения: 0
следующая версия скорее всего будет с защитой от РЕБ))
СпойлерИзображение

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


Вернуться наверх
 
Не в сети
 Заголовок сообщения: Re: Котуинко
СообщениеДобавлено: Чт окт 09, 2025 16:26:04 
Друг Кота
Аватар пользователя

Карма: 96
Рейтинг сообщений: 1494
Зарегистрирован: Вт мар 16, 2010 22:02:27
Сообщений: 15331
Откуда: ДОНЕЦК
Рейтинг сообщения: 0
А на кой такой дурдом то?
Для простейших бытовых устройств или того же расширителя СОМ порта компа?
:dont_know:
Не хош влияния ИИ - не подключайся к интернету, не используй мобильную связь.
Обычных проводков что ли мало?
Остальное (ежли не радиоканал) от помех весьма мало зависит.
Относительно "искрового разряда в шины питания" - так то же пройденный этап.
Не вижу в том смысла кухонный таймер от РЭБа защищать.
8)


Вернуться наверх
 
Не в сети
 Заголовок сообщения: Re: Котуинко
СообщениеДобавлено: Чт окт 09, 2025 17:48:33 
Друг Кота

Карма: -1
Рейтинг сообщений: 86
Зарегистрирован: Вт мар 13, 2012 12:16:13
Сообщений: 8887
Откуда: .ru
Рейтинг сообщения: 0
во первых в моём компе нет СОМ порта... только виртуальный для прогера))
во вторых речь про устройство на видео...

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

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


Вернуться наверх
 
Не в сети
 Заголовок сообщения: Re: Котуинко
СообщениеДобавлено: Чт окт 09, 2025 18:25:54 
Друг Кота
Аватар пользователя

Карма: 96
Рейтинг сообщений: 1494
Зарегистрирован: Вт мар 16, 2010 22:02:27
Сообщений: 15331
Откуда: ДОНЕЦК
Рейтинг сообщения: 0
Котуинке как раз все равно какой тип СОМ порта - аппаратный или виртуальный (USB-COM переходник).
8)
Насчет тырнета для простого таймера на кухню - это уже из разряда избыточного дурнодома...
Правда кому что удобнее - или простота применения или "только при работе через глобальные (интернет) сети".
В то же время наиболее удачным вариантом является конструкция, которая при полностью автономной работе имеет еще и опционно дополнительный сервисный модуль связи с удаленным контрольным пультом (который всегда можно и исключить).
Варианты интернет (сетевых) приложений частично снимают вопросы интерактива с оператором ("лампочки/кнопочки"). Но то уж за собой и минусы потянет - "несанкционированный доступ" (соответственно необходимость кодирования/шифрования и прочее к функционированию самой конструкции напрямую отношения не имеющее, а вот на затраты средств и времени избыточно кусючее).
Выбор конечно за автором конструкции (ежли заказчик своего требования не выставит - а в качестве заказчика частенько домашнее окружение выступает :wink: ).
:tea:


Вернуться наверх
 
Не в сети
 Заголовок сообщения: Re: Котуинко
СообщениеДобавлено: Пт окт 10, 2025 10:49:11 
Друг Кота

Карма: -1
Рейтинг сообщений: 86
Зарегистрирован: Вт мар 13, 2012 12:16:13
Сообщений: 8887
Откуда: .ru
Рейтинг сообщения: 0
сейчас у меня простейшие бытовые устройства работают так...
СпойлерИзображение

и опять же...

всё одним файлом... открыл и сразу видно весь проект.
:roll:
и вот тут уже возникает потребность в многофайловых проектах...
потому что для каждого МК надо писать отдельный файл...
:tea:
BOB51 писал(а):
(соответственно необходимость кодирования/шифрования и прочее к функционированию самой конструкции напрямую отношения не имеющее, а вот на затраты средств и времени избыточно кусючее).

вовсе нет.
всё уже написано. осталось только скопировать кусок кода в свой проект.
:tea:
а вот собственно кусок кода отвечающего за шифрование...
Спойлер
Код:
////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////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.
и затраты... и времени... совсем небольшие))
:tea:
из плюсов:
-отпадает необходимость в блоке точного времени. т.к. время синхронизируется по компьютеру.
-отпадает необходимость постоянно бегать на кухню и смотреть показания кухонного таймера. т.к. время кухонного таймера можно посмотреть в компьютере.
-отпадает необходимость вручную устанавливать время кухонного таймера. т.к. время кухонного таймера можно установить в компьютере.
-отпадает необходимость в блоке питания кухонного таймера. т.к. питание кухонный таймер получает по проводам.
-если таймер находится на кухне а мы в комнате... то мы можем не услышать звук кухонного таймера. в этом случае кухонный таймер отправляет пакет на сервер который находится в комнате и в котором установлен бузер. так мы гарантированно услышим кухонный таймер.
-и т.д.

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

из минусов:
-надо тянуть провода по всему дому.
:roll:
но это не очень большая плата за удобства.))


Вложения:
исходники_Dom_9.rar [129.38 KiB]
Скачиваний: 45
схема_Dom_9.rar [206.62 KiB]
Скачиваний: 39
Вернуться наверх
 
Не в сети
 Заголовок сообщения: Re: Котуинко
СообщениеДобавлено: Пт окт 10, 2025 11:52:15 
Друг Кота
Аватар пользователя

Карма: 96
Рейтинг сообщений: 1494
Зарегистрирован: Вт мар 16, 2010 22:02:27
Сообщений: 15331
Откуда: ДОНЕЦК
Рейтинг сообщения: 0
У каждого свои предпочтения.
8)
Однако городить полноценную внутри домовую/внутриквартирную сеть ради пары простых приборчиков для домашнего хозяйства это не слишком оправдано.
Но и не исключается, если такая сеть уже ранее сделана и самоделка является дополнением к уже ранее созданному.
Я ж сетевыми вариантами не занимаюсь - разве что небольшие проекты с вынесенными датчиками и/или функциональными блоками.
8)
Касательно "единого массива текста" - все же значительно более удобен вариант из нескольких файлов.
Редактирование "выкусь - копировать - вставить" или вставка целым блоком "библиотеки" похожи, но не совсем одно и то же.
8)


Вернуться наверх
 
Не в сети
 Заголовок сообщения: Re: Котуинко
СообщениеДобавлено: Пт окт 10, 2025 12:31:07 
Друг Кота

Карма: -1
Рейтинг сообщений: 86
Зарегистрирован: Вт мар 13, 2012 12:16:13
Сообщений: 8887
Откуда: .ru
Рейтинг сообщения: 0
многие говорят что это всё просто игрушки...
а я говорю что это на самом деле реально удобно.
удобно когда лёжа на диване можно управлять всеми бытовыми приборами в доме.
СпойлерИзображение

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


Вернуться наверх
 
Не в сети
 Заголовок сообщения: Re: Котуинко
СообщениеДобавлено: Пт окт 10, 2025 14:42:00 
Друг Кота
Аватар пользователя

Карма: 96
Рейтинг сообщений: 1494
Зарегистрирован: Вт мар 16, 2010 22:02:27
Сообщений: 15331
Откуда: ДОНЕЦК
Рейтинг сообщения: 0
У каждого свои предпочтения.
8)
Однако система выноса в отдельный файл текста обработчика алгоритма и/или аппаратного модуля достаточно удобна.
Помимо прочего такой подход приучает выделять задачу, а не размешивать по всей программе в разных местах (если таковое не вынужденная мера).
8)


Вернуться наверх
 
Не в сети
 Заголовок сообщения: Re: Котуинко
СообщениеДобавлено: Пт окт 10, 2025 14:54:33 
Мудрый кот

Карма: 25
Рейтинг сообщений: 494
Зарегистрирован: Сб май 05, 2012 20:24:52
Сообщений: 1815
Откуда: KN34PC, Болгария
Рейтинг сообщения: 3
roman.com, если кто-то захочет продолжить ваш файл с конструкцией позже во времени, даже вы через год-два например, несмотря на столько комментариев, будет сложно, почти невозможно.

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


Вернуться наверх
 
Не в сети
 Заголовок сообщения: Re: Котуинко
СообщениеДобавлено: Пт окт 10, 2025 15:59:09 
Друг Кота
Аватар пользователя

Карма: 96
Рейтинг сообщений: 1494
Зарегистрирован: Вт мар 16, 2010 22:02:27
Сообщений: 15331
Откуда: ДОНЕЦК
Рейтинг сообщения: 0
Многое зависит и от сложности как самой основной программы, так и ее составлящих.
То же обслуживание интерактива может быть как простейшим, так и весьма навороченным, обработчики вывода на дисплей также различны. что касается коммуникационных модулей - то их порой вообще в разных участках программы можно встретить.
Постепенно от подпрограммы (функции) и до отдельного файла (или класса) переход будет происходить.
Всему свое время.
8)
А вот насчет "вспомнить прошлый код"...
:o
Это таки весьма жутковатая история/перспектива...
Особо ежли больше года прошло да распечаток с хорошим описанием нету...
Зато пару раз вспомнил и отметил забытое описание понятнее сделаешшш!
:write:
:))


Последний раз редактировалось BOB51 Пт окт 10, 2025 16:02:15, всего редактировалось 1 раз.

Вернуться наверх
 
Не в сети
 Заголовок сообщения: Re: Котуинко
СообщениеДобавлено: Пт окт 10, 2025 16:01:48 
Сверлит текстолит когтями
Аватар пользователя

Карма: 1
Рейтинг сообщений: 23
Зарегистрирован: Чт авг 21, 2014 11:11:48
Сообщений: 1264
Откуда: краснодарский край
Рейтинг сообщения: 0
roman.com писал(а):
удобно когда лёжа на диване можно управлять всеми бытовыми приборами в доме.

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


Вернуться наверх
 
Показать сообщения за:  Сортировать по:  Вернуться наверх
Начать новую тему Ответить на тему  [ Сообщений: 2326 ]     ... , , , 114, , ,  

Часовой пояс: UTC + 3 часа


Кто сейчас на форуме

Сейчас этот форум просматривают: нет зарегистрированных пользователей и гости: 14


Вы не можете начинать темы
Вы не можете отвечать на сообщения
Вы не можете редактировать свои сообщения
Вы не можете удалять свои сообщения
Вы не можете добавлять вложения

Найти:
Перейти:  


Powered by phpBB © 2000, 2002, 2005, 2007 phpBB Group
Русская поддержка phpBB
Extended by Karma MOD © 2007—2012 m157y
Extended by Topic Tags MOD © 2012 m157y