#include <stdio.h>

#include <ctype.h>

#include <string.h>

#include "main.h"

#include "driver.h"

#include "vfs.h"

#include "filesystem.h"

#include "sfs.h"

#include "rfs.h"

#include "w25.h"

#include "uartterm.h"

#include "calls.h"

#define PRESCALER 72

#define TIMPERIOD 0xffff

#define TICKSPERSEC (72000000 / PRESCALER)

#define ITDUR 10

#define OUTPUTPINSA (GPIO_PIN_4)

#define OUTPUTPINSB (GPIO_PIN_3)

SPI_HandleTypeDef hspi1;

TIM_HandleTypeDef htim1;

TIM_HandleTypeDef htim2;

UART_HandleTypeDef huart1;

struct driver drivers[8];

struct bdevice dev[8];

struct filesystem fs[8];

struct bdevice *curdev;

// for heap test

void *_sbrk(ptrdiff_t incr);

void systemclock_config(void);

static void gpio_init(void);

static void spi1_init(void);

static void tim1_init(void);

static void tim2_init(void);

static void usart1_init(void);

static void flash_init(void);

static void rfs_init(void);

void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)

{

}

int printhelp()

{

ut_write("\r\ndriver commands:\n\r");

ut_write("\t%-23s%-32s\n\r",

"sd [dev]", "set current device to [dev]");

ut_write("\t%-23s%-32s\n\r",

"rd [addr]", "read data at address [addr]");

ut_write("\t%-23s%-32s\n\r",

"wd [addr] [str]","write string [str] into [addr]");

ut_write("\r\nfilesystem commands:\n\r");

ut_write("\t%-23s%-32s\n\r",

"f", "format choosen device");

ut_write("\t%-23s%-32s\n\r",

"i [struct] {[addr]}",

"dump filesystem [struct] (sb, in, bm) at [addr]");

ut_write("\t%-23s%-32s\n\r",

"c [sz]","create inode for data size of [size]");

ut_write("\t%-23s%-32s\n\r",

"d [addr]","delete inode with address [addr]");

ut_write("\t%-23s%-32s\n\r",

"s [addr] [data]",

"set data for inode with address [addr] to [data]");

ut_write("\t%-23s%-32s\n\r",

"g [addr]",

"get data from inode with address [addr]");

ut_write("\t%-23s%-32s\n\r",

"r [addr] [off] [sz]",

"read [sz] bytes from inode with address `[addr]` with offset of [off] bytes");

ut_write("\t%-23s%-32s\n\r",

"w [addr] [off] [data]",

"write data into inode with address `[addr]` with offset of [off] bytes");

ut_write("\r\nvirtual filesystem commands:\n\r");

ut_write("\t%-23s%-32s\n\r",

"mount [dev] [target]",

"mount [dev] to [target]");

ut_write("\t%-23s%-32s\n\r",

"format [target]",

"format device mounted at [target]");

ut_write("\t%-23s%-32s\n\r",

"umount [dev] [target]",

"unmount [target]");

ut_write("\t%-23s%-32s\n\r",

"mountlist",

"get list of mounted devices");

ut_write("\t%-23s%-32s\n\r",

"open [path] [flags]",

"open file with [path], if [flags] is 'c', create it");

ut_write("\t%-23s%-32s\n\r",

"read [fd] [sz]",

"read [sz] bytes from opened file with descriptor [fd]");

ut_write("\t%-23s%-32s\n\r",

"write [fd] [data]",

"write [data] into opened file with descriptor [fd]");

ut_write("\t%-23s%-32s\n\r",

"close [fd]",

"close opened file with descriptor [fd]");

ut_write("\t%-23s%-32s\n\r",

"mkdir [path]",

"create directory [path]");

ut_write("\t%-23s%-32s\n\r",

"rm [path]",

"delete file or directory [path]");

ut_write("\t%-23s%-32s\n\r",

"ls [path]",

"get list of file in directory [path]");

ut_write("\t%-23s%-32s\n\r",

"cd [path]",

"change current working directory to [path]");

ut_write("\n\r");

return 0;

}

int setdevice(const char **toks)

{

if (strcmp(toks[1], dev[0].name) == 0)

curdev = dev + 0;

else if (strcmp(toks[1], dev[1].name) == 0)

curdev = dev + 1;

else {

ut_write("unknown device %s\n\r", toks[1]);

return 0;

}

ut_write("device %s was set\n\r", toks[1]);

return 0;

}

int devformat(const char **toks)

{

size_t r;

if (fs_iserror(r = fs[0].format(curdev))) {

ut_write("error: %s\n\r",

vfs_strerror(fs_uint2interr(r)));

return 0;

}

return 0;

}

