Mcu

Первая среда, для любителей всё делать правильно

Вот так выглядит STVD

Я так понял её создали, когда в моде были 16 битные цвета...

GPIO_DeInit(GPIOD);GPIO_Init(GPIOD, GPIO_PIN_3, GPIO_MODE_OUT_PP_LOW_SLOW);

void Delay(uint16_t nCount){  /* Decrement nCount value */  while (nCount != 0)  {    nCount--;  }}

/* Private function prototypes -----------------------------------------------*/void Delay (uint16_t nCount);

/**  ******************************************************************************  * @file    Project/main.c   * @author  MCD Application Team  * @version V2.3.0  * @date    16-June-2017  * @brief   Main program body   ******************************************************************************  * @attention  *  * <h2><center> COPYRIGHT 2014 STMicroelectronics</center></h2>  *  * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License");  * You may not use this file except in compliance with the License.  * You may obtain a copy of the License at:  *  *        http://www.st.com/software_license_agreement_liberty_v2  *  * Unless required by applicable law or agreed to in writing, software   * distributed under the License is distributed on an "AS IS" BASIS,   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  * See the License for the specific language governing permissions and  * limitations under the License.  *  ******************************************************************************  */ /* Includes ------------------------------------------------------------------*/#include "stm8s.h"/* Private defines -----------------------------------------------------------*//* Private function prototypes -----------------------------------------------*/void Delay (uint16_t nCount);/* Private functions ---------------------------------------------------------*/void main(void){GPIO_DeInit(GPIOD);GPIO_Init(GPIOD, GPIO_PIN_3, GPIO_MODE_OUT_PP_LOW_SLOW);  /* Infinite loop */  while (1)  {GPIO_WriteReverse(GPIOD, GPIO_PIN_3);    Delay(0xFFFF);  }  }void Delay(uint16_t nCount){  /* Decrement nCount value */  while (nCount != 0)  {    nCount--;  }}#ifdef USE_FULL_ASSERT/**  * @brief  Reports the name of the source file and the source line number  *   where the assert_param error has occurred.  * @param file: pointer to the source file name  * @param line: assert_param error line source number  * @retval : None  */void assert_failed(u8* file, u32 line){   /* User can add his own implementation to report the file name and line number,     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */  /* Infinite loop */  while (1)  {  }}#endif/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

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

/* Private define ------------------------------------------------------------*/#define _GPIO_DeInit#define _GPIO_Init#define _GPIO_WriteReverse#define _CLK_DeInit#define _CLK_SYSCLKConfig#define _TIM4_DeInit#define _TIM4_ITConfig#define _TIM4_ClearITPendingBit#define _TIM4_Cmd#define _TIM4_TimeBaseInit#define _TIM4_ClearFlag#define _HAL_GPIO_WritePin#define _GPIO_WriteLow#define _GPIO_WriteHigh//#define STM8S003/* Includes ------------------------------------------------------------------*/#include "stm8s.h"/* Uncomment the line below to enable peripheral header file inclusion */#if defined(STM8S105) || defined(STM8S005) || defined(STM8S103) || defined(STM8S003) ||\    defined(STM8S001) || defined(STM8S903) || defined (STM8AF626x) || defined (STM8AF622x)// #include "stm8s_adc1.h" #endif /* (STM8S105) ||(STM8S103) || (STM8S001) || (STM8S903) || (STM8AF626x) */#if defined(STM8S208) || defined(STM8S207) || defined(STM8S007) || defined (STM8AF52Ax) ||\    defined (STM8AF62Ax)// #include "stm8s_adc2.h"

Послевкусие.

Небольшое лирическое отступление.

Физический интерфейс.

• SEL0 Сигнал выбора первого порта, активный уровень низкий
• SEL1 Сигнал выбора второго порта, активный уровень низкий;
• CLK Тактовый сигнал интерфейса, пассивное состояние высокий уровень, по спаду сдвиг, по фронту защёлкивание;
• CMD Сигнал данных от консоли к периферии;
• DAT Сигнал данных от периферии к консоли;
• ACK Аппаратный хэндшейк, активный уровень низкий.

        ___   ___________________________   ____Данные     \ /                           \ /     или        X                             XКоманда ___/ \___________________________/ \____        ___                  ____________                  \                /            \      Такты       \              /              \                  \____________/                \____            |                             |            |           tck               |            |<--------------------------->|+-------+-------+------+-------+|       | мин.  | тип. | макс. |+-------+-------+------+-------+| tck   | 1мкс  | 4мкс |   -   |+-------+-------+------+-------+Тайминг ACK:     ____                                               SEL-     |______________________________________________     ______        __________        ___________        CLK        ||||||||          ||||||||           ||||||||                  |                 |ACK- -----------------------|_|-------------|_|---------                  |   ta1   | |     |  ta2  |                  |<------->| |     |<----->|                            | |  ap                           >|-|<-----+-----+------+-------+--------+|     | мин. |  тип. |  макс. |+-----+------+-------+--------+| ta1 | 0мкс |   -   | 100мкс | Первый байт-подтверждение+-----+------+-------+--------+| ta2 |      | 10мкс |   1мс  | Остальные+-----+------+-------+--------+|  ap | 2мкс |       |        | Длительность ACK+-----+------+-------+--------+

• R 0x52 или Read. Чтение сектора карты памяти;
• W 0x57 или Write. Запись сектора карты памяти;
• S 0x53 или Status. Чтение статуса карты памяти.

Протокол работы с картой памяти.

Чтение:

CMD 0x81 0x52 0x00 0x00 MSB LSB 0x00 0x00 0x00 0x00 0x00 ... 0x00 0x00 0x00DAT ---- FLAG 0x5A 0x5D PRV PRV 0x5C 0x4D  MSB  LSB DATA ... DATA  CHK  ACK

Запись:

CMD 0x81 0x57 0x00 0x00 MSB LSB DATA ... DATA CHK 0x00 0x00 0x00 DAT ---- FLAG 0s5A 0x5D PRV PRV  PRV ...  PRV PRV 0x5C 0x5D  ACK

Статус:

CMD 0x81 0x53 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00DAT ---- FLAG 0x5A 0x5D 0x5C 0x5D 0x04 0x00 0x00 0x80

• D5 Устанавливается некоторыми картами памяти не от Sony. Назначение неизвестно.
• D3 Устанавливается при подаче питания и сбрасывается при любой записи. Используется для обнаружения смены карты памяти.
• D2 Устанавливается при ошибках записи, актуален на следующее обращение после самой операции.

Реализация своей карты памяти.

1. При чтении необходимо время на актуализацию данных. Между номером сектора и фактической передачей данных у нас есть 4 байта, у которых мы можем немного растянуть ACK. К слову, у оригинальной карты памяти на NOR FLASH все ACK идут равномерно, у карт памяти с SPI FLASH после передачи LSB происходит задержка ACK, во время которой контроллер выставляет команду в SPI FLASH и вычитывает первый байт, а остальные он вычитывает по ходу обмена.
2. При записи после передачи всего пакета и начала самой записи в массив требуется время, но тут система сама даёт необходимую задержку.

Программная реализация.

// Инициализация карты памятиTCardType Card_Init( void ){// Локальные переменныеTCardType Res;uint32_t Cnt,OCR;uint8_t Dat, Resp;// Отключаем картуCARD_OFF; Res = ctNone;// Настраиваем SPI на медленную скорость PCLK/128: 48/128 = 0,375МГцSPI1->CR1 &= ~SPI_CR1_SPE;SPI1->CR1 = SPI_CR1_MSTR | SPI_LOW_SPEED;SPI1->CR1 |= SPI_CR1_SPE;// Топчемся на местеHAL_Delay( 1 );// Посылаем инит 256 байтfor (Cnt = 0;Cnt < 256;Cnt++ ){// Послыаем словоCard_SPI( 0xFF );}// Начинаем инициализацию картыCARD_ON;// Ожидаем готовности картыdo{// Посылаем 0xFFDat = Card_SPI( 0xFF );} while ( Dat != 0xFF );// CMD0: GO_IDLE_STATECard_SendCMD( &CARD_CMD0[ 0 ], CMD_LENGTH ); Resp = Card_WaitResp( &OCR, DISABLE, 128 );// Какой ответ получен?if ( Resp == 0x01 ){// Карта вошла в IDLE_STATE, посылаем CMD8: SEND_IF_CONDCard_SendCMD( &CARD_CMD8[ 0 ], CMD_LENGTH ); Resp = Card_WaitResp( &OCR, ENABLE, 128 );// Если был дан адекватный респонсif ( Resp != 0x01 ){// Это ветка SDv1/MMCdo{// Посылаем ACMD41: APP_SEND_OP_CONDCard_SendCMD( &CARD_ACMD41[ 0 ], CMD_LENGTH ); Resp = Card_WaitResp( &OCR, ENABLE, 128 );} while ( Resp == 0x01 );// Каков был ответ?if ( Resp == 0x00 ){// Обнаружена карта SD v1Res = ctSD1;}else{// Это ветка MMC, нам её некуда втыкатьRes = ctUnknown;}}else{// Это ветка SDv2if ( (OCR & 0x0001FF) == 0x0001AA ){// Это карта SDv2do{// Посылаем ACMD55: APP_CMDCard_SendCMD( &CARD_CMD55[ 0 ], CMD_LENGTH ); Resp = Card_WaitResp( &OCR, DISABLE, 128 );// Если ответ правильныйif ( Resp == 0x01 ){// Посылаем ACMD41: APP_SEND_OP_CONDCard_SendCMD( &CARD_ACMD41[ 0 ], CMD_LENGTH ); Resp = Card_WaitResp( &OCR, ENABLE, 128 );}} while ( Resp == 0x01 );// Каков был ответ?if ( Resp == 0x00 ){// Посылаем CMD58: READ_OCRCard_SendCMD( &CARD_CMD58[ 0 ], CMD_LENGTH ); Resp = Card_WaitResp( &OCR, ENABLE, 128 );// Каков ответ?if ( Resp == 0x00 ){// Анализируем OCRif ( (OCR & 0x40000000) == 0x00000000 ){// Карта обычной ёмкостиRes = ctSD2;}else{// Карта повышенной ёмкостиRes = ctSD3;}}else{// Эта карта неисправнаRes = ctUnknown;}}else{// Эта карта неисправнаRes = ctUnknown;}}else{// Эта карта неисправнаRes = ctUnknown;}}}else{// Карта ответила неправильноif ( Res != 0xFF ) { Res = ctUnknown; }}// Только для карт обычной ёмкостиif ( (Res == ctSD1) || (Res == ctSD2) ){// Устанавливаем размер блока 512 байт// CMD16: SET_BLOCKLENCard_SendCMD( &CARD_CMD16[ 0 ], CMD_LENGTH ); Resp = Card_WaitResp( &OCR, DISABLE, 128 );// Каков ответ?if ( Resp != 0x00 ){// Эта карта неисправнаRes = ctUnknown;}}// Выключаем картуwhile ( (SPI1->SR & SPI_SR_BSY) != 0x0000 ) { }CARD_OFF;// Если карта инициализированаif ( (Res != ctNone) && (Res != ctUnknown) ){// Настраиваем SPI на быструю скорость PCLK/2: 48/2 = 24МГцSPI1->CR1 &= ~SPI_CR1_SPE;SPI1->CR1 = SPI_CR1_MSTR;SPI1->CR1 |= SPI_CR1_SPE;}// Выходимreturn Res;}

