кароч, думал о таком ещё лет 15 назад
а теперь кто-то сделал, ну как всегда)
только я хотел вместо колков "шаговики" влепить, чтобы нажал кнопочку и всё подстроилось

Напомнило

Разработка одноплатного компьютера. Пособие для продвинутых

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

https://habr.com/ru/post/577246/

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

Разработчик опытный, но всю статью лил воду. В итоге дал только один практический совет по USB. Хотя по такому проекту можно было написать целый учебник. NXP - платформа плохо известная и дорогая - нам нищебродам проще и доступнее разобраться в каком-нибудь sunxi, коих выпущено десятки миллионов штук за три копейки. Да и для пылесоса хватило бы какого-нибудь Allwinner.

Если вдруг хотели поменять вывод загрузки карточки или загрузк  цп у малинки на другой пин, то вот:

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

👍

Кросива

это что мультитрединг?

это просто переменная

По мотивам вчерашнего обсуждения в https://t.me/theyforcedme/2895

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

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

void foo(){
    // выделяем память
    DataType* data = malloc(sizeof(Data));

    // работаем с памятью
    process(data);

    // освобождаем память
    free(data);
}

Пока что все выглядит ок. Но требования меняются, и теперь нам надо обрабатывать данные в зависимости от того что вернула предыдущая обработка.

void foo(){
    DataType* data = malloc(sizeof(Data));

    if(process_1(data)){
        if(process_2(data)){
            if(process_3(data)){
                process_4(data);
            }
        }
    }

    free(data);
}

Цикломатическая сложность растет, и если мы продолжим писать в этом же стиле - рано или поздно мы уйдем ifами за правый край экрана (ну или запутаемся в блоках). Код становится неприятно читать и сложно поддерживать, давайте его перепишем на множественный возврат из функции.

void foo(){
    DataType* data = malloc(sizeof(Data));

    if(!process_1(data)){
        free(data);
        return;
    }

    if(!process_2(data)){
        free(data);
        return;
    }

    if(!process_3(data)){
        free(data);
        return;
    }

    process_4(data);

    free(data);
}

Это выглядит и читается приемлимо, но поддерживать этот код стало еще сложнее, например очень легко можно забыть освободить память перед возвратом. Для борьбы с этим человечество придумало блоки finally и идиому "Получение ресурса есть инициализация" (RAII). К сожалению мы любим простреленные ноги и пишем на языке Си, в котором подобное невозможно реализовать не превратив код обмазанный макросами в некрономикоподобный диалект. Что же мы можем сделать?

void foo(){
    DataType* data = malloc(sizeof(Data));

    if(!process_1(data)) goto finally;
    if(!process_2(data)) goto finally;
    if(!process_3(data)) goto finally;
    process_4(data);

    finally:
        free(data);
}

К сожалению столь лаконичный код получился с использованием goto. Использование оператора goto в целом критикуется, так как программу с его использованием читать на порядки сложнее, как минимум неявны начала и концы переходов, для подробной критики см "Go To Statement Considered Harmful" Эдсгера Дейкстры. Нам нужен блок который бы исполнялся один раз и из которого мы можем выйти оператором отличным от goto, например возьмем отдельную функцию.

void process_data(DataType* data){
    assert(data);
  
    if(!process_1(data)) return;
    if(!process_2(data)) return;
    if(!process_3(data)) return;
    process_4(data);
}

void foo(){
    DataType* data = malloc(sizeof(Data));
    process_data(data);
    free(data);
}

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

Чтобы не отвлекать программиста на другие функции мы можем использовать что-то наподобие "анонимной функции", например цикл из одной итерации. Цикл из одной итерации может быть любого вида, while, for, но do {} while (false); это довольно распространенная и понятная идиома, не требующая дополнительных переменных.

void foo(){
    DataType* data = malloc(sizeof(Data));

    do {
        if(!process_1(data)) break;
        if(!process_2(data)) break;
        if(!process_3(data)) break;
        process_4(data);
    } while(false);

    free(data);
}

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

под какой камень компилите?

Это для flipper zero, stm32wb какой-то

у меня похожая хрень на пике

асма кстати, мне больше зашла чем си, но я не нашел повода ее юзать кроме как 8битных контроллеров