int readdata(const char **toks)

{

char rdata[256];

size_t addr, r;

sscanf(toks[1], "%x", &addr);

memset(rdata, 0, 256);

r = curdev->read(curdev->priv, addr, rdata, 256);

if (fs_iserror(r)) {

ut_write("error: %s\n\r",

vfs_strerror(fs_uint2interr(r)));

return 0;

}

ut_dumppage(rdata, 256);

return 0;

}

int writedata(const char **toks)

{

size_t addr, r;

sscanf(toks[1], "%x", &addr);

if (fs_iserror(r = curdev->erasesector(curdev->priv, addr))) {

ut_write("error: %s\n\r",

vfs_strerror(fs_uint2interr(r)));

return 0;

}

r = curdev->write(curdev->priv, addr, toks[2],

strlen(toks[2]) + 1);

if (fs_iserror(r)) {

ut_write("error: %s\n\r",

vfs_strerror(fs_uint2interr(r)));

return 0;

}

return 0;

}

int mntdevformat(const char **toks)

{

int r;

if ((r = format(toks[1])) < 0) {

ut_write("error: %s\n\r", vfs_strerror(r));

return 0;

}

return 0;

}

int createinode(const char **toks)

{

size_t addr, r;

sscanf(toks[1], "%d", &addr);

if (fs_iserror(r = fs[0].inodecreate(curdev, addr, FS_FILE))) {

ut_write("error: %s\n\r",

vfs_strerror(fs_uint2interr(r)));

return 0;

}

ut_write("new inode address: %x\n\r", r);

return 0;

}

int deleteinode(const char **toks)

{

size_t addr, r;

sscanf(toks[1], "%x", &addr);

if (fs_iserror(r = fs[0].inodedelete(curdev, addr))) {

ut_write("error: %s\n\r",

vfs_strerror(fs_uint2interr(r)));

return 0;

}

return 0;

}

int setinode(const char **toks)

{

size_t addr, r;

sscanf(toks[1], "%x", &addr);

r = fs[0].inodeset(curdev, addr, toks[2], strlen(toks[2]) + 1);

if (fs_iserror(r)) {

ut_write("error: %s\n\r",

vfs_strerror(fs_uint2interr(r)));

return 0;

}

return 0;

}

int getinode(const char **toks)

{

size_t addr;

uint8_t buf[256];

size_t r;

sscanf(toks[1], "%x", &addr);

if (fs_iserror(r = fs[0].inodeget(curdev, addr, buf, 256))) {

ut_write("error: %s\n\r",

vfs_strerror(fs_uint2interr(r)));

return 0;

}

buf[r] = '\0';

ut_write("%s\n\r", buf);

return 0;

}

int readinode(const char **toks)

{

size_t addr, offset, size;

uint8_t buf[256];

size_t r;

sscanf(toks[1], "%x", &addr);

sscanf(toks[2], "%d", &offset);

sscanf(toks[3], "%d", &size);

memset(buf, 0, 256);

r = fs[0].inoderead(curdev, addr, offset, buf, size);

if (fs_iserror(r)) {

ut_write("error: %s\n\r",

vfs_strerror(fs_uint2interr(r)));

return 0;

}

ut_write("%s\n\r", buf);

return 0;

}

int writeinode(const char **toks)

{

size_t addr, offset, r;

sscanf(toks[1], "%x", &addr);

sscanf(toks[2], "%d", &offset);

r = fs[0].inodewrite(curdev, addr, offset,

toks[3], strlen(toks[3]));

if (fs_iserror(r)) {

ut_write("error: %s\n\r",

vfs_strerror(fs_uint2interr(r)));

}

return 0;

}

int createbiginode(const char **toks)

{

size_t addr, insz, i;

char buf[5000];

insz = 5000;

ut_write("new inode address: %x\n\r",

(addr = fs[0].inodecreate(curdev, 32, FS_FILE)));

for (i = 0; i < insz; ++i)

buf[i] = (i % ('z' - 'a')) + 'a';

ut_write("set data: %d\n\r",

fs[0].inodeset(curdev, addr, buf, insz));

return 0;

}

int dumpsb()

{

struct sfs_superblock sb;

int i;

fs[0].dumpsuperblock(curdev, &sb);

ut_write("checksum: %lx\r\n", sb.checksum);

ut_write("inode count: %lx\r\n", sb.inodecnt);

ut_write("inode size: %lu\r\n", sb.inodesz);

ut_write("inodes start: %lx\r\n", sb.inodestart);

ut_write("free inode: %lx\r\n", sb.freeinodes);

ut_write("blocks start: %lx\r\n", sb.blockstart);

ut_write("free block: %lx\r\n", sb.freeblocks);

ut_write("inodes checksums: ");

for (i = 0; i < SFS_INODESECTORSCOUNT + 1; ++i) {

ut_write("%lx%s", sb.inodechecksum[i],

((i != SFS_INODESECTORSCOUNT) ? ", " : ""));

}

ut_write("\r\n");

return 0;

}

