Програмний I2C проти апаратного: запускаємо U8x8 на CH32V003

У проєкті з OLED-дисплеєм та мікроконтролером STM32F103 виниклопитання: чи можна це здешевити? Що, якщо використати CH32V003? Багато ніжок не потрібно, корпусу SOP16 вистачить. Головне питання — як він працюватиме з OLED SSD1306.

Перевіримо це.

Як я писав раніше, U8x8 має легко портуватися і може працювати з програмним I2C (bit-bang). Перенесення коду з CMSIS пройшло дуже швидко — кілька чашок кави, і приклад у мене запрацював. Ось код функції u8x8_gpio_and_delay_ch32v:

uint8_t u8x8_gpio_and_delay_ch32v(u8x8_t *u8x8, uint8_t msg, uint8_t arg_int, void *arg_ptr) {
    switch(msg) {
        case U8X8_MSG_GPIO_AND_DELAY_INIT:
            RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
            GPIO_InitTypeDef init = {0};
            init.GPIO_Pin = GPIO_Pin_1 | GPIO_Pin_2;
            init.GPIO_Mode = GPIO_Mode_Out_OD;
            init.GPIO_Speed = GPIO_Speed_50MHz;
            GPIO_Init(GPIOA, &init);
            break;
        case U8X8_MSG_DELAY_MILLI:
            Delay_Ms(arg_int);
            break;
        case U8X8_MSG_DELAY_10MICRO:
            for (volatile uint32_t i = 0; i < (arg_int * 8); i++) { __NOP(); }
            break;
        case U8X8_MSG_DELAY_100NANO:
            __NOP();
            break;

        case U8X8_MSG_GPIO_I2C_CLOCK:
            GPIO_WriteBit(GPIOA, GPIO_Pin_2, (BitAction)(arg_int ? Bit_SET : Bit_RESET));
            break;

        case U8X8_MSG_GPIO_I2C_DATA:
            GPIO_WriteBit(GPIOA, GPIO_Pin_1, (BitAction)(arg_int ? Bit_SET : Bit_RESET));
            break;
    }
    return 1;
}

Головний нюанс під час налаштування пінів — використовувати режим відкритого стоку (GPIO_Mode_Out_OD). Для самого OLED-дисплея це, можливо, і не критично, але деякі I2C-пристрої також можуть притягувати шину до землі. Якщо пін працюватиме у звичайному Push-Pull режимі, це може призвести до короткого замикання VDD на GND.

Після цих налаштувань програмний I2C чудово завівся:


Проте зупинятися на цьому не хотілося. Мені стало цікаво, тому я продовжив експерименти і підключив бібліотеку U8x8 ще й за допомогою апаратного (Hardware) I2C. Обидва методи я свідомо залишив у коді, щоб наочно порівняти, наскільки апаратна реалізація виявиться швидшою за “ногодриг”.

Більше того, я протестував роботу дисплея не лише на стандартній частоті I2C 400 кГц, а й розігнав шину до 1600 кГц — це виявилася максимальна частота, на якій контролер дисплея ще стабільно приймає дані. Хм, можливо, вдалося б вичавити й більше, якби я вдався до овервольтингу :)

Отже, пропоную подивитися на результати нашого порівняння:

У цифрах маємо таку картину:

  • Програмний I2C (bit-bang) — видав близько 3 кадрів на секунду (332 мс на малювання одного кадру). Цілком прийнятна швидкість, якщо виводити лише статичну інформацію.

  • HW I2C на 400 кГц — показав 12 кадрів на секунду (83 мс на кадр). З таким FPS вже можна робити повноцінний UI, малювати меню та активні елементи.

  • HW I2C на 1600 кГц — видав цілих 32 кадри на секунду (31,6 мс на кадр). З такою швидкістю вже можна крутити плавні анімації, показувати просте відео або навіть зробити емулятор якоїсь ретро-консолі (щоправда, в монохромному вигляді).

Гаразд, досить теорії. Ось готовий C-код для тестування:

#include <ch32v00x.h>
#include <debug.h>
#include <stdlib.h>

#include "clib/u8x8.h"

#define USE_HW_I2C
#define I2C_FREQ 400000  // 400 kHz

void NMI_Handler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
void HardFault_Handler(void) __attribute__((interrupt("WCH-Interrupt-fast")));