// Чтение сектора карты памяти без DMAFunctionalState Card_Read( TCardType CardType, uint8_t *Buf, uint32_t *Loaded, uint32_t Addr ){// Локальные переменныеFunctionalState Res;uint8_t Cmd[ 6 ];uint8_t Dat,Resp;uint32_t Cnt;// ИнитRes = DISABLE;// Посмотрим, у нас в буфере уже загружено?if ( *(Loaded) != Addr ){// Сохраняем новый номер сектора*(Loaded) = Addr;// Корректируем адрес для старых картif ( (CardType == ctSD1) || (CardType == ctSD2) ){// У старых карт адрес вместо LBAAddr *= 0x00000200;}// Работаемwhile ( 1 ){// Если тип карты неправильный - выходимif ( CardType == ctNone ) { break; }if ( CardType == ctUnknown ) { break; }// Готовим команду на чтение сектораCmd[ 0 ] = CARD_CMD17;Cmd[ 1 ] = Addr >> 24;Cmd[ 2 ] = Addr >> 16;Cmd[ 3 ] = Addr >> 8;Cmd[ 4 ] = Addr;Cmd[ 5 ] = 0xFF;// Включаем картуCARD_ON;// Ожидаем готовности картыdo{// Посылаем 0xFFDat = Card_SPI( 0xFF );} while ( Dat != 0xFF );// Посылаем команду чтенияCard_SendCMD( &Cmd[ 0 ], CMD_LENGTH ); Resp = Card_WaitResp( (uint32_t *)&Cmd[ 0 ], DISABLE, 128 );// Анализируем ответ на командуif ( Resp != 0x00 ) { break; }// Ожидаем токен данныхCnt = 2048;do{// Считываем данныеDat = Card_SPI( 0xFF );// СчитаемCnt--;} while ( (Dat == 0xFF) && (Cnt > 0) );// Таймаут?if ( Cnt == 0 ) { break; }// Ошибка в токене?if ( Dat != CARD_DATA_TOKEN ) { break; }// Начались данные, загружаемfor (Cnt = 0;Cnt < 512;Cnt++){// Считываем данные*(Buf) = Card_SPI( 0xFF ); Buf++;}// Дочитываем CRCCmd[ 0 ] = Card_SPI( 0xFF );Cmd[ 1 ] = Card_SPI( 0xFF );// Без ошибокRes = ENABLE;// Выходbreak;}}else{// Без ошибокRes = ENABLE;}// Выключаем картуwhile ( (SPI1->SR & SPI_SR_BSY) != 0x0000 ) { }CARD_OFF;// Если была ошибка, обнулим номерif ( Res == DISABLE ) { *(Loaded) = 0xFFFFFFFF; }// Выходreturn Res;}

// Запись сектора карты памяти без DMAFunctionalState Card_Write( TCardType CardType, uint8_t *Buf, uint32_t *Loaded, uint32_t Addr ){// Локальные переменныеFunctionalState Res;uint8_t Cmd[ 6 ];uint8_t Dat,Resp;uint32_t Cnt;// ИнитRes = DISABLE;// Корректируем адрес для старых картif ( (CardType == ctSD1) || (CardType == ctSD2) ){// У старых карт адрес вместо LBAAddr *= 0x00000200;}// Работаемwhile ( 1 ){// Если тип карты неправильный - выходимif ( CardType == ctNone ) { break; }if ( CardType == ctUnknown ) { break; }// Готовим команду на чтение сектораCmd[ 0 ] = CARD_CMD24;Cmd[ 1 ] = Addr >> 24;Cmd[ 2 ] = Addr >> 16;Cmd[ 3 ] = Addr >> 8;Cmd[ 4 ] = Addr;Cmd[ 5 ] = 0xFF;// Включаем картуCARD_ON;// Ожидаем готовности картыdo{// Посылаем 0xFFDat = Card_SPI( 0xFF );} while ( Dat != 0xFF );// Посылаем команду чтенияCard_SendCMD( &Cmd[ 0 ], CMD_LENGTH ); Resp = Card_WaitResp( (uint32_t *)&Cmd[ 0 ], DISABLE, 128 );// Анализируем ответ на командуif ( Resp != 0x00 ) { break; }// Посылаем токен данныхCard_SPI( CARD_DATA_TOKEN );// Посылаем данные в цикле// Начались данные, загружаемfor (Cnt = 0;Cnt < 512;Cnt++){// Считываем данныеCard_SPI( *(Buf) ); Buf++;}// Досылаем CRCCard_SPI( 0xFF );Card_SPI( 0xFF );// Без ошибокRes = ENABLE;// Выходbreak;}// Выключаем картуwhile ( (SPI1->SR & SPI_SR_BSY) != 0x0000 ) { }CARD_OFF;// Успешно?if ( Res == ENABLE ){// Сохраняем новый номер сектора*(Loaded) = Addr;}else{// Обнуляем*(Loaded) = 0xFFFFFFFF;}// Выходreturn Res;}

// Прерывание по перепаду SELvoid EXTI2_3_IRQHandler( void ){// Подтверждаем прерываниеEXTI->PR = 0x00000004;// Анализируем состояние SELif ( MEM_SEL ){// SEL = 1EXTI->IMR &= 0xFFFFFFFE;State.PSIO.Mode = mdSync;// Тушим зелёную лампочкуLED_GREEN_OFF;}else{// SEL = 0EXTI->IMR |= 0x00000001;State.PSIO.Bits = 7;// Тушим лампочкиLED_GREEN_OFF; LED_RED_OFF;}// ОбесточиваемMEM_DAT1; MEM_nACK;}