int dumpin(const char *arg)

{

size_t addr;

struct sfs_inode in;

sscanf(arg, "%x", &addr);

fs[0].dumpinode(curdev, addr, &in);

ut_write("checksum: %lx\r\n", in.checksum);

ut_write("next free: %lx\r\n", in.nextfree);

ut_write("size: %lu\r\n", in.size);

ut_write("allocsize: %lu\r\n", in.allocsize);

ut_write("type: %lx\r\n", in.type);

ut_write("block[0]: %x\r\n", in.blocks.block[0]);

ut_write("block[1]: %x\r\n", in.blocks.block[1]);

ut_write("indirect block: %x\r\n", in.blocks.blockindirect);

return 0;

}

int dumpb(const char *arg)

{

size_t addr;

struct sfs_blockmeta meta;

sscanf(arg, "%x", &addr);

fs[0].dumpblockmeta(curdev, addr, &meta);

ut_write("checksum: %lx\r\n", meta.checksum);

ut_write("next: %lx\r\n", meta.next);

ut_write("datasize: %lu\r\n", meta.datasize);

return 0;

}

int dump(const char **toks)

{

if (strcmp(toks[1], "sb") == 0)

return dumpsb();

if (strcmp(toks[1], "in") == 0)

return dumpin(toks[2]);

if (strcmp(toks[1], "bm") == 0)

return dumpb(toks[2]);

else {

ut_write("Unknown structure\n\r");

return 0;

}

return 0;

}

int mounthandler(const char **toks)

{

struct bdevice *d;

int r;

if (strcmp(toks[1], dev[0].name) == 0)

d = dev + 0;

else if (strcmp(toks[1], dev[1].name) == 0)

d = dev + 1;

else {

ut_write("unknown device %s\n\r", toks[1]);

return 0;

}

if ((r = mount(d, toks[2], fs + 0)) < 0) {

ut_write("mount: %s\n\r", vfs_strerror(r));

return 0;

}

return 0;

}

int umounthandler(const char **toks)

{

int r;

if ((r = umount(toks[1])) < 0) {

ut_write("error: %s\n\r", vfs_strerror(r));

return 0;

}

return 0;

}

int mountlisthandler(const char **toks)

{

char buf[256];

const char *list[MOUNTMAX];

const char **p;

int r;

if ((r = mountlist(list, buf, 2048)) < 0) {

ut_write("error: %s\n\r", vfs_strerror(r));

return 0;

}

for (p = list; *p != NULL; ++p)

ut_write("%s\n\r", *p);

return 0;

}

int openfile(const char **toks)

{

int fd;

fd = open(toks[1], (strcmp(toks[2], "c") == 0) ? O_CREAT : 0);

if (fd < 0) {

ut_write("error: %s\n\r", vfs_strerror(fd));

return 0;

}

ut_write("fd: %d\n\r", fd);

return 0;

}

int readfile(const char **toks)

{

uint8_t buf[256];

size_t sz;

int fd, r;

sscanf(toks[1], "%d", &fd);

sscanf(toks[2], "%d", &sz);

if ((r = read(fd, buf, sz)) < 0) {

ut_write("error: %s\n\r", vfs_strerror(r));

return 0;

}

buf[r] = '\0';

ut_write("%s\n\r", (char *) buf);

return 0;

}

int writefile(const char **toks)

{

int fd, r;

sscanf(toks[1], "%d", &fd);

if ((r = write(fd, toks[2], strlen(toks[2]))) < 0) {

ut_write("error: %s\n\r", vfs_strerror(r));

return 0;

}

return 0;

}

int closefile(const char **toks)

{

int fd, r;

sscanf(toks[1], "%d", &fd);

if ((r = close(fd)) < 0) {

ut_write("error %d: %s\n\r", fd, vfs_strerror(r));

return 0;

}

return 0;

}

int makedir(const char **toks)

{

int r;

if ((r = mkdir(toks[1])) < 0) {

ut_write("error: %s\n\r", vfs_strerror(r));

return 0;

}

return 0;

}

int makedev(const char **toks)

{

int r;

size_t driverid, deviceid;

sscanf(toks[2], "%d", &driverid);

sscanf(toks[3], "%d", &deviceid);

if ((r = mkdev(toks[1], driverid, deviceid)) < 0) {

ut_write("error: %s\n\r", vfs_strerror(r));

return 0;

}

return 0;

}

