подскажите будь ласка неплохой источник по raspberry pi zero

а именно псб

ну и схематика полная

А мне не дали 4/24 арм 🤷‍♂ аут оф сток. Тоже выбирал по быстрому Амстердам. Думал поближе, не через море, точка обмена трафика рядом. Ага-ага..

Взял 1/1 АМД 🤔 для поиграться.

Ну и там писало предупреждение, что всякие Германии, УК, и другие загружены, выбрал называется то, что не загружено 😄

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

Регион Амстердам.

Какой есть способ узнать IP подключенного одноплатника через кросс соединение?

Скорее всего нет там ip если он кроссом к ПК подключен. Ну если конечно на ПК не поднят dhcp сервер на интерфейсе

Тогда буду dhcp поднимать

Полупроводниковый крезис be like

По мотивам вчерашнего обсуждения в 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);
}

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

void foo() {
   auto data = std::make_unique<DataType>();
   process(data);
   // сколь угодно высокая вложенность if-ов и return-ов, при выходе из скоупа вызовется деаллокатор. Или кастомный функтор для деаллокации, если он был передан аргументов make_unique.
}

#изобретаем_костыли_вместо_использования_плюсов.

Всем привет! Можете посоветовать осциллограф ардуинщику?

у вас какой?

)

"если по чесноку, этому программному коммитету бы забить на развитие C++ и перейти на Rust/Go. Складывается впечатление что люди не понимают куда идут"

Складывается впечетление, что ты вбросил, совершенно не разобравшись в ситуации.

20 стандарт плюсов это лучшее, что с ними произошло.