uint8_t u8x8_gpio_and_delay_ch32v(u8x8_t *u8x8, uint8_t msg, uint8_t arg_int, void *arg_ptr) {
    switch(msg) {
        case U8X8_MSG_GPIO_AND_DELAY_INIT:
            RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);
            GPIO_InitTypeDef init = {0};
            init.GPIO_Pin = GPIO_Pin_1 | GPIO_Pin_2;
            init.GPIO_Mode = GPIO_Mode_Out_OD;
            init.GPIO_Speed = GPIO_Speed_50MHz;
            GPIO_Init(GPIOC, &init);
            break;
        case U8X8_MSG_DELAY_MILLI:
            Delay_Ms(arg_int);
            break;
        case U8X8_MSG_DELAY_10MICRO:
            for (volatile uint32_t i = 0; i < (arg_int * 8); i++) { __NOP(); }
            break;
        case U8X8_MSG_DELAY_100NANO:
            __NOP();
            break;

        case U8X8_MSG_GPIO_I2C_CLOCK:
            GPIO_WriteBit(GPIOC, GPIO_Pin_2, (BitAction)(arg_int ? Bit_SET : Bit_RESET));
            break;

        case U8X8_MSG_GPIO_I2C_DATA:
            GPIO_WriteBit(GPIOC, GPIO_Pin_1, (BitAction)(arg_int ? Bit_SET : Bit_RESET));
            break;
    }
    return 1;
}

uint8_t u8x8_byte_hw_i2c_ch32v(u8x8_t *u8x8, uint8_t msg, uint8_t arg_int, void *arg_ptr) {
    uint8_t *data;
    switch(msg) {
        case U8X8_MSG_BYTE_INIT:
            RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC | RCC_APB2Periph_AFIO, ENABLE);
            RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1, ENABLE);

            // We will use PC1 (SDA) and PC2 (SCL)
            GPIO_InitTypeDef GPIO_InitStructure = {0};
            GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1 | GPIO_Pin_2;
            GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_OD; // Alternate Function Open-Drain
            GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
            GPIO_Init(GPIOC, &GPIO_InitStructure);

            I2C_InitTypeDef I2C_InitTSturcture = {0};
            I2C_InitTSturcture.I2C_ClockSpeed = I2C_FREQ;
            I2C_InitTSturcture.I2C_Mode = I2C_Mode_I2C;
            I2C_InitTSturcture.I2C_DutyCycle = I2C_DutyCycle_2;
            I2C_InitTSturcture.I2C_OwnAddress1 = 0x00;
            I2C_InitTSturcture.I2C_Ack = I2C_Ack_Enable;
            I2C_InitTSturcture.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
            
            I2C_Init(I2C1, &I2C_InitTSturcture);
            I2C_Cmd(I2C1, ENABLE);
            break;

        case U8X8_MSG_BYTE_START_TRANSFER:
            while(I2C_GetFlagStatus(I2C1, I2C_FLAG_BUSY) != RESET);

            I2C_GenerateSTART(I2C1, ENABLE);
            while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT)); // Чекаємо EV5

            I2C_Send7bitAddress(I2C1, u8x8_GetI2CAddress(u8x8), I2C_Direction_Transmitter);
            while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED)); // Чекаємо EV6
            break;

        case U8X8_MSG_BYTE_SEND:
            data = (uint8_t *)arg_ptr;
            while (arg_int > 0) {
                I2C_SendData(I2C1, *data++);
                while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTED));
                arg_int--;
            }
            break;

        case U8X8_MSG_BYTE_END_TRANSFER:
            I2C_GenerateSTOP(I2C1, ENABLE);
            break;
        default:
            break;
    }
    return 1;
}

void refreshTest(u8x8_t *u8x8) {
    const int8_t columnsCount = 16;
    char buffer[columnsCount + 1];
    uint8_t counter = 0;
    uint32_t start_ticks = SysTick->CNT;
    SysTick->CTLR |= 1; // Enable SysTick
    
    while (1) {
        for (int8_t i = 0; i < sizeof(buffer) - 1; i++) {
            buffer[i] = '0' + counter;
        }
        counter++;
        if (counter > 30) {
            uint32_t end = SysTick->CNT;
            uint32_t elapsed = end - start_ticks;
            printf("Elapsed ticks\t%lu\n", elapsed);
            start_ticks = SysTick->CNT;
            counter = 0;
        }
        buffer[columnsCount] = '\0';
        for (int8_t y = 0; y < 8; y++) {
            u8x8_DrawString(u8x8, 0, y, buffer);
        }
    }
}

int main(void) {
    SystemCoreClockUpdate();
    Delay_Init();
    USART_Printf_Init(9600);

    printf("Current SYSCLK: %lu\n", 
           SystemCoreClock);

    // u8x8 initialization block
    u8x8_t u8x8;
#ifdef USE_HW_I2C
    u8x8_Setup(&u8x8, 
        u8x8_d_ssd1306_128x64_noname, 
        u8x8_cad_ssd13xx_i2c, 
        u8x8_byte_hw_i2c_ch32v, 
        u8x8_gpio_and_delay_ch32v
    );
#else
    // Software i2c
    u8x8_Setup(
        &u8x8, 
        u8x8_d_ssd1306_128x64_noname, 
        u8x8_cad_ssd13xx_i2c, 
        u8x8_byte_sw_i2c, 
        u8x8_gpio_and_delay_ch32v
    );
#endif

    u8x8_InitDisplay(&u8x8);
    u8x8_SetPowerSave(&u8x8, 0);
    u8x8_ClearDisplay(&u8x8);
    u8x8_SetFont(&u8x8, u8x8_font_chroma48medium8_r);
    u8x8_DrawString(&u8x8, 0, 0, "Hello from CH32V");
    u8x8_DrawString(&u8x8, 0, 2, "SW I2C");
    Delay_Ms(3000);

    refreshTest(&u8x8);
    return 0;
}