// Прерывание по фронту CLKvoid EXTI0_1_IRQHandler( void ){// Подтверждаем прерываниеEXTI->PR = 0x00000001;// Локальные переменныеuint16_t AckTime;// ИнитAckTime = 0;// Считываем данныеState.PSIO.DataIn >>= 1;if ( MEM_CMD ){// Принята 1State.PSIO.DataIn |= 0x80;}else{// Принят 0State.PSIO.DataIn &= 0x7F;}// Считаем битыif ( State.PSIO.Bits > 0 ){// Ещё есть битыState.PSIO.Bits--;}else{// Кончились биты?if ( State.PSIO.Bits == 0 ){// Биты кончилисьState.PSIO.Bits = 7;// Значение по умолчаниюState.PSIO.DataOut = State.PSIO.DataIn;// Анализируем ответswitch ( State.PSIO.Mode ){// Режим синхронизацииcase mdSync : {// Принят первый байт командыif ( State.PSIO.DataIn == 0x81 ){// Команда активации картыState.PSIO.Mode = mdCmd;// Текущий ответState.PSIO.DataOut = State.MemCard.Status;// Посылаем ACKAckTime = AckNormal;}elseif ( State.PSIO.DataIn == 0x01 ){// Команда активации джойстика}// Выходbreak;}// Получаем командуcase mdCmd : {// Меняем режимState.PSIO.Mode = mdParam;// Сохраняем байт в команду и подготовим буферState.MemCard.Cmd = State.PSIO.DataIn;State.MemCard.Bytes = 0;// ОтвечаемState.PSIO.DataOut = 0x5A;// Посылаем ACKAckTime = AckNormal;// Выходbreak;}// Режим получения параметровcase mdParam : {// Почти каждый ответ требует ACKAckTime = AckNormal;// Принимаем параметрыswitch ( State.MemCard.Cmd ){// Команда чтения: Rcase 0x52 : {// Анализируем байтыswitch ( State.MemCard.Bytes ){// Просто все вариантыcase 0 : { State.PSIO.DataOut = 0x5D; break; }case 1 : { break; }case 2 : { State.MemCard.Sector = State.PSIO.DataIn * 0x0100; State.MemCard.Check = State.PSIO.DataIn; break; }case 3 : { State.MemCard.Sector += State.PSIO.DataIn; State.MemCard.Check ^= State.PSIO.DataIn; State.PSIO.DataOut = 0x5C;   State.SDCard.CardOp = coRead; AckTime = AckDelayed; break; }case 4 : { State.PSIO.DataOut = 0x5D; AckTime = AckDelayed; break; }case 5 : { State.PSIO.DataOut = State.MemCard.Sector >> 8; AckTime = AckDelayed; break; }case 6 : { State.PSIO.DataOut = State.MemCard.Sector; AckTime = AckDelayed;   State.PSIO.Mode = mdRdData; State.MemCard.Bytes = 0; break; }default : { State.PSIO.Mode = mdDone; AckTime = 0; break; }}// Сигнализируем чтениемLED_GREEN_ON;// Выходbreak;}// Команда записи: Wcase 0x57 : {// Анализируем байтыswitch ( State.MemCard.Bytes ){// Просто все вариантыcase 0 : { State.PSIO.DataOut = 0x5D; break; }case 1 : { break; }case 2 : { State.MemCard.Sector = State.PSIO.DataIn * 0x0100; State.MemCard.Check = State.PSIO.DataIn; break; }case 3 : { State.MemCard.Sector += State.PSIO.DataIn; State.MemCard.Check ^= State.PSIO.DataIn; // break; }   State.PSIO.Mode = mdWrData; State.MemCard.Bytes = 0; break; }default : { State.PSIO.Mode = mdDone; AckTime = 0; break; }}// Сигнализируем записьюLED_RED_ON;// Выходbreak;}// Команда параметров: Scase 0x53 : {// Выставляем байт согласно номеруswitch ( State.MemCard.Bytes ){// Просто все вариантыcase 0 : { State.PSIO.DataOut = 0x5D; break; }case 1 : { State.PSIO.DataOut = 0x5C; break; }case 2 : { State.PSIO.DataOut = 0x5D; break; }case 3 : { State.PSIO.DataOut = 0x04; break; }case 4 : { State.PSIO.DataOut = 0x00; break; }case 5 : { State.PSIO.DataOut = 0x00; break; }case 6 : { State.PSIO.DataOut = 0x80; break; }default : { State.PSIO.Mode = mdDone; AckTime = 0; break; }}// Выходbreak;}// По умолчаниюdefault : { State.PSIO.Mode = mdDone; break; }}// Считаем номерif ( State.PSIO.Mode == mdParam ) { State.MemCard.Bytes++; }// Выходbreak;}// Режим передачи данных для чтенияcase mdRdData : {// Почти каждый ответ требует ACKAckTime = AckNormal;// Счётчик байтif ( State.MemCard.Bytes < 128 ){// Это передача данныхState.PSIO.DataOut = State.MemCard.Data[ State.MemCard.Bytes ]; State.MemCard.Check ^= State.PSIO.DataOut;}else{// Это хвостик за пределами данныхswitch ( State.MemCard.Bytes ){// Передача контрольной суммыcase 128 : { State.PSIO.DataOut = State.MemCard.Check; break; }// Передача завершающего статусаcase 129 : { State.PSIO.DataOut = 0x47; break; }// Завершение работыdefault : { State.PSIO.Mode = mdDone; AckTime = 0; LED_GREEN_OFF; break; }}}// СчитаемState.MemCard.Bytes++;// Выходbreak;}// Режим приёма данных для записиcase mdWrData : {// Почти каждый ответ требует ACKAckTime = AckNormal;// Счётчик байтif ( State.MemCard.Bytes < 128 ){// Это приём данныхState.MemCard.Data[ State.MemCard.Bytes ] = State.PSIO.DataIn; State.MemCard.Check ^= State.PSIO.DataIn;}else{// Это хвостик за пределамы данныхswitch ( State.MemCard.Bytes ){// Это приём контрольной суммыcase 128 : {// Сравниваем контрольную сумму и выносим решениеif ( State.MemCard.Check == State.PSIO.DataIn ) { State.MemCard.Check = 0x47; } else { State.MemCard.Check = 0x4E; }// Начинаем подтверждать приёмState.PSIO.DataOut = 0x5C;// Выходимbreak;}// Это хвостик данныхcase 129 : { State.PSIO.DataOut = 0x5D; break; }// Это вывод результата командыcase 130 : {// Сначала проверим, что сектор задан верноif ( State.MemCard.Sector < 0x4000 ){// Сектор верен, отдаём результат проверкиState.PSIO.DataOut = State.MemCard.Check;// Какой результат проверки?if ( State.MemCard.Check == 0x47 ){// Заказываем запись сектора в карту памятиState.SDCard.CardOp = coWrite;// После успешной записи обнуляется флагState.MemCard.Status &= ~StateNew;}}else{// Сектор ошибочен, выдаём ошибку сектораState.PSIO.DataOut = 0xFF;}// Выходbreak;}// Завершение работыdefault : { State.PSIO.Mode = mdDone; AckTime = 0; break; }}}// СчитаемState.MemCard.Bytes++;// Выходbreak;}// Заглушка, тупим до конца пакетаcase mdDone : { break; }// По умолчанию - откатываемся в началоdefault : { State.PSIO.Mode = mdSync; break; }}}}// Выставляем свои данныеif ( State.PSIO.Mode != mdSync ){// Выставляем текущий бит выводного байтаif ( State.PSIO.DataOut & 0x01 ){// Выставляем 1MEM_DAT1;}else{// Выставляем 0MEM_DAT0;}// Сдвигаем данныеState.PSIO.DataOut >>= 1;}// Требуется ACK?if ( AckTime > 0 ){// Установим CNTTIM3->CNT = AckTime;// Устанавливаем флагState.PSIO.Ack = DISABLE;// Сбросим событияTIM3->SR = 0x0000;// Включаем таймерTIM3->CR1 |= TIM_CR1_CEN;}}

// Прерывание таймера TIM3void TIM3_IRQHandler( void ){// Снимаем флагTIM3->SR = 0x0000;// Анализируем режимif ( State.PSIO.Ack == ENABLE ){// Выключаем сигнал ACKMEM_nACK;}else{// Включаем сигнал ACKMEM_ACK;// Перекидываем режимState.PSIO.Ack = ENABLE;// Новый таймаутTIM3->CNT = 0;// Включаем таймерTIM3->CR1 |= TIM_CR1_CEN;}}

// Основной циклwhile ( 1 ){// Обрабатываем сигнал вытаскивания картыif ( CARD_nCD == 0 ){// Карта вставленаif ( State.SDCard.CardType == ctNone ){// Включаем зелёную лампочкуLED_GREEN_ON; LED_RED_OFF;// Карту только что поменяли, пытаемся обнаружитьState.SDCard.CardType = Card_Init();// Карта обнаружена?if ( State.SDCard.CardType != ctUnknown ){// Анализируем файловую систему картыif ( Card_FSInit( &State.SDCard, &CARD_IMAGE[ 0 ] ) == ENABLE ){// Файлоавая система опознана, разрешаем работуEXTI->IMR |= 0x00000004;// Выключаем лампочкиLED_GREEN_OFF; LED_RED_OFF;}else{// Файловая система не опознанаState.SDCard.CardType = ctUnknown;// Зажигаем обе лампочкиLED_GREEN_ON; LED_RED_ON;}}else{// Зажигаем обе лампочкиLED_GREEN_ON; LED_RED_ON;}}}else{// Карта отсутствуетif ( State.SDCard.CardType != ctNone ){// Только вытащили, отключаем PSIOEXTI->IMR &= 0xFFFFFFFA;// Обнуляем все переменныеState.PSIO.Mode = mdSync; State.PSIO.Bits = 0; State.PSIO.DataIn = 0x00; State.PSIO.DataOut = 0; State.PSIO.Ack = DISABLE;State.MemCard.Status = StateNew;State.SDCard.CardType = ctNone; State.SDCard.CardOp = coIdle; State.SDCard.LoadedLBA = 0xFFFFFFFF;}// Потушим обе лампочкиLED_GREEN_OFF; LED_RED_OFF;}// Если карта естьif ( (State.SDCard.CardType != ctNone) && (State.SDCard.CardType != ctUnknown) ){// Заказана запись?if ( State.SDCard.CardOp == coWrite ){// Вычисляем сектор чтения и смещение в блокеOfs = State.MemCard.Sector & 0x03FF;LBA = (Ofs >> 2) & 0x000000FF;Ofs = (Ofs << 7) & 0x00000180;// Считываем сектор в буферCard_Read( State.SDCard.CardType, &State.SDCard.CardBuf[ 0 ], &State.SDCard.LoadedLBA, State.SDCard.CardList[ LBA ] );// Подменяем наш секторfor (Cnt = 0;Cnt < 128;Cnt++){// Переносим данныеState.SDCard.CardBuf[ Ofs + Cnt ] = State.MemCard.Data[ Cnt ];}// Пишем сетор назадCard_Write( State.SDCard.CardType, &State.SDCard.CardBuf[ 0 ], &State.SDCard.LoadedLBA, State.SDCard.CardList[ LBA ] );// Потушем лампочкуLED_RED_OFF;// Снимаем флагState.SDCard.CardOp = coIdle;}// Заказано чтение?if ( State.SDCard.CardOp == coRead ){// Вычисляем сектор чтения и смещение в блокеOfs = State.MemCard.Sector & 0x03FF;LBA = (Ofs >> 2) & 0x000000FF;Ofs = (Ofs << 7) & 0x00000180;// Считываем сектор в буферCard_Read( State.SDCard.CardType, &State.SDCard.CardBuf[ 0 ], &State.SDCard.LoadedLBA, State.SDCard.CardList[ LBA ] );// Копируем нужный секторfor (Cnt = 0;Cnt < 128;Cnt++){// Переносим данныеState.MemCard.Data[ Cnt ] = State.SDCard.CardBuf[ Ofs + Cnt ];}// Снимаем флагState.SDCard.CardOp = coIdle;}}}

