Перейти к содержанию
    

Сергей Борщ

Модератор
  • Постов

    10 921
  • Зарегистрирован

  • Посещение

  • Победитель дней

    31

Сообщения, опубликованные Сергей Борщ


  1. 1 минуту назад, dfxer сказал:

    Неужели себестоимость процесса декорпусирования

    Зачем? Заказал кто-то на контрактном производстве 100000 плат, в изготовление запустили 101000 для замены при возможном браке сборки. 100000 ушло заказчику, 1000 в мусорку. Дядюшка Ляо покопался в мусорке, у себя в подвале распаял, микросхемы в ленту на коленке закатал и выкинул на свободный рынок по бросовой цене. Барыга у дядюшки Ляо оптом купил и вам через Али продал.

    • Upvote 1
  2. Чисто поржать:

    Спойлер

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

    (тут должна быть картинка с Лавровым)

    • Upvote 1
  3. Можно просто отключать нагрев в момент измерения. За время измерения датчик сильно не остынет. Или измерить смещение от тока нагревательного элемента и вносить его как поправку (в самолетах так влияние всего самолета на компас компенсируют).

  4. #ifndef UNALIGNED_H__
    #define UNALIGNED_H__
    
    template<typename T>
    struct unaligned
    {
        operator T() const                  { return Data; }
        void operator =(T const & value)    { Data = value; }
    
        T   Data;
    } __attribute__((packed));
    
    
    #endif  // UNALIGNED_H__

    Объявить данные как unaligned<uint16_t>, unaligned<int32_t>, unaligned<что угодно> и делать с ними что угодно. В том числе и работать с указателями на unaligned<что угодно>. Но это плюсы, да.

    • Thanks 1
  5. 4 часа назад, repstosw сказал:

    Это точно, что в этих случаях каждый элемент массива будет volatile? Или только имя массива?

    Имя массива не может быть volatile. Как и имя любой другой переменной. Оно имя. volatile относится к содержимому переменной/массива.

  6. 1 час назад, repstosw сказал:

    RSC - указатель на буфер данных, тоже volatile.

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

    1 час назад, repstosw сказал:

    Как сделать массив volatile

    volatile int a1[10];
    int volatile a2[10];	// эти два объявления эквивалентны, выбирайте по вкусу.
    
    int * pa;			// указатель на int
    int * volatile pb;	// volatile-указатель на int
    volatile int * pc1;	// указатель на volatile int
    int volatile * pc2; // тоже указатель на volatile int
    int volatile * volatile pd; // volatile-указатель на volatile-int

     

    • Like 1
    • Upvote 1
  7. 1 час назад, MementoMori сказал:

    По формальной логике  - плюсовую клемму АКБ и контакт замка зажигания, который при поворачивании ключа подсоединяется к  плюсовой клемме АКБ. Но это бред.

    Не знаю, откуда такая логика. По вашей схеме главное реле подключает к АКБ ЭБУ, бензонасос, форсунки, кондиционер клапан ППТ (не знаю, что это такое) и РВГ (тоже не знаю что это, регулятора чего-то?). И это вполне нормально.

    1 час назад, MementoMori сказал:

    А вторые их контакты куда? На землю?

    В ЭБУ, который их коммутирует на землю когда ему нужно.

    1 час назад, MementoMori сказал:

    при выключении зажигания машина не глохнет сразу, останавливается топливный насос и двигатель работает еще секунд 7-8

    Был бы карбюратор - сказал бы, что калильное зажигание.

  8. 1 час назад, Edit2007 сказал:

    Объявлять переменные в начале функции(блока) - это требование классического С. Только плюсы позволяют объявлять переменные где вздумается по мере необходимости.

    В стандарте языка C от 89 года нету требования объявлять переменные в начале блока. Такое требование было в K&R C, еще до введения стандарта. Так что не только лишь плюсы...

    • Upvote 1
  9. 12 часов назад, ChristinaChadzynski сказал:

    на какое они напряжение не понятно

    Никогда не встречал, чтобы выгорали вот прямо все светодиоды в линейке. Хоть какой-то да остался живым. Подать на него напряжение через резистор от ЛБП, зажечь, измерить падение.

  10. 1 час назад, Forger сказал:

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

    В такой системе systick почти не нужен :biggrin: Просто ищу наименьший timeout из активных и завожу на него будильник. А при пробуждении ОС вычитываю из будильника, сколько же прошло времени на самом деле (разбудить ведь мог не будильник, а какое-то другое прерывание) и подправляю системное время и оставшиеся timeout-ы. SysTick включаю только на время исполнения задач ОС, перед спячкой выключаю.

  11. 1 час назад, jcxz сказал:

    Т.е. - вводя SLEEPONEXIT, разработчики уже заведомо предусмотрели модель использования CPU "всегда только в ISR". Без каких-либо "главных циклов".

    А у меня в фоне крутится scmRTOS, у которой переключатель контекста при переключении на IdleTask этот бит взводит, а при переключении на любой другой - сбрасывает. То есть прерывания могут как максимально быстро делать что-то, не требующее участия ОС, так и при необходимости будить задачи ОС.

    • Thanks 1
  12. 32 минуты назад, EdgeAligned сказал:

    Дело в том, что "не ноль" - это любое число, в том числе и отрицательное.

    Дело в том, что результат оператора ! для нулевого аргумента четко определен в стандарте и это ровно единица типа int.

    • Upvote 2
  13. 12 минут назад, EdgeAligned сказал:

    TI-режим SPI. Только по времянкам не совпадет с тем, как надо

    В обычном режиме тоже:
    image.thumb.png.e50368d2f09c541b984051d958e8c395.png

    Это ли не то, что нужно автору темы?

     

    Вот если нужно N байтов "обрамить" - тогда да, только врукопашную.

  14. 1 час назад, amaora сказал:

    Есть такая известная проблема у STM32 (в частности F4 и F7), что не умеет модуль SPI работать с NSS сигналом.

    Какая проблема? Перечитал errata, ничего про NSS не нашел. STM32 умеет дергать NSS на каждую посылку и умеет посылки по 16 бит, как раз то, что вам и нужно.

  15. 10 минут назад, Lagman сказал:

    Тут ошибка?

    У меня работает...

    MASK = 0xF0, 5 * (0xF0 & 0xFFFFFF10) = 5 * 0x10 = 0x50, что и требовалось.

    10 минут назад, Lagman сказал:

    У нас такое выражение используется для установки полей по маске:

    У вас другое выражение - в нем инверсия, в моем отрицательное число.

  16. 24 минуты назад, Homiak1988 сказал:

    Почему нет?

    Пожалуйста. Но это будет не встроенный в таблетку счетчик, а некая логическая конструкция поверх записи в ЭСППЗУ (EEPROM). Кстати, 33 байта * миллион записей потребует примерно 32 мегабайта, а в таблетке памяти в 1000 раз меньше.

    24 минуты назад, Homiak1988 сказал:

    Таблетку подключал отдельно,без аппарата.

    Это как? Аппарат формирует запросы к таблетке, без адресованных ей запросов она будет просто молчать. Вы наблюдаете просадки от заряда накопительного конденсатора внутри таблетки.

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

    Из совсем старого (чистый C) :

    Спойлер

     

    #define	SEG_A	(1<<1)
    #define	SEG_B	(1<<0)
    #define	SEG_C	(1<<6)
    #define	SEG_D	(1<<5)
    #define	SEG_E	(1<<4)
    #define	SEG_F	(1<<2)
    #define	SEG_G	(1<<3)
    #define	SEG_H	(1<<7)
    
    #define	DIGIT_0	\
    	((1 * SEG_A) | (1 * SEG_B) | (1 * SEG_C) | (1 * SEG_D) | (1 * SEG_E) | (1 * SEG_F) | (0 * SEG_G))	//0
    #define	DIGIT_1	\
    	((0 * SEG_A) | (1 * SEG_B) | (1 * SEG_C) | (0 * SEG_D) | (0 * SEG_E) | (0 * SEG_F) | (0 * SEG_G))	//1
    #define	DIGIT_2	\
    	((1 * SEG_A) | (1 * SEG_B) | (0 * SEG_C) | (1 * SEG_D) | (1 * SEG_E) | (0 * SEG_F) | (1 * SEG_G))	//2
    #define	DIGIT_3	\
    	((1 * SEG_A) | (1 * SEG_B) | (1 * SEG_C) | (1 * SEG_D) | (0 * SEG_E) | (0 * SEG_F) | (1 * SEG_G))	//3
    #define	DIGIT_4	\
    	((0 * SEG_A) | (1 * SEG_B) | (1 * SEG_C) | (0 * SEG_D) | (0 * SEG_E) | (1 * SEG_F) | (1 * SEG_G))	//4
    #define	DIGIT_5	\
    	((1 * SEG_A) | (0 * SEG_B) | (1 * SEG_C) | (1 * SEG_D) | (0 * SEG_E) | (1 * SEG_F) | (1 * SEG_G))	//5
    #define	DIGIT_6	\
    	((1 * SEG_A) | (0 * SEG_B) | (1 * SEG_C) | (1 * SEG_D) | (1 * SEG_E) | (1 * SEG_F) | (1 * SEG_G))	//6
    #define	DIGIT_7	\
    	((1 * SEG_A) | (1 * SEG_B) | (1 * SEG_C) | (0 * SEG_D) | (0 * SEG_E) | (0 * SEG_F) | (0 * SEG_G))	//7
    #define	DIGIT_8	\
    	((1 * SEG_A) | (1 * SEG_B) | (1 * SEG_C) | (1 * SEG_D) | (1 * SEG_E) | (1 * SEG_F) | (1 * SEG_G))	//8
    #define	DIGIT_9	\
    	((1 * SEG_A) | (1 * SEG_B) | (1 * SEG_C) | (1 * SEG_D) | (0 * SEG_E) | (1 * SEG_F) | (1 * SEG_G))	//9
    
    uint8_t const PROGMEM num[] = // Numbers for LCD
    {
        DIGIT_0, DIGIT_1, DIGIT_2, DIGIT_3, DIGIT_4,
        DIGIT_5, DIGIT_6, DIGIT_7, DIGIT_8, DIGIT_9,
    };
    
    uint16_t LCD_number (uint8_t x) //send number 01..99 to LCD
    {
        if(x == NO_CONNECTION)
            return (SEG_G << 8) | (SEG_G);
        if(x >= 100)
            return 0;
    
        if(x < 10)
            return pgm_read_byte(&num[x])<<8;
    
        uint8_t tmp = 0;
        while (x >= 10)
        {
            x = x - 10;
            tmp++;
        }
        return pgm_read_byte(&num[tmp]) | (pgm_read_byte(&num[x])<<8);
    }

    более свежее (плюсы):

    Спойлер
    #ifndef DISPLAY_H__
    #define DISPLAY_H__
    #include    <stdint.h>
    
    class display
    {
    public:
        using raw_data = uint16_t;
        display()
        : Bitmap(0)
        , Refresh_counter(0)
        {}
    
        void show(uint8_t value);
        void show_dashes()                  { Bitmap = Encode_digit1[10] | Encode_digit2[10]; }
        void blank()                        { Bitmap = 0; }
    
        raw_data refresh()                  { return ++Refresh_counter & 0x01 ? Bitmap : (~Bitmap); }
    private:
        enum
        {
            //     aaa
            //    f   b
            //    f   b
            //     ggg
            //    e   c
            //    e   c
            //     ddd
            NC,
            C1,
            D1,
            E1,
            C2,
            D2,
            E2,
            G2,
            CMN,
            F2,
            A2,
            B2,
            G1,
            F1,
            A1,
            B1,
        };
    
        uint16_t        Bitmap;
        uint_fast8_t    Refresh_counter;
    
        static constexpr uint16_t Encode_digit1[] =
        {
            (1 << A1) | (1 << B1) | (1 << C1) | (1 << D1) | (1 << E1) | (1 << F1) | (0 << G1),      // 0
            (0 << A1) | (1 << B1) | (1 << C1) | (0 << D1) | (0 << E1) | (0 << F1) | (0 << G1),      // 1
            (1 << A1) | (1 << B1) | (0 << C1) | (1 << D1) | (1 << E1) | (0 << F1) | (1 << G1),      // 2
            (1 << A1) | (1 << B1) | (1 << C1) | (1 << D1) | (0 << E1) | (0 << F1) | (1 << G1),      // 3
            (0 << A1) | (1 << B1) | (1 << C1) | (0 << D1) | (0 << E1) | (1 << F1) | (1 << G1),      // 4
            (1 << A1) | (0 << B1) | (1 << C1) | (1 << D1) | (0 << E1) | (1 << F1) | (1 << G1),      // 5
            (1 << A1) | (0 << B1) | (1 << C1) | (1 << D1) | (1 << E1) | (1 << F1) | (1 << G1),      // 6
            (1 << A1) | (1 << B1) | (1 << C1) | (0 << D1) | (0 << E1) | (0 << F1) | (0 << G1),      // 7
            (1 << A1) | (1 << B1) | (1 << C1) | (1 << D1) | (1 << E1) | (1 << F1) | (1 << G1),      // 8
            (1 << A1) | (1 << B1) | (1 << C1) | (1 << D1) | (0 << E1) | (1 << F1) | (1 << G1),      // 9
            (0 << A1) | (0 << B1) | (0 << C1) | (0 << D1) | (0 << E1) | (0 << F1) | (1 << G1),      // -
        };
    
        static constexpr uint16_t Encode_digit2[] =
        {
            (1 << A2) | (1 << B2) | (1 << C2) | (1 << D2) | (1 << E2) | (1 << F2) | (0 << G2),      // 0
            (0 << A2) | (1 << B2) | (1 << C2) | (0 << D2) | (0 << E2) | (0 << F2) | (0 << G2),      // 1
            (1 << A2) | (1 << B2) | (0 << C2) | (1 << D2) | (1 << E2) | (0 << F2) | (1 << G2),      // 2
            (1 << A2) | (1 << B2) | (1 << C2) | (1 << D2) | (0 << E2) | (0 << F2) | (1 << G2),      // 3
            (0 << A2) | (1 << B2) | (1 << C2) | (0 << D2) | (0 << E2) | (1 << F2) | (1 << G2),      // 4
            (1 << A2) | (0 << B2) | (1 << C2) | (1 << D2) | (0 << E2) | (1 << F2) | (1 << G2),      // 5
            (1 << A2) | (0 << B2) | (1 << C2) | (1 << D2) | (1 << E2) | (1 << F2) | (1 << G2),      // 6
            (1 << A2) | (1 << B2) | (1 << C2) | (0 << D2) | (0 << E2) | (0 << F2) | (0 << G2),      // 7
            (1 << A2) | (1 << B2) | (1 << C2) | (1 << D2) | (1 << E2) | (1 << F2) | (1 << G2),      // 8
            (1 << A2) | (1 << B2) | (1 << C2) | (1 << D2) | (0 << E2) | (1 << F2) | (1 << G2),      // 9
            (0 << A2) | (0 << B2) | (0 << C2) | (0 << D2) | (0 << E2) | (0 << F2) | (1 << G2),      // -
        };
    };
    
    inline void display::show(uint8_t value)
    {
        if(value < 100)
            Bitmap = Encode_digit1[value % 10] | Encode_digit2[value / 10];
        else
            show_dashes();
    }
    
    extern display Display;
    #endif  // DISPLAY_H__

     

     

    • Upvote 2
×
×
  • Создать...