void NMI_Handler(void) {}
void HardFault_Handler(void)
{
    while (1)
    {
    }
}

Щоб вам було зручно самостійно поекспериментувати, я виніс вибір режиму роботи та налаштування тактової частоти шини у невеличкий блок макросів на самому початку коду:

#define USE_HW_I2C
#define I2C_FREQ 400000  // 400 kHz

Керувати тестами дуже просто: якщо закоментувати рядок #define USE_HW_I2C, програма автоматично перемкнеться на використання програмного I2C. А за допомогою параметра I2C_FREQ ви можете легко регулювати швидкість апаратного інтерфейсу. Наприклад, змініть значення на 1600000, щоб повторити мій експеримент із розгоном і побачити 32 кадри на секунду.

Коментарі

Дописати коментар

Популярні дописи з цього блогу

Огляд DC-DC Step-down Buck перетворювачів

Зображення
Умови та параметри тестування — У більшості випадків я тестував при вхідній напрузі 20 вольт, а на виході було налаштовано 5 вольт. Тестування завершував при досягненні будь-яким компонентом модуля температури 100 градусів. Мінімальне падіння напруги (Dropout Voltage) — це те, наскільки буде мінімальна можлива різниця між напругою на вході і на виході. Наприклад, якщо у нас на вході 12 вольт та мінімальна напруга падіння 0,7 В, то на виході ми не зможемо отримати більше ніж 11,3 В. Доволі часто падіння напруги безпосередньо залежить від струму. Струм холостого ходу (Quiescent Current) - це величина струму, який споживає модуль без підключеного навантаження. Частота перемикань - це частота, з якою силовий транзистор керує подачею струму на котушку індуктивності. Чим вища частота, тим менші пульсації на виході, що дозволяє використовувати компактніші котушки та конденсатори. Проте є і недолік: з підвищенням частоти зростає нагрів силових транзисторів та рівень високочастотних шум...
Докладніше

Як додати підтримку CH32V до Platform.IO

Зображення
CH32V — це доволі дешеві мікроконтролери архітектури RISC-V від WinChipHead (Nanjing Qinheng Microelectronics). Також є CH32F — це мікроконтролери на архітектурі ARM. Для початку нам знадобляться дві речі: Відлагоджувальна плата (девборда) CR-CH32VXX з CH32V003 — це один із найдешевших мікроконтролерів. Та WCH-LinkE — програматор для CH32V. У продажу є прості WCH-Link , але для серії CH32V00x вони не підходять, бо вона використовує однодротовий протокол програмування та відлагодження. А він підтримується лише в дорожчому WchLinkE. До речі, є проєкти, які з RP2040 роблять подібний програматор, але офіційні утиліти (MounRiver Studio) не підтримують нічого, окрім WCH-Link. Але я і не використовую офіційну IDE. Тому, напевно, найближчим часом спробую це зробити та описати методику. Чому я використовую PlatformIO, а не MounRiver Studio? З одного боку, MounRiver Studio є для Linux, який є моєю основною ОС для роботи. Але з іншого — коли я спробував її встановити і вона почала вима...
Докладніше

ESP8266 модуль з OLED екраном (HW-364A)

Зображення
Прийшло до мене декілька таких модулів. Вони ще з старою ESP8266. Нічого, і для нього завжди знайдеться робота. Особливий плюс - одразу на модулі є OLED екранчик 0.91" на 128х64 пікселя, який під'єднаний через контролер SSD1306. З коробки на тестовій прошивці він чудово демонстрував роботу свого OLED дисплея. А от як я спробував семпли від продавця, то отримав чорний екран. Згідно документації - дисплей під'єднаний через програмний I2C SDA - D6, SCL - D5. Але як я залив тестовий проект з вказаними налаштуваннями дисплею - то нічого не отримав. Екран пустий та чорний. Почав шукати щось схоже - і дійсно знайшов багато аналогічних модулів від Wemos або з ESP32. Але всі вони мали взагалі інше під'єднання I2C дисплею. В якийсь момент почав пробувати різні бібліотеки для роботи з SSD1306, і помилився в конфігурації. Прописав піни навпаки - SDA - D5, SCL - D6 . І от курва, воно запрацювало! Семпл коду для U8g2: #include "U8g2lib.h" U8G2_SSD1306_128X64_NONAME_F_SW...
Докладніше