int unlinkfile(const char **toks)

{

int r;

if ((r = unlink(toks[1])) < 0) {

ut_write("unlink: %s\n\r", vfs_strerror(r));

return 0;

}

return 0;

}

int listvfsdir(const char **toks)

{

char buf[256];

char *list[16];

char **p;

int r;

if ((r = lsdir(toks[1], (const char **) list, buf, 256)) < 0) {

ut_write("error: %s\n\r", vfs_strerror(r));

return 0;

}

for (p = list; *p != NULL; ++p)

ut_write("%s\n\r", *p);

return 0;

}

int vfscd(const char **toks)

{

int r;

if ((r = cd(toks[1])) < 0) {

ut_write("error: %s\n\r", vfs_strerror(r));

return 0;

}

return 0;

}

int heaptest(const char **toks)

{

char *p[256];

int i;

ut_write("initial break: %p\n\r", _sbrk(0));

for (i = 0; i < 128; ++i)

p[i] = malloc(32);

for (i = 0; i < 4; ++i)

p[128 + i] = malloc(1024);

for (i = 0; i < 132; ++i) {

ut_write("%p ", p[i] - 12);

if (((i + 1) % 8) == 0)

ut_write("\n\r");

}

ut_write("\n\r");

ut_write("current break: %p\n\r", _sbrk(0));

for (i = 0; i < 132; ++i)

free(p[i]);

ut_write("current break (after free): %p\n\r", _sbrk(0));

for (i = 0; i < 128; ++i)

p[i] = malloc(32);

for (i = 0; i < 4; ++i)

p[128 + i] = malloc(1024);

for (i = 0; i < 132; ++i) {

ut_write("%p ", p[i] - 12);

if (((i + 1) % 8) == 0)

ut_write("\n\r");

}

ut_write("\n\r");

ut_write("current break: %p\n\r", _sbrk(0));

for (i = 0; i < 132; ++i)

free(p[i]);

ut_write("current break (after free): %p\n\r", _sbrk(0));

return 0;

}

int main(void)

{

HAL_Init();

systemclock_config();

gpio_init();

tim1_init();

tim2_init();

usart1_init();

spi1_init();

flash_init();

rfs_init();

HAL_TIM_Base_Start_IT(&htim1);

HAL_TIM_Base_Start_IT(&htim2);

__HAL_TIM_SET_COUNTER(&htim2, 0);

vfsinit();

ut_init(&huart1);

ut_addcommand("sd", setdevice);

ut_addcommand("rd", readdata);

ut_addcommand("wd", writedata);

ut_addcommand("f", devformat);

ut_addcommand("i", dump);

ut_addcommand("c", createinode);

ut_addcommand("d", deleteinode);

ut_addcommand("s", setinode);

ut_addcommand("g", getinode);

ut_addcommand("r", readinode);

ut_addcommand("w", writeinode);

ut_addcommand("b", createbiginode);

ut_addcommand("format", mntdevformat);

ut_addcommand("mount", mounthandler);

ut_addcommand("umount", umounthandler);

ut_addcommand("mountlist", mountlisthandler);

ut_addcommand("open", openfile);

ut_addcommand("read", readfile);

ut_addcommand("write", writefile);

ut_addcommand("close", closefile);

ut_addcommand("mkdir", makedir);

ut_addcommand("mkdev", makedev);

ut_addcommand("rm", unlinkfile);

ut_addcommand("ls", listvfsdir);

ut_addcommand("cd", vfscd);

ut_addcommand("heaptest", heaptest);

printhelp();

mount(dev + 0, "/", fs + 0);

mount(dev + 1, "/dev", fs + 0);

mount(NULL, "/tmp", fs + 1);

format("/tmp");

ut_promptcommand();

while (1) {

int c;

__HAL_TIM_SET_COUNTER(&htim2, 0);

if (ut_getcommand() == 0) {

ut_executecommand();

ut_promptcommand();

}

while ((c = __HAL_TIM_GET_COUNTER(&htim2)) < ITDUR);

}

}

void systemclock_config(void)

{

RCC_OscInitTypeDef RCC_OscInitStruct = {0};

RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

__HAL_RCC_PWR_CLK_ENABLE();

__HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE2);

RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;

RCC_OscInitStruct.HSIState = RCC_HSI_ON;

RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;

RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;

if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)

error_handler();

RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK

| RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_PCLK1

| RCC_CLOCKTYPE_PCLK2;

RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSI;

RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;

RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;

RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct,