1. Анализируем сектор LBA=#0 на предмет MBR. Если это действительно MBR, то получаем новый сектор, где находится MBS.
2. Получив адрес предполагаемого MBS (это может быть #0, если нет MBR или какое-то число, если MBR есть) мы начинаем его анализ на предмет принадлежности одной из FAT: FAT12, FAT16, FAT32 или vFAT.
3. Если сектор прошёл проверку, то мы забираем из него информацию о структуре и в корневом каталоге ищем элемент с именем файла. В данном случае это MEMCRD00.BIN.
4. Если такой файл находится, то проверяем его размер он должен быть строго фиксирован 0x20000 байт. Если всё так получаем номер первого кластера.
5. Если мы дошли до этого пункта, то у нас уже есть вся необходимая информации для построения списка физических LBA секторов, где расположен наш образ. Пробегая по цепочке FAT и используя информацию о структуре из MBS, заполняем таблицу из 256 номеров LBA секторов.

// Инициализация таблицы секторов по имени файла, поддерживается пока только FAT16FunctionalState Card_FSInit( TSDCard *SDCard, const uint8_t *FName ){// Локальные переменныеFunctionalState Res;uint8_t *Buf;uint8_t Pos;uint16_t ClustSize,Reserv,RootSize,FATSize,Cluster;uint32_t Cnt,LBA,SysOrg,FATOrg,RootOrg,DataOrg;int Compare;// ИнитRes = DISABLE; SysOrg = 0; Cluster = 0xFFFF;// Начинаем с самого сначалаwhile ( 1 ){// Вычитываем сектор 0if ( Card_Read( SDCard->CardType, &SDCard->CardBuf[ 0 ], &SDCard->LoadedLBA, SysOrg ) == DISABLE ) { break; }// Анализируем сектор #0 на MBRif ( *((uint16_t *)&SDCard->CardBuf[ 0x01FE ]) != 0xAA55 ) { break; }// Проверим косвенные признаки MBRif ( ((SDCard->CardBuf[ 0x01BE ] == 0x00) || (SDCard->CardBuf[ 0x01BE ] == 0x80)) && ((SDCard->CardBuf[ 0x01CE ] == 0x00) || (SDCard->CardBuf[ 0x01CE ] == 0x80)) && ((SDCard->CardBuf[ 0x01DE ] == 0x00) || (SDCard->CardBuf[ 0x01DE ] == 0x80)) && ((SDCard->CardBuf[ 0x01EE ] == 0x00) || (SDCard->CardBuf[ 0x01EE ] == 0x80)) ){// Похоже на MBR, анализируем таблицу разделовfor (Cnt = 0;Cnt < 4;Cnt++){// Анализируем признак разделаif ( (SDCard->CardBuf[ (Cnt * 0x0010) + 0x01C2 ] == 0x01) ||// Сигнатура 0x01: FAT12 (SDCard->CardBuf[ (Cnt * 0x0010) + 0x01C2 ] == 0x04) ||// Сигнатура 0x04: FAT16 (SDCard->CardBuf[ (Cnt * 0x0010) + 0x01C2 ] == 0x06) ||// Сигнатура 0x06: Big FAT16 (SDCard->CardBuf[ (Cnt * 0x0010) + 0x01C2 ] == 0x0E) )// Сигнатура 0x0E: vFAT{// Сигнатура подошла, забираем адрес MBS разделаSysOrg = SDCard->CardBuf[ (Cnt * 0x0010) + 0x01C6 ];SysOrg += (SDCard->CardBuf[ (Cnt * 0x0010) + 0x01C7 ] * 0x00000100);SysOrg += (SDCard->CardBuf[ (Cnt * 0x0010) + 0x01C8 ] * 0x00010000);SysOrg += (SDCard->CardBuf[ (Cnt * 0x0010) + 0x01C9 ] * 0x01000000);// Выходимbreak;}}}// Загружаем сектор предполагаемого MBSif ( Card_Read( SDCard->CardType, &SDCard->CardBuf[ 0 ], &SDCard->LoadedLBA, SysOrg ) == DISABLE ) { break; }// Анализируем сектор на MBSif ( *((uint16_t *)&SDCard->CardBuf[ 0x01FE ]) != 0xAA55 ) { break; }if ( SDCard->CardBuf[ 0x000D ] == 0x00 ) { break; }if ( (SDCard->CardBuf[ 0x0010 ] == 0x00) || (SDCard->CardBuf[ 0x0010 ] > 0x02) ) { break; }if ( SDCard->CardBuf[ 0x0015 ] != 0xF8 ) { break; }if ( *((uint32_t *)&SDCard->CardBuf[ 0x001C ]) != SysOrg ) { break; }if ( SDCard->CardBuf[ 0x0026 ] != 0x29 ) { break; }if ( *((uint16_t *)&SDCard->CardBuf[ 0x0036 ]) != 0x4146 ) { break; }if ( *((uint16_t *)&SDCard->CardBuf[ 0x0038 ]) != 0x3154 ) { break; }if ( SDCard->CardBuf[ 0x003A ] != 0x36 ) { break; }// Заполняем локальные переменные, которые нужны для математикиClustSize = SDCard->CardBuf[ 0x000D ];Reserv = *((uint16_t *)&SDCard->CardBuf[ 0x000E ]);RootSize = (SDCard->CardBuf[ 0x0012 ] * 0x0100) + SDCard->CardBuf[ 0x0011 ];FATSize = *((uint16_t *)&SDCard->CardBuf[ 0x0016 ]);// Вычисляем координаты FAT и ROOTFATOrg = SysOrg + Reserv;RootOrg = FATOrg + (FATSize * 2);DataOrg = RootOrg + (RootSize / 16 );// Все данные получены, приступаем к поиску имени файла нужного имиджаfor (LBA = 0;LBA < (RootSize / 16);LBA++){// Загружаем сектор корневой папкиif ( Card_Read( SDCard->CardType, &SDCard->CardBuf[ 0 ], &SDCard->LoadedLBA, RootOrg + LBA ) == ENABLE ){// Перебираем 16 элементов, которые могут находиться в сектореfor (Cnt = 0;Cnt < 16;Cnt++){// Сравниваем имяCompare = memcmp( &SDCard->CardBuf[ Cnt * 32 ], &CARD_IMAGE[ 0 ], 11 );if (  Compare == 0 ){// Файл найден, проверим размерif ( *((uint32_t *)&SDCard->CardBuf[ (Cnt * 32) + 0x001C ]) == 0x00020000 ){// Размер подходит, копируем номер кластераCluster = *((uint16_t *)&SDCard->CardBuf[ (Cnt * 32) + 0x001A ]);// Без ошибокRes = ENABLE;// Выходимbreak;}}}// Если файл найден - выходим экстренноif ( Res == ENABLE ) { break; }}else{// ошибка загрузки - вываливаемсяbreak;}}// Файл найден, данные получены, начинаем построение таблицы доступаif ( Res == ENABLE ){// У нас есть номер кластера, готовимся заполнять табличкуPos = 0;do{// Проверяем номер кластераif ( Cluster < 0x0002 ){// Ошибка, выходимRes = DISABLE; break;}// Вычисляем LBA данных кластераLBA = DataOrg + ((Cluster - 2) * ClustSize);// В цикле по размерку кластера заполняем элементы таблицыfor (Cnt = 0;Cnt < ClustSize;Cnt++){// Вычисляем LBA сектроа внутри кластераSDCard->CardList[ Pos ] = LBA + Cnt;// Следующий элементPos++; if ( Pos == 0 ) { break; }}// Если есть ещё элементы, надо получить новый номер кластера// А для этого надо вычислить номер сектора, где этот кластер находится и загрузить его по цепочкеif ( Pos != 0 ){// Вычисляем сектор нахождения кластераLBA = FATOrg; Reserv = Cluster;while ( Reserv > 256 ) { LBA++; Reserv -= 256; }// Загружаем этот сектор в памятьif ( Card_Read( SDCard->CardType, &SDCard->CardBuf[ 0 ], &SDCard->LoadedLBA, LBA ) == ENABLE ){// Забираем новый номер кластераCluster = *((uint16_t *)&SDCard->CardBuf[ Reserv * 2 ]);}else{// Ошибка загрузкиRes = DISABLE; break;}}} while ( (Cluster != 0xFFFF) && (Pos != 0) );}// Выходbreak;}// Выходreturn Res;}

python3 -m http.server -d <site folder>

Статический сайт

$ ls website/em_big.png  index.html

python3 -m http.server -d website/

$ ls website/em_big.png  index.html  Mybuild

package embox.demomodule website {    @InitFS    source "index.html",        "em_big.png",}

    include embox.cmd.net.httpd        include embox.demo.website

"service httpd /",

$ ls website/app.js  css  images  index.html  Mybuild  partials

Динамический контент

CGI

#!/bin/bashecho -ne "HTTP/1.1 200 OK\r\n"echo -ne "Content-Type: application/json\r\n"echo -ne "Connection: Connection: close\r\n"echo -ne "\r\n"tm=`LC_ALL=C date +%c`echo -ne "\"$tm\"\n\n"

./cgi-bin/gettimeHTTP/1.1 200 OKContent-Type: application/jsonConnection: Connection: close"Fri Feb  5 20:58:19 2021"

#include <stdio.h>#include <unistd.h>#include <string.h>int main(int argc, char *argv[]) {    char buf[128];    char *pbuf;    struct timeval tv;    time_t time;    printf(        "HTTP/1.1 200 OK\r\n"        "Content-Type: application/json\r\n"        "Connection: Connection: close\r\n"        "\r\n"    );    pbuf = buf;    pbuf += sprintf(pbuf, "\"");    gettimeofday(&tv, NULL);    time = tv.tv_sec;    ctime_r(&time, pbuf);    strcat(pbuf, "\"\n\n");    printf("%s", buf);    return 0;}

app.controller("SystemCtrl", ['$scope', '$http', function($scope, $http) {    $scope.time = null;    $scope.update = function() {        $http.get('cgi-bin/gettime').then(function (r) {            $scope.time = r.data;        });    };    $scope.update();}]);

python3 -m http.server --cgi -d .

Автоматическое обновление динамического контента

• Server Side Includes (SSI)
• Server-sent Events (SSE)
• WebSockets
• И так далее

Server Side Includes (SSI).

<meta http-equiv="refresh" content="1">

<BODY onLoad="window.setTimeout("location.href='runtime.shtml'",2000)">

Server-sent Events

        "Content-Type: text/event-stream\r\n"        "Cache-Control: no-cache\r\n"        "Connection: keep-alive\r\n"

: this is a test streamdata: some textdata: another messagedata: with two lines

data: { time: <real date>}

#!/bin/bashecho -ne "HTTP/1.1 200 OK\r\n"echo -ne "Content-Type: text/event-stream\r\n"echo -ne "Cache-Control: no-cache\r\n"echo -ne "Connection: keep-alive\r\n"echo -ne "\r\n"while true; do    tm=`LC_ALL=C date +%c`    echo -ne "data: {\"time\" : \"$tm\"}\n\n" 2>/dev/null || exit 0    sleep 1done

$ ./cgi-bin/gettimeHTTP/1.1 200 OKContent-Type: text/event-streamCache-Control: no-cacheConnection: keep-alivedata: {"time" : "Fri Feb  5 21:48:11 2021"}data: {"time" : "Fri Feb  5 21:48:12 2021"}data: {"time" : "Fri Feb  5 21:48:13 2021"}

#include <stdio.h>#include <unistd.h>#include <string.h>int main(int argc, char *argv[]) {    char buf[128];    char *pbuf;    struct timeval tv;    time_t time;    printf(        "HTTP/1.1 200 OK\r\n"        "Content-Type: text/event-stream\r\n"        "Cache-Control: no-cache\r\n"        "Connection: keep-alive\r\n"        "\r\n"    );    while (1) {        pbuf = buf;        pbuf += sprintf(pbuf, "data: {\"time\" : \"");        gettimeofday(&tv, NULL);        time = tv.tv_sec;        ctime_r(&time, pbuf);        strcat(pbuf, "\"}\n\n");        if (0 > printf("%s", buf)) {            break;        }        sleep(1);    }    return 0;}

app.controller("SystemCtrl", ['$scope', '$http', function($scope, $http) {    $scope.time = null;    var eventCallbackTime = function (msg) {        $scope.$apply(function () {            $scope.time = JSON.parse(msg.data).time        });    }    var source_time = new EventSource('/cgi-bin/gettime');    source_time.addEventListener('message', eventCallbackTime);    $scope.$on('$destroy', function () {        source_time.close();    });    $scope.update = function() {    };    $scope.update();}]);

Демо

#!/bin/bashecho -ne "HTTP/1.1 200 OK\r\n"echo -ne "Content-Type: text/event-stream\r\n"echo -ne "Cache-Control: no-cache\r\n"echo -ne "Connection: keep-alive\r\n"echo -ne "\r\n"while true; do    x=$((1 + $RANDOM % 15000))    y=$((1 + $RANDOM % 15000))    z=$((1 + $RANDOM % 15000))    echo -ne "data: {\"rate\" : \"x:$x y:$y z:$z\"}\n\n" 2>/dev/null || exit 0    sleep 1done

#!/bin/python3import cgiimport sysprint("HTTP/1.1 200 OK")print("Content-Type: text/plain")print("Connection: close")print()form = cgi.FieldStorage()cmd = form['cmd'].valueif cmd == 'serialize_states':    with open('cgi-bin/leds.txt', 'r') as f:        print('[' + f.read() + ']')elif cmd == 'clr' or cmd == 'set':    led_nr = int(form['led'].value)    with open('cgi-bin/leds.txt', 'r+') as f:        leds = f.read().split(',')        leds[led_nr] = str(1 if cmd == 'set' else 0)        f.seek(0)        f.write(','.join(leds))

Заключение

Разработка прототипа на Linux

libmodbus-$(LIBMODBUS_VER).tar.gz:    wget http://libmodbus.org/releases/libmodbus-$(LIBMODBUS_VER).tar.gz$(BUILD_BASE)/libmodbus/lib/pkgconfig/libmodbus.pc : libmodbus-$(LIBMODBUS_VER).tar.gz    tar -xf libmodbus-$(LIBMODBUS_VER).tar.gz    cd libmodbus-$(LIBMODBUS_VER); \    ./configure --prefix=$(BUILD_BASE)/libmodbus --enable-static --disable-shared; \    make install; cd ..;

    ctx = modbus_new_tcp(ip, port);    header_len = modbus_get_header_length(ctx);    query = malloc(MODBUS_TCP_MAX_ADU_LENGTH);    modbus_set_debug(ctx, TRUE);    mb_mapping = mb_mapping_wrapper_new();    if (mb_mapping == NULL) {        fprintf(stderr, "Failed to allocate the mapping: %s\n",                modbus_strerror(errno));        modbus_free(ctx);        return -1;    }    listen_socket = modbus_tcp_listen(ctx, 1);    for (;;) {        client_socket = modbus_tcp_accept(ctx, &listen_socket);        if (-1 == client_socket) {            break;        }        for (;;) {            int query_len;            query_len = modbus_receive(ctx, query);            if (-1 == query_len) {                /* Connection closed by the client or error */                break;            }            if (query[header_len - 1] != MODBUS_TCP_SLAVE) {                continue;            }            mb_mapping_getstates(mb_mapping);            if (-1 == modbus_reply(ctx, query, query_len, mb_mapping)) {                break;            }            leddrv_updatestates(mb_mapping->tab_bits);        }        close(client_socket);    }    printf("exiting: %s\n", modbus_strerror(errno));    close(listen_socket);    mb_mapping_wrapper_free(mb_mapping);    free(query);    modbus_free(ctx);

static modbus_mapping_t *mb_mapping_wrapper_new(void) {    modbus_mapping_t *mb_mapping;    mb_mapping = modbus_mapping_new(LEDDRV_LED_N, 0, 0, 0);    return mb_mapping;}static void mb_mapping_wrapper_free(modbus_mapping_t *mb_mapping) {    modbus_mapping_free(mb_mapping);}static void mb_mapping_getstates(modbus_mapping_t *mb_mapping) {    int i;    leddrv_getstates(mb_mapping->tab_bits);    for (i = 0; i < mb_mapping->nb_bits; i++) {        mb_mapping->tab_bits[i] = mb_mapping->tab_bits[i] ? ON : OFF;    }}

static unsigned char leddrv_leds_state[LEDDRV_LED_N];int leddrv_init(void) {    static int inited = 0;    if (inited) {        return 0;    }    inited = 1;    leddrv_ll_init();    leddrv_load_state(leddrv_leds_state);    leddrv_ll_update(leddrv_leds_state);    return 0;}...int leddrv_getstates(unsigned char leds_state[LEDDRV_LED_N]) {    memcpy(leds_state, leddrv_leds_state, sizeof(leddrv_leds_state));    return 0;}int leddrv_updatestates(unsigned char new_leds_state[LEDDRV_LED_N]) {    memcpy(leddrv_leds_state, new_leds_state, sizeof(leddrv_leds_state));    leddrv_ll_update(leddrv_leds_state);    return 0;}

void leddrv_ll_update(unsigned char leds_state[LEDDRV_LED_N]) {    int i;    int idx;    char buff[LEDDRV_LED_N * 2];        for (i = 0; i < LEDDRV_LED_N; i++) {        char state = !!leds_state[i];        fprintf(stderr, "led(%03d)=%d\n", i, state);        buff[i * 2] = state + '0';        buff[i * 2 + 1] = ',';    }    idx = open(LED_FILE_NAME, O_RDWR);    if (idx < 0) {        return;    }    write(idx, buff, (LEDDRV_LED_N * 2) - 1);    close(idx);}...void leddrv_load_state(unsigned char leds_state[LEDDRV_LED_N]) {    int i;    int idx;    char buff[LEDDRV_LED_N * 2];    idx = open(LED_FILE_NAME, O_RDWR);    if (idx < 0) {        return;    }    read(idx, buff, (LEDDRV_LED_N * 2));    close(idx);        for (i = 0; i < LEDDRV_LED_N; i++) {        leds_state[i] = buff[i * 2] - '0';    }}

0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1

./led-serverled(000)=0led(001)=1...led(078)=0led(079)=1

ctx = modbus_new_tcp(ip, port);    if (ctx == NULL) {        fprintf(stderr, "Unable to allocate libmodbus context\n");        return -1;    }    modbus_set_debug(ctx, TRUE);    modbus_set_error_recovery(ctx,            MODBUS_ERROR_RECOVERY_LINK |            MODBUS_ERROR_RECOVERY_PROTOCOL);    if (modbus_connect(ctx) == -1) {        fprintf(stderr, "Connection failed: %s\n",                modbus_strerror(errno));        modbus_free(ctx);        return -1;    }    if (1 == modbus_write_bit(ctx, bit_n, bit_value)) {        printf("OK\n");    } else {        printf("FAILED\n");    }    /* Close the connection */    modbus_close(ctx);    modbus_free(ctx);

./led-client set 78Connecting to 127.0.0.1:1502[00][01][00][00][00][06][FF][05][00][4E][FF][00]Waiting for a confirmation...<00><01><00><00><00><06><FF><05><00><4E><FF><00>OK

...led(076)=0led(077)=1led(078)=1led(079)=1Waiting for an indication...ERROR Connection reset by peer: read

./led-client clr 78Connecting to 127.0.0.1:1502[00][01][00][00][00][06][FF][05][00][4E][00][00]Waiting for a confirmation...<00><01><00><00><00><06><FF><05><00><4E><00><00>OK

...led(076)=0led(077)=1led(078)=0led(079)=1Waiting for an indication...ERROR Connection reset by peer: read

#!/bin/bashecho -ne "HTTP/1.1 200 OK\r\n"echo -ne "Content-Type: application/json\r\n"echo -ne "Connection: close\r\n"echo -ne "\r\n"if [ $REQUEST_METHOD = "GET" ]; then    echo "Query: $QUERY_STRING" >&2    case "$QUERY_STRING" in        "c=led_driver&a1=serialize_states")            echo [ $(cat ../emulate/conf/leds.txt) ]            ;;        "c=led_driver&a1=serialize_errors")            echo [ $(printf "0, %.0s" {1..79}) 1 ]            ;;        "c=led_names&a1=serialize")            echo '[ "one", "two", "WWWWWWWWWWWWWWWW", "W W W W W W W W " ]'            ;;    esacelif [ $REQUEST_METHOD = "POST" ]; then    read -n $CONTENT_LENGTH POST_DATA    echo "Posted: $POST_DATA" >&2fi

python3 -m http.server --cgi -d .

./led-client -a 127.0.0.1 set 78Connecting to 127.0.0.1:1502[00][01][00][00][00][06][FF][05][00][4E][FF][00]Waiting for a confirmation...<00><01><00><00><00><06><FF><05><00><4E><FF><00>OK

./led-client -a 127.0.0.1 clr 79Connecting to 127.0.0.1:1502[00][01][00][00][00][06][FF][05][00][4F][00][00]Waiting for a confirmation...<00><01><00><00><00><06><FF><05><00><4F><00><00>OK

Адаптация к Embox и запуск на эмуляторе

Библиотека libmodbus

package third_party.lib@Build(script="$(EXTERNAL_MAKE)")@BuildArtifactPath(cppflags="-I$(ROOT_DIR)/build/extbld/third_party/lib/libmodbus/install/include/modbus")module libmodbus {    @AddPrefix("^BUILD/extbld/^MOD_PATH/install/lib")    source "libmodbus.a"    @NoRuntime depends embox.compat.posix.util.nanosleep}

PKG_NAME := libmodbusPKG_VER  := 3.1.6PKG_SOURCES := http://libmodbus.org/releases/$(PKG_NAME)-$(PKG_VER).tar.gzPKG_MD5     := 15c84c1f7fb49502b3efaaa668cfd25ePKG_PATCHES := accept4_disable.patchinclude $(EXTBLD_LIB)libmodbus_cflags = -UHAVE_ACCEPT4$(CONFIGURE) :    export EMBOX_GCC_LINK=full; \    cd $(PKG_SOURCE_DIR) && ( \        CC=$(EMBOX_GCC) ./configure --host=$(AUTOCONF_TARGET_TRIPLET) \        prefix=$(PKG_INSTALL_DIR) \        CFLAGS=$(libmodbus_cflags) \    )    touch $@$(BUILD) :    cd $(PKG_SOURCE_DIR) && ( \        $(MAKE) install MAKEFLAGS='$(EMBOX_IMPORTED_MAKEFLAGS)'; \    )    touch $@

Подключаем проект к Embox

make ext_conf EXT_PROJECT_PATH=<path to project> 

 make ext_conf EXT_PROJECT_PATH=~/git/embox_project_modbus_iocontrol

modbus-server

package iocontrol.modbus.cmd@AutoCmd@Build(script="true")@BuildDepends(third_party.lib.libmodbus)@Cmd(name="modbus_server")module modbus_server {    source "modbus_server.c"    @NoRuntime depends third_party.lib.libmodbus}

    include iocontrol.modbus.http_admin    include iocontrol.modbus.cmd.flash_settings    include iocontrol.modbus.cmd.led_names    include third_party.lib.libmodbus    include iocontrol.modbus.cmd.modbus_server    include iocontrol.modbus.cmd.led_driver    include embox.service.cgi_cmd_wrapper(cmds_check=true, allowed_cmds="led_driver led_names flash_settings")    include iocontrol.modbus.lib.libleddrv_ll_stub

"export PWD=/","export HOME=/","netmanager","service telnetd","service httpd http_admin","ntpdate 0.europe.pool.ntp.org","mkdir -v /conf","mount -t ramfs /dev/static_ramdisk /conf","cp leds.txt /conf/leds.txt","led_driver init","service modbus_server","tish",

./scripts/qemu/auto_qemu

./led-client -a 10.0.2.16 set 78Connecting to 10.0.2.16:1502[00][01][00][00][00][06][FF][05][00][4E][FF][00]Waiting for a confirmation...<00><01><00><00><00><06><FF><05><00><4E><FF><00>OK

./led-client -a 10.0.2.16 clr 79Connecting to 10.0.2.16:1502[00][01][00][00][00][06][FF][05][00][4F][00][00]Waiting for a confirmation...<00><01><00><00><00><06><FF><05><00><4F><00><00>

Запуск на микроконтроллере

package iocontrol.modbus.libstatic module libleddrv {    option number leds_quantity = 80...}

#ifdef __EMBOX__#include <framework/mod/options.h>#include <module/iocontrol/modbus/lib/libleddrv.h>#define LEDDRV_LED_N OPTION_MODULE_GET(iocontrol__modbus__lib__libleddrv,NUMBER,leds_quantity)#else#define LEDDRV_LED_N 80#endif

    include  iocontrol.modbus.lib.libleddrv(leds_quantity=4)

struct leddrv_pin_desc {    int gpio; /**< port */    int pin; /**< pin mask */};static const struct leddrv_pin_desc leds[] = {    #include <leds_config.inc>};void leddrv_ll_init(void) {    int i;    for (i = 0; i < LEDDRV_LED_N; i++) {        gpio_setup_mode(leds[i].gpio, leds[i].pin, GPIO_MODE_OUTPUT);    }}void leddrv_ll_update(unsigned char leds_state[LEDDRV_LED_N]) {    int i;    for (i = 0; i < LEDDRV_LED_N; i++) {        gpio_set(leds[i].gpio, leds[i].pin,                leds_state[i] ? GPIO_PIN_HIGH : GPIO_PIN_LOW);    }}

    include iocontrol.modbus.http_admin    include iocontrol.modbus.cmd.flash_settings    include iocontrol.modbus.cmd.led_names    include third_party.lib.libmodbus    include iocontrol.modbus.cmd.modbus_server    include iocontrol.modbus.cmd.led_driver    include embox.service.cgi_cmd_wrapper(cmds_check=true, allowed_cmds="led_driver led_names flash_settings")    include iocontrol.modbus.lib.libleddrv(leds_quantity=4)    include iocontrol.modbus.lib.libleddrv_ll_stm32_f4_demo

Выводы

Сборка

Первый запуск на плате

Запускаем на Линукс

./qvfb -width 480 -height 272 -nocursor

./configure -opensource -confirm-license -debug \    -embedded -qt-gfx-qvfb -qvfb \    -no-javascript-jit -no-script -no-scripttools \    -no-qt3support -no-webkit -nomake demos -nomake examples

./examples/animation/animatedtiles/animatedtiles -qws -display QVFb:0

Запуск на Embox

$ valgrind --tool=massif --massif-out-file=animatedtiles.massif ./examples/animation/animatedtiles/animatedtiles -qws -fullscreen$ ms_print animatedtiles.massif > animatedtiles.out

Запуск на STM32F769I-Discovery.

$ ./qvfb -width 800 -height 480 -nocursor &$ valgrind --tool=massif --massif-out-file=animatedtiles.massif ./examples/animation/animatedtiles/animatedtiles -qws -fullscreen$ ms_print animatedtiles.massif > animatedtiles.out

Базовый синтаксис

Глобальные конструкторы и деструкторы

void cxx_invoke_constructors(void) {    extern const char _ctors_start, _ctors_end;    typedef void (*ctor_func_t)(void);    ctor_func_t *func = (ctor_func_t *) &_ctors_start;    ....    for ( ; func != (ctor_func_t *) &_ctors_end; func++) {        (*func)();    }}

int __cxa_atexit(void (*f)(void *), void *objptr, void *dso) {    if (atexit_func_count >= TABLE_SIZE) {        printf("__cxa_atexit: static destruction table overflow.\n");        return -1;    }    atexit_funcs[atexit_func_count].destructor_func = f;    atexit_funcs[atexit_func_count].obj_ptr = objptr;    atexit_funcs[atexit_func_count].dso_handle = dso;    atexit_func_count++;    return 0;};void __cxa_finalize(void *f) {    int i = atexit_func_count;    if (!f) {        while (i--) {            if (atexit_funcs[i].destructor_func) {                (*atexit_funcs[i].destructor_func)(atexit_funcs[i].obj_ptr);                atexit_funcs[i].destructor_func = 0;            }        }        atexit_func_count = 0;    } else {        for ( ; i >= 0; --i) {            if (atexit_funcs[i].destructor_func == f) {                (*atexit_funcs[i].destructor_func)(atexit_funcs[i].obj_ptr);                atexit_funcs[i].destructor_func = 0;            }        }    }}void cxx_invoke_destructors(void) {    extern const char _dtors_start, _dtors_end;    typedef void (*dtor_func_t)(void);    dtor_func_t *func = ((dtor_func_t *) &_dtors_end) - 1;    /* There are two possible ways for destructors to be calls:     * 1. Through callbacks registered with __cxa_atexit.     * 2. From .fini_array section.  */    /* Handle callbacks registered with __cxa_atexit first, if any.*/    __cxa_finalize(0);    /* Handle .fini_array, if any. Functions are executed in teh reverse order. */    for ( ; func >= (dtor_func_t *) &_dtors_start; func--) {        (*func)();    }}

/** * @brief Register destructor for a global object * * @param destructor the global object destructor function * @param objptr global object pointer * @param dso Dynamic Shared Object handle for shared libraries * * Function does nothing at the moment, assuming the global objects * do not need to be deleted * * @return N/A */int __cxa_atexit(void (*destructor)(void *), void *objptr, void *dso){    ARG_UNUSED(destructor);    ARG_UNUSED(objptr);    ARG_UNUSED(dso);    return 0;}

Операторы new/delete

void* operator new(std::size_t size)  throw() {    void *ptr = NULL;    if ((ptr = std::malloc(size)) == 0) {        if (alloc_failure_handler) {            alloc_failure_handler();        }    }    return ptr;}void operator delete(void* ptr) throw() {    std::free(ptr);}

RTTI & exceptions

void register_eh_frame(void) {    extern const char _eh_frame_begin;    __register_frame((void *)&_eh_frame_begin);}

    .ARM.exidx : {        __exidx_start = .;        KEEP(*(.ARM.exidx*));        __exidx_end = .;    } SECTION_REGION(text)    .ARM.extab : {        KEEP(*(.ARM.extab*));    } SECTION_REGION(text)

extern __EIT_entry __exidx_start;extern __EIT_entry __exidx_end;

Стандартная библиотека языка (libstdc++)

Собственная реализация стандартной библиотеки

Стандартная библиотека из кросс-компилятора

$ arm-none-eabi-gcc -vUsing built-in specs.COLLECT_GCC=arm-none-eabi-gccCOLLECT_LTO_WRAPPER=/home/alexander/apt/gcc-arm-none-eabi-9-2020-q2-update/bin/../lib/gcc/arm-none-eabi/9.3.1/lto-wrapperTarget: arm-none-eabiConfigured with: ***     --with-gnu-as --with-gnu-ld --with-newlib   ***Thread model: singlegcc version 9.3.1 20200408 (release) (GNU Arm Embedded Toolchain 9-2020-q2-update)

struct _reent {    int _errno;           /* local copy of errno */  /* FILE is a big struct and may change over time.  To try to achieve binary     compatibility with future versions, put stdin,stdout,stderr here.     These are pointers into member __sf defined below.  */    FILE *_stdin, *_stdout, *_stderr;};struct _reent global_newlib_reent;void *_impure_ptr = &global_newlib_reent;static int reent_init(void) {    global_newlib_reent._stdin = stdin;    global_newlib_reent._stdout = stdout;    global_newlib_reent._stderr = stderr;    return 0;}

Расширенная поддержка стандартной библиотеки std::thread и std::mutex

$ arm-none-eabi-gcc -v***Thread model: singlegcc version 9.3.1 20200408 (release) (GNU Arm Embedded Toolchain 9-2020-q2-update)

Конфигурация Embox

• embox.lib.libsupcxx определяет какой метод для поддержки базового синтаксиса языка нужно использовать.
• embox.lib.libstdcxx определяет какую реализацию стандартной библиотеки нужно использовать

• embox.lib.cxx.libsupcxx_standalone базовая реализация в составе Embox.
• third_party.lib.libsupcxx_toolchain использовать библиотеку поддержки языка из кросс-компилятора
• third_party.gcc.tlibsupcxx полная сборка библиотеки из исходников

• third_party.STLport.libstlportg стандартная библиотека вслкючающая STL на основе проекта STLport. Не требует пересборки gcc. Но проект давно не поддерживается
• third_party.lib.libstdcxx_toolchain стандартная библиотека из кросс-компилятора
• third_party.gcc.libstdcxx полная сборка библиотеки из исходников

Первые оптимизации. Экономия памяти

Промежуточный буфер. Компиляторные оптимизации. FPU

        if (nk_begin(&rawfb->ctx, "Demo", nk_rect(50, 50, 200, 200),            NK_WINDOW_BORDER|NK_WINDOW_MOVABLE|            NK_WINDOW_CLOSABLE|NK_WINDOW_MINIMIZABLE|NK_WINDOW_TITLE)) {            enum {EASY, HARD};            static int op = EASY;            static int property = 20;            static float value = 0.6f;            if (mouse->type == INPUT_DEV_TOUCHSCREEN) {                /* Do not show cursor when using touchscreen */                nk_style_hide_cursor(&rawfb->ctx);            }            nk_layout_row_static(&rawfb->ctx, 30, 80, 1);            if (nk_button_label(&rawfb->ctx, "button"))                fprintf(stdout, "button pressed\n");            nk_layout_row_dynamic(&rawfb->ctx, 30, 2);            if (nk_option_label(&rawfb->ctx, "easy", op == EASY)) op = EASY;            if (nk_option_label(&rawfb->ctx, "hard", op == HARD)) op = HARD;            nk_layout_row_dynamic(&rawfb->ctx, 25, 1);            nk_property_int(&rawfb->ctx, "Compression:", 0, &property, 100, 10, 1);            nk_layout_row_begin(&rawfb->ctx, NK_STATIC, 30, 2);            {                nk_layout_row_push(&rawfb->ctx, 50);                nk_label(&rawfb->ctx, "Volume:", NK_TEXT_LEFT);                nk_layout_row_push(&rawfb->ctx, 110);                nk_slider_float(&rawfb->ctx, 0, &value, 1.0f, 0.1f);            }            nk_layout_row_end(&rawfb->ctx);        }        nk_end(&rawfb->ctx);        if (nk_window_is_closed(&rawfb->ctx, "Demo")) break;        /* Draw framebuffer */        nk_rawfb_render(rawfb, nk_rgb(30,30,30), 1);        memcpy(fb_info->screen_base, fb_buf, width * height * bpp);

Включение кэшей процессора. Режим Write-Through

Двойная буферизация (пока с промежуточным буфером). Включение DMA

            while (dma_in_progress()) {            }            ret = dma_transfer((uint32_t) fb_info->screen_base,                    (uint32_t) fb_buf[fb_buf_idx], (width * height * bpp) / 4);            if (ret < 0) {                printf("DMA transfer failed\n");            }            fb_buf_idx = (fb_buf_idx + 1) % 2;

Двойная буферизация. Работа с LTDC

        BSP_LCD_SetTransparency_NoReload(fb_buf_idx, 0xff);        fb_buf_idx = (fb_buf_idx + 1) % 2;        BSP_LCD_SetTransparency(fb_buf_idx, 0x00);

Аппаратная заливка сцены через DMA2D

nk_rawfb_render(rawfb, nk_rgb(30,30,30), 1);

nk_rawfb_render(rawfb, nk_rgb(30,30,30), 0);

Vertical Blanking Period (VBLANK)

          LCD_CLK (MHz) = total_screen_size * refresh_rate,

Немного об input устройствах в нашем примере

        /* Input */        nk_input_begin(&rawfb->ctx);        {            switch (mouse->type) {            case INPUT_DEV_MOUSE:                handle_mouse(mouse, fb_info, rawfb);                break;            case INPUT_DEV_TOUCHSCREEN:                handle_touchscreen(mouse, fb_info, rawfb);                break;            default:                /* Unreachable */                break;            }        }        nk_input_end(&rawfb->ctx);

static void handle_touchscreen(struct input_dev *ts, struct fb_info *fb_info,        struct rawfb_context *rawfb) {    struct input_event ev;    int type;    static int x = 0, y = 0;    while (0 <= input_dev_event(ts, &ev)) {        type = ev.type & ~TS_EVENT_NEXT;        switch (type) {        case TS_TOUCH_1:            x = normalize_coord((ev.value >> 16) & 0xffff, 0, fb_info->var.xres);            y = normalize_coord(ev.value & 0xffff, 0, fb_info->var.yres);            nk_input_button(&rawfb->ctx, NK_BUTTON_LEFT, x, y, 1);            nk_input_motion(&rawfb->ctx, x, y);            break;        case TS_TOUCH_1_RELEASED:            nk_input_button(&rawfb->ctx, NK_BUTTON_LEFT, x, y, 0);            break;        default:            break;        }    }}

Запускаем на другой плате

Итоги

• Write-back. Данные по записи подают только в кэш. Реальная запись в память откладывается до тех пор пока кэш не переполнится и не потребуется место для новых данных.
• Write-through. Запись происходит одновременно и в кэш и в память.

Write-through

Write-through: triggers a write to the memory as soon as the contents on the cache line are written to. This is safer for the data coherency, but it requires more bus accesses. In practice, the write to the memory is done in the background and has a little effect unless the same cache set is being accessed repeatedly and very quickly. It is always a tradeoff.

• При последовательном и быстром доступе в одну и ту же память производительность может снижаться. В режиме write-back последовательные частые доступы к одной памяти будут, наоборот, являться плюсом.
• Как и в случае с write-back все равно нужно делать cache invalidate после окончания DMA операций.
• Баг Data corruption in a sequence of Write-Through stores and loads в некоторых версиях Cortex-M7. Нам указал на него один из разработчиков LVGL.

Write-back

Write Allocate

MPU

The base address, size and attributes of a region are all configurable, with the general rule that all regions are naturally aligned. This can be stated as:
RegionBaseAddress[(N-1):0] = 0, where N is log2(SizeofRegion_in_bytes)

  MPU_InitStruct.BaseAddress = 0x20010000;  MPU_InitStruct.Size = MPU_REGION_SIZE_256KB;

TCM

Instruction cache

Синтетические тесты

Non-cacheable memory VS. write-back

    dst = (uint8_t *) DATA_ADDR;    for (i = 0; i < ITERS * 8; i++) {        for (j = 0; j < DATA_LEN; j++) {            *dst = VALUE;            dst++;        }        dst -= DATA_LEN;    }

    for (i = 0; i < ITERS * BLOCKS * 8; i++) {        for (j = 0; j < BLOCK_LEN; j++) {            *dst = VALUE;            *dst = VALUE;            *dst = VALUE;            *dst = VALUE;            dst++;        }        dst -= BLOCK_LEN;    }

    for (i = 0; i < ITERS * BLOCKS * 8; i++) {        dst = (uint8_t *) DATA_ADDR;        for (j = 0; j < BLOCK_LEN; j++) {            val = VALUE;            *dst = val;            val = *dst;            dst++;        }    }

    for (i = 0; i < ITERS * BLOCKS; i++) {        for (j = 0; j < BLOCK_LEN; j++) {            // 16 lines            arr[i]++;            arr[i]++;***            arr[i]++;        }    }

    for (i = 0; i < ITERS * BLOCKS; i++) {        for (j = 0; j < BLOCK_LEN; j++) {            arr[i + 0 ]++;            ***            arr[i + 3 ]++;            arr[i + 4 ]++;            arr[i + 100]++;            arr[i + 6 ]++;            arr[i + 7 ]++;            ***            arr[i + 15]++;        }    }

    for (i = 0; i < ITERS * BLOCKS; i++) {        for (j = 0; j < BLOCK_LEN; j++) {            arr[i + 0 ]++;            ***            arr[i + 4 ]++;            arr[i + 100]++;            arr[i + 6 ]++;            ***            arr[i + 9 ]++;            arr[i + 200]++;            arr[i + 11]++;            arr[i + 12]++;            ***            arr[i + 15]++;        }    }

Write allocate VS. no write allocate

    for (i = 0; i < ITERS * BLOCKS; i++) {        for (j = 0; j < BLOCK_LEN; j++) {            arr[j + 0 ]  = VALUE;            ***            arr[j + 7 ]  = VALUE;            arr[j + 8 ]  = arr[i % 1024 + (j % 256) * 128];            arr[j + 9 ]  = VALUE;            ***            arr[j + 15 ]  = VALUE;        }    }

    arr = (uint8_t *) DATA_ADDR;    arr2 = arr;    for (i = 0; i < ITERS * BLOCKS; i++) {        for (j = 0; j < BLOCK_LEN; j++) {            arr2[i * BLOCK_LEN            ] = arr[j + 0 ];            arr2[i * BLOCK_LEN + j*32 + 1 ] = arr[j + 1 ];            arr2[i * BLOCK_LEN + j*64 + 2 ] = arr[j + 2 ];            arr2[i * BLOCK_LEN + j*128 + 3] = arr[j + 3 ];            arr2[i * BLOCK_LEN + j*32 + 4 ] = arr[j + 4 ];            ***            arr2[i * BLOCK_LEN + j*32 + 15] = arr[j + 15 ];        }    }

Практические примеры

ping

OpenCV

   gettimeofday(&tv_start, NULL);    cedge.create(image.size(), image.type());    cvtColor(image, gray, COLOR_BGR2GRAY);    blur(gray, edge, Size(3,3));    Canny(edge, edge, edgeThresh, edgeThresh*3, 3);    cedge = Scalar::all(0);    image.copyTo(cedge, edge);    gettimeofday(&tv_cur, NULL);    timersub(&tv_cur, &tv_start, &tv_cur);

Не кэшируемая или кэшируемая память, но с cache invalidate

Заключение

PKG_NAME := Gecko_SDKPKG_VER := v5.1.2PKG_ARCHIVE_NAME := $(PKG_NAME)-$(PKG_VER).tar.gzPKG_SOURCES := https://github.com/SiliconLabs/$(PKG_NAME)/archive/v5.1.2.tar.gzPKG_MD5     := 0de78b48a8da80931af1a53d401e74f5include $(EXTBLD_LIB)

package platform.efm32...@BuildArtifactPath(cppflags="-I$(EXTERNAL_BUILD_DIR)/platform/efm32/bsp_get/Gecko_SDK-5.1.2/hardware/kit/common/bsp/")module bsp_get { }@BuildDepends(bsp_get)@BuildDepends(efm32_conf)static module bsp extends embox.arch.arm.cmsis {    source "platform/emlib/src/em_timer.c",        "platform/emlib/src/em_adc.c",    depends bsp_get    depends efm32_conf}

package platform.efm32.efm32zg_stk3200@BuildArtifactPath(cppflags="-I$(EXTERNAL_BUILD_DIR)/platform/efm32/bsp_get/Gecko_SDK-5.1.2/platform/Device/SiliconLabs/EFM32ZG/Include")@BuildArtifactPath(cppflags="-I$(EXTERNAL_BUILD_DIR)/platform/efm32/bsp_get/Gecko_SDK-5.1.2/hardware/kit/EFM32ZG_STK3200/config")...@BuildArtifactPath(cppflags="-D__CORTEX_SC=0")@BuildArtifactPath(cppflags="-DUART_COUNT=0")@BuildArtifactPath(cppflags="-DEFM32ZG222F32=1")module efm32zg_stk3200_conf extends platform.efm32.efm32_conf {    source "efm32_conf.h"}@BuildDepends(platform.efm32.bsp)@BuildDepends(efm32zg_stk3200_conf)static module bsp extends platform.efm32.efm32_bsp {    @DefineMacro("DOXY_DOC_ONLY=0")    @AddPrefix("^BUILD/extbld/platform/efm32/bsp_get/Gecko_SDK-5.1.2/")    source        "platform/Device/SiliconLabs/EFM32ZG/Source/system_efm32zg.c",        "hardware/kit/common/drivers/displayls013b7dh03.c",...}

sudo openocd -f /usr/share/openocd/scripts/board/efm32.cfg

     @Runlevel(0) include embox.arch.generic.arch    include embox.arch.arm.libarch    @Runlevel(0) include embox.arch.arm.armmlib.locore    @Runlevel(0) include embox.arch.system(core_freq=8000000)    @Runlevel(0) include embox.arch.arm.armmlib.exception_entry(irq_stack_size=256)    @Runlevel(0) include embox.kernel.stack(stack_size=1024,alignment=4)    @Runlevel(0) include embox.arch.arm.fpu.fpu_stub

/* region (origin, length) */ROM (0x00000000, 32K)RAM (0x20000000, 4K)/* section (region[, lma_region]) */text   (ROM)rodata (ROM)data   (RAM, ROM)bss    (RAM)

static int efm32_uart_putc(struct uart *dev, int ch) {    LEUART_Tx((void *) dev->base_addr, ch);    return 0;}static int efm32_uart_hasrx(struct uart *dev) {...}static int efm32_uart_getc(struct uart *dev) {    return LEUART_Rx((void *) dev->base_addr);}static int efm32_uart_setup(struct uart *dev, const struct uart_params *params) {    LEUART_TypeDef      *leuart = (void *) dev->base_addr;    LEUART_Init_TypeDef init    = LEUART_INIT_DEFAULT;    /* Enable CORE LE clock in order to access LE modules */    CMU_ClockEnable(cmuClock_HFPER, true);  ...    /* Finally enable it */    LEUART_Enable(leuart, leuartEnable);    return 0;}...DIAG_SERIAL_DEF(&efm32_uart0, &uart_defparams);

package embox.driver.serial@BuildDepends(platform.efm32.efm32_bsp)module efm32_leuart extends embox.driver.diag.diag_api {    option number baud_rate    source "efm32_leuart.c"    @NoRuntime depends platform.efm32.efm32_bsp    depends core    depends diag}

    include embox.cmd.help    include embox.cmd.sys.version    include embox.lib.Tokenizer    include embox.init.setup_tty_diag    @Runlevel(2) include embox.cmd.shell    @Runlevel(3) include embox.init.start_script(shell_name="diag_shell")

    @Runlevel(1) include embox.driver.serial.efm32_leuart    @Runlevel(1) include embox.driver.diag(impl="embox__driver__serial__efm32_leuart")    include embox.driver.serial.core_notty

package embox.driver.gpio@BuildDepends(platform.efm32.efm32_bsp)module efm32_gpio extends api {    option number log_level = 0    option number gpio_chip_id = 0    option number gpio_ports_number = 2    source "efm32_gpio.c"    depends embox.driver.gpio.core    @NoRuntime depends platform.efm32.efm32_bsp}

static int efm32_gpio_setup_mode(unsigned char port, gpio_mask_t pins, int mode) {...}static void efm32_gpio_set(unsigned char port, gpio_mask_t pins, char level) {    if (level) {        GPIO_PortOutSet(port, pins);    } else {        GPIO_PortOutClear(port, pins);    }}static gpio_mask_t efm32_gpio_get(unsigned char port, gpio_mask_t pins) {    return GPIO_PortOutGet(port) & pins;}...static int efm32_gpio_init(void) {#if (_SILICON_LABS_32B_SERIES < 2)  CMU_ClockEnable(cmuClock_HFPER, true);#endif#if (_SILICON_LABS_32B_SERIES < 2) \  || defined(_SILICON_LABS_32B_SERIES_2_CONFIG_2)  CMU_ClockEnable(cmuClock_GPIO, true);#endif    return gpio_register_chip((struct gpio_chip *)&efm32_gpio_chip, EFM32_GPIO_CHIP_ID);}

include embox.cmd.hardware.pin

"pin GPIOC 11 blink",

package embox.driver.video@BuildDepends(platform.efm32.efm32_bsp)module efm32_lcd {...    source "efm32_lcd.c"    @NoRuntime depends platform.efm32.efm32_bsp}

    //@Runlevel(2) include embox.cmd.shell    //@Runlevel(3) include embox.init.start_script(shell_name="diag_shell")    @Runlevel(3) include embox.init.system_start_service(cmd_max_len=32, cmd_max_argv=6)

    include embox.driver.common(device_name_len=1, max_dev_module_count=0)    include embox.compat.libc.stdio.file_pool(file_quantity=0)    include embox.kernel.task.resource.idesc_table(idesc_table_size=3)    include embox.kernel.task.task_no_table    @Runlevel(1) include embox.kernel.timer.sys_timer(timer_quantity=1)...    @Runlevel(1) include embox.kernel.timer.itimer(itimer_quantity=0)

    @Runlevel(0) include embox.arch.arm.armmlib.exception_entry(irq_stack_size=224)    @Runlevel(0) include embox.kernel.stack(stack_size=448,alignment=4)

extern const uint8_t demo_image_mono_128x128[128][16];static int efm_lcd_init(void) {    DISPLAY_Device_t      displayDevice;    EMSTATUS status;    DISPLAY_PixelMatrix_t pixelMatrixBuffer;    /* Initialize the DISPLAY module. */    status = DISPLAY_Init();    if (DISPLAY_EMSTATUS_OK != status) {        return status;    }    /* Retrieve the properties of the DISPLAY. */    status = DISPLAY_DeviceGet(DISPLAY_DEVICE_NO, &displayDevice);    if (DISPLAY_EMSTATUS_OK != status) {        return status;    }    /* Allocate a framebuffer from the DISPLAY device driver. */    displayDevice.pPixelMatrixAllocate(&displayDevice,            displayDevice.geometry.width,            displayDevice.geometry.height,            &pixelMatrixBuffer);#if START_WITH_LOGO    memcpy(pixelMatrixBuffer, demo_image_mono_128x128,            displayDevice.geometry.width * displayDevice.geometry.height / 8 );    status = displayDevice.pPixelMatrixDraw(&displayDevice,            pixelMatrixBuffer,            0,            displayDevice.geometry.width,            0,            displayDevice.geometry.height);#endif    return 0;}