FLASH_LATENCY_0) != HAL_OK)

error_handler();

}

static void gpio_init(void)

{

GPIO_InitTypeDef GPIO_InitStruct = {0};

__HAL_RCC_GPIOD_CLK_ENABLE();

__HAL_RCC_GPIOA_CLK_ENABLE();

__HAL_RCC_GPIOB_CLK_ENABLE();

HAL_GPIO_WritePin(GPIOA, OUTPUTPINSA, GPIO_PIN_RESET);

HAL_GPIO_WritePin(GPIOB, OUTPUTPINSB, GPIO_PIN_RESET);

GPIO_InitStruct.Pin = OUTPUTPINSA;

GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;

GPIO_InitStruct.Pull = GPIO_NOPULL;

GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;

HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

GPIO_InitStruct.Pin = OUTPUTPINSB;

GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;

GPIO_InitStruct.Pull = GPIO_NOPULL;

GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;

HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

}

static void spi1_init(void)

{

hspi1.Instance = SPI1;

hspi1.Init.Mode = SPI_MODE_MASTER;

hspi1.Init.Direction = SPI_DIRECTION_2LINES;

hspi1.Init.DataSize = SPI_DATASIZE_8BIT;

hspi1.Init.CLKPolarity = SPI_POLARITY_LOW;

hspi1.Init.CLKPhase = SPI_PHASE_1EDGE;

hspi1.Init.NSS = SPI_NSS_SOFT;

hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_16;

hspi1.Init.FirstBit = SPI_FIRSTBIT_MSB;

hspi1.Init.TIMode = SPI_TIMODE_DISABLE;

hspi1.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;

hspi1.Init.CRCPolynomial = 10;

if (HAL_SPI_Init(&hspi1) != HAL_OK)

error_handler();

}

static void tim1_init(void)

{

TIM_ClockConfigTypeDef sClockSourceConfig = {0};

TIM_MasterConfigTypeDef sMasterConfig = {0};

htim1.Instance = TIM1;

htim1.Init.Prescaler = 72 - 1;

htim1.Init.CounterMode = TIM_COUNTERMODE_UP;

htim1.Init.Period = 0xffff - 1;

htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;

htim1.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;

if (HAL_TIM_Base_Init(&htim1) != HAL_OK)

error_handler();

sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;

if (HAL_TIM_ConfigClockSource(&htim1, &sClockSourceConfig) != HAL_OK)

error_handler();

sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;

sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;

if (HAL_TIMEx_MasterConfigSynchronization(&htim1, &sMasterConfig) != HAL_OK)

error_handler();

}

static void tim2_init(void)

{

TIM_ClockConfigTypeDef sClockSourceConfig = {0};

TIM_MasterConfigTypeDef sMasterConfig = {0};

htim2.Instance = TIM2;

htim2.Init.Prescaler = PRESCALER - 1;

htim2.Init.CounterMode = TIM_COUNTERMODE_UP;

htim2.Init.Period = TIMPERIOD - 1;

htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;

htim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;

if (HAL_TIM_Base_Init(&htim2) != HAL_OK)

error_handler();

sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;

if (HAL_TIM_ConfigClockSource(&htim2, &sClockSourceConfig) != HAL_OK)

error_handler();

sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;

sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;

if (HAL_TIMEx_MasterConfigSynchronization(&htim2, &sMasterConfig) != HAL_OK)

error_handler();

}

static void usart1_init()

{

huart1.Instance = USART1;

huart1.Init.BaudRate = 921600;

huart1.Init.WordLength = UART_WORDLENGTH_8B;

huart1.Init.StopBits = UART_STOPBITS_1;

huart1.Init.Parity = UART_PARITY_NONE;

huart1.Init.Mode = UART_MODE_TX_RX;

huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;

huart1.Init.OverSampling = UART_OVERSAMPLING_16;

if (HAL_UART_Init(&huart1) != HAL_OK)

error_handler();

}

static void flash_init()

{

struct w25_device d;

w25_getdriver(drivers + 0);

d.hspi = &hspi1;

d.gpio = GPIOA;

d.pin = GPIO_PIN_4;

drivers[0].initdevice(&d, dev + 0);

d.hspi = &hspi1;

d.gpio = GPIOB;

d.pin = GPIO_PIN_3;

drivers[0].initdevice(&d, dev + 1);

curdev = dev;

sfs_getfs(fs + 0);

}

static void rfs_init()

{

rfs_getfs(fs + 1);

}

void error_handler(void)

{

__disable_irq();

while (1) {}

}

#ifdef USE_FULL_ASSERT

void assert_failed(uint8_t *file, uint32_t line)

{

}

#endif