Архитектура GPIO-регистров

Введение

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

Тем не менее, для глубокого понимания принципов работы и для оптимизации производительности в специфических задачах, необходимо рассмотреть, какие именно процессы происходят на аппаратном уровне. Основой этого взаимодействия является прямое манипулирование аппаратными регистрами — специализированными ячейками памяти внутри процессора.

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

Важно учитывать, что в линейке Repka Pi используются разные SoC: Repka Pi 3 построена на Allwinner H5, Repka Pi 4 — на Allwinner H6, а Repka Pi 5 — на Rockchip RK3588. Общая логика работы GPIO-регистров схожа, но конкретные имена портов, адреса, битовые поля и коды альтернативных функций зависят от выбранного процессора.

Модель уровней управления

Взаимодействие между кодом пользователя и физическим состоянием GPIO-контакта представляет собой многоуровневый стек управления:

1. Прикладной уровень: Пользовательский код (например, скрипт на Python), который вызывает функции из библиотек.
2. Библиотечный уровень: Программная библиотека (RepkaPi.GPIO, wiringRP), которая транслирует вызовы функций в стандартизированные запросы к операционной системе.
3. Уровень ядра ОС: Ядро Linux обрабатывает эти запросы, используя свои драйверы для преобразования их в низкоуровневые операции записи и чтения в физическую память.
4. Аппаратный уровень: Физические регистры внутри однокристальной системы (SoC), прямое изменение которых и приводит к изменению электрического состояния на контакте.

Данный документ фокусируется на аппаратном уровне (4) и механизмах, применяемых на уровне ядра ОС (3).

Структура GPIO-регистров в SoC

Контакты GPIO сгруппированы в порты или банки. Для каждого такого блока существует набор управляющих регистров. Несмотря на различия в конкретных SoC, архитектура этих регистров обычно подчиняется нескольким общим функциональным категориям.

Регистры конфигурации (Px_CFG, условное обозначение)

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

• INPUT (Вход): Основной режим для приема цифрового сигнала.
• OUTPUT (Выход): Основной режим для передачи цифрового сигнала.
• ALTERNATE FUNCTION (Альтернативная функция): Специализированные режимы, в которых пин перестает быть контактом общего назначения и становится частью аппаратного интерфейса (например, линией TX для UART или SDA для I2C).
• DISABLED (Отключено): Пин неактивен.

Перед любым использованием контакта его режим должен быть сконфигурирован путем записи соответствующего кода в этот регистр.

Регистр данных (Px_DAT, условное обозначение)

Теория: Этот регистр напрямую управляет состоянием пина, настроенного как выход. Запись 1 в соответствующий бит устанавливает высокий уровень напряжения (HIGH), запись 0 — низкий (LOW).

Практика: Ниже приведён пример для плат на Allwinner. Он полезен для понимания принципа, но не должен восприниматься как универсальная инструкция для всех моделей Repka Pi.

Пример: Управление светодиодом на пине PL7.

Предварительное условие: Прежде чем управлять пином как выходом, его нужно настроить в режим OUTPUT.

Шаг 1: Настройка пина PL7 в режим ВЫХОДА (OUTPUT, пример для Allwinner)

• Цель: Изменить конфигурацию пина PL7.
• Регистр: PL_CFG0 (адрес 0x0300B288).

Важно для Repka Pi 5: На Rockchip RK3588 используются другие GPIO-банки, другая карта регистров и другие адреса. Команды с PL7, PL_CFG0, PL_DAT и адресами семейства 0x0300B... относятся к материалу для плат на Allwinner и не должны использоваться на Repka Pi 5 без адаптации под документацию RK3588.

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

Команда:

sudo devmem2 0x0300B288 w

Вывод (пример): Value at address 0x300B288 (0x...): 0x22222222

Что делать: Скопируйте это значение (0x22222222). Ваше значение может отличаться! Используйте именно его на следующем шаге.

Вычисляем новое значение Теперь, используя считанное значение, мы рассчитаем новое. Нам нужно установить биты 28-31 (отвечают за PL7) в 0b0001 (OUTPUT).

Команда (используйте ваш любимый калькулятор или Python): Откройте новый терминал и выполните, подставив ваше значение вместо 0x22222222:

python3 -c "print(hex((0x22222222 & ~0xF0000000) | 0x10000000))"

Вывод: 0x12222222

Что делать: Это наше новое, готовое к записи значение.

Записываем новое значение в регистр Используем devmem2 для записи вычисленного значения.

Команда:

sudo devmem2 0x0300B288 w 0x12222222```

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

**Команда:**
```bash
sudo devmem2 0x0300B288 w

Вывод должен быть: Value at address 0x300B288 (0x...): 0x12222222 Первая цифра 1 означает, что PL7 теперь в режиме OUTPUT.

Шаг 2: Включение светодиода (Установка HIGH на PL7)

• Цель: Подать напряжение на пин PL7.
• Регистр: PL_DAT (адрес 0x0300B29C).

Проделываем ту же процедуру: читаем, вычисляем, записываем.

Читаем регистр данных:

sudo devmem2 0x0300B29C w
# Пример вывода: 0x00000000

Вычисляем новое значение (устанавливаем 7-й бит в 1):

python3 -c "print(hex(0x00000000 | (1 << 7)))"
# Вывод: 0x80

Записываем 0x80, чтобы включить светодиод:

sudo devmem2 0x0300B29C w 0x80

Результат: Ваш светодиод, подключенный к PL7, должен загореться.

Шаг 3: Выключение светодиода (Установка LOW на PL7)

Читаем регистр данных (он сейчас равен 0x80):

sudo devmem2 0x0300B29C w
# Вывод: 0x00000080

Вычисляем новое значение (сбрасываем 7-й бит в 0):

python3 -c "print(hex(0x80 & ~(1 << 7)))"
# Вывод: 0x0

Записываем 0x0, чтобы выключить светодиод:

sudo devmem2 0x0300B29C w 0x0

Результат: Светодиод должен погаснуть.

---

Регистры управления подтяжкой (Px_PUL, условное обозначение)

Теория: Эти регистры управляют внутренними резисторами для пинов, настроенных как вход. На разных SoC они могут называться по-разному и иметь разную организацию битовых полей.

Шаг 1: Настройка пина PL7 в режим ВХОДА (INPUT)

• Цель: Вернуть пин PL7 в безопасное состояние входа.
• Регистр: PL_CFG0 (адрес 0x0300B288).

Читаем регистр:

sudo devmem2 0x0300B288 w
# Пример вывода: 0x12222222

Вычисляем (устанавливаем биты PL7 в 0b0000):

python3 -c "print(hex(0x12222222 & ~0xF0000000))"
# Вывод: 0x2222222

Записываем:

sudo devmem2 0x0300B288 w 0x2222222

Теперь пин PL7 является входом.

Шаг 2: Включение Pull-Up резистора (подтяжка к уровню питания линии)

• Цель: Задать пину PL7 стабильно высокий уровень по умолчанию.
• Регистр: PL_PUL0 (адрес 0x0300B2A8).

Читаем регистр подтяжки:

sudo devmem2 0x0300B2A8 w
# Пример вывода: 0x00000000

Вычисляем (устанавливаем биты PL7 (14-15) в 0b01):

python3 -c "print(hex((0x0 & ~0xC000) | 0x4000))"
# Вывод: 0x4000

Записываем:

sudo devmem2 0x0300B2A8 w 0x4000

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

Шаг 3: Отключение подтяжки (возврат в "плавающее" состояние)

Читаем регистр (он сейчас равен 0x4000):

sudo devmem2 0x0300B2A8 w

Вычисляем (устанавливаем биты PL7 в 0b00):

python3 -c "print(hex(0x4000 & ~0xC000))"
# Вывод: 0x0```
**3.3. Записываем:**
```bash
sudo devmem2 0x0300B2A8 w 0x0

Результат: Пин PL7 вернулся в состояние по умолчанию для входа — без подтяжки. Отлично, это финальный штрих, который превратит документацию в настоящую методичку. Мы структурируем главу 4 как справочник по "командам" для работы с регистрами, а в главе 5 покажем, зачем вся эта сложность нужна, на новом, показательном примере.

Методы доступа и модификации: API для работы с регистрами

Для управления регистрами из командной строки необходимо освоить три фундаментальные операции, которые вместе составляют цикл «Чтение-Модификация-Запись». Ниже представлен своего рода "API" для работы с devmem2, где каждая операция разбирается как отдельная команда.

Чтение регистра (READ)

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

• Инструмент: devmem2

• Синтаксис: sudo devmem2 [адрес] w

• Пример: Чтение регистра конфигурации порта L (PL_CFG0).

  sudo devmem2 0x0300B288 w
  

• Результат: Вы получите строку, из которой нужно извлечь шестнадцатеричное значение. Value at address 0x300B288 (0x...): 0x22222222 Рабочее значение для следующего шага — 0x22222222.

Модификация значения (MODIFY)

Эта операция выполняется "офлайн" — не на устройстве, а с помощью калькулятора или интерпретатора Python. Вы берете считанное значение и применяете к нему битовые маски.

• Инструмент: python3

• Синтаксис: python3 -c "print(hex( ( [значение] & ~[маска_очистки] ) | [маска_установки] ))"

• Пример: Изменение значения 0x22222222, чтобы установить для пина PL7 режим OUTPUT (0b0001).

  python3 -c "print(hex( (0x22222222 & ~0xF0000000) | 0x10000000 ))"
  ```*   **Результат:** Вы получите новое, готовое к записи значение.
  `0x12222222`
  
  

Запись регистра (WRITE)

Это финальная операция, которая атомарно заменяет старое значение в регистре на новое, вычисленное нами.

• Инструмент: devmem2

• Синтаксис: sudo devmem2 [адрес] w [новое_значение]

• Пример: Запись нового значения в регистр PL_CFG0.

  sudo devmem2 0x0300B288 w 0x12222222
  

• Результат: Состояние пина физически изменится.

Прикладное применение и заключение: Тест производительности

Мы изучили теорию и освоили методы прямого доступа. Но зачем это нужно, если есть удобные и безопасные библиотеки? Ответ — скорость.

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

Задача: Генерация максимально высокочастотного сигнала

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

Контекст примера: Ниже приведен пример для платформы на Allwinner H6. Мы используем Python с модулем mmap, так как он является почти точной копией механизма работы с памятью в C, но с более чистым синтаксисом. Скрипт сначала настроит пин PL7 на выход, а затем войдет в цикл переключений.

Важно для Repka Pi 5: Этот код нельзя использовать на Rockchip RK3588 без переработки. Для Repka Pi 5 потребуется другая карта MMIO, другие имена GPIO-линий, другие смещения регистров и сверка с документацией именно на RK3588 и конкретную плату.

#!/usr/bin/env python3
#
# Тест производительности GPIO через прямое управление регистрами.
# Запуск: sudo python3 ./gpio_speed_test.py

import mmap
import os
import struct
import time

# --- Константы для Allwinner H6 ---
PIO_BASE_PHYS = 0x0300B000
BLOCK_SIZE = 4096

PL_CFG0_OFFSET = 0x0288
PL_DAT_OFFSET = 0x029C
PIN_NUMBER = 7 # Наш PL7

def gpio_speed_test():
    # --- Шаг 1: Получение прямого доступа к памяти ---
    try:
        f = os.open("/dev/mem", os.O_RDWR | os.O_SYNC)
        mem = mmap.mmap(f, BLOCK_SIZE, mmap.MAP_SHARED, mmap.PROT_READ | mmap.PROT_WRITE, offset=PIO_BASE_PHYS)
    except Exception as e:
        print(f"Ошибка доступа к /dev/mem: {e}")
        return

    # --- Шаг 2: Настройка пина PL7 в режим OUTPUT ---
    # Читаем текущее значение
    val = struct.unpack('<L', mem[PL_CFG0_OFFSET:PL_CFG0_OFFSET+4])[0]
    # Модифицируем: Очищаем биты PL7 и устанавливаем код 0b0001 (OUTPUT)
    val = (val & ~(0xF << (PIN_NUMBER * 4))) | (0x1 << (PIN_NUMBER * 4))
    # Записываем
    mem[PL_CFG0_OFFSET:PL_CFG0_OFFSET+4] = struct.pack('<L', val)
    
    print(f"Пин PL{PIN_NUMBER} настроен как OUTPUT. Начинаем тест...")

    # --- Шаг 3: Тест скорости ---
    iterations = 1000000
    
    # Заранее получаем текущее значение регистра данных
    dat_val = struct.unpack('<L', mem[PL_DAT_OFFSET:PL_DAT_OFFSET+4])[0]
    
    # И заранее вычисляем маски для установки и сброса бита
    set_mask = 1 << PIN_NUMBER
    clear_mask = ~set_mask

    start_time = time.monotonic()
    
    for i in range(iterations):
        # Максимально быстрый цикл: только логические операции и запись
        dat_val |= set_mask  # Установить бит (HIGH)
        mem[PL_DAT_OFFSET:PL_DAT_OFFSET+4] = struct.pack('<L', dat_val)
        
        dat_val &= clear_mask # Сбросить бит (LOW)
        mem[PL_DAT_OFFSET:PL_DAT_OFFSET+4] = struct.pack('<L', dat_val)
        
    end_time = time.monotonic()

    # --- Шаг 4: Расчет и вывод результатов ---
    duration = end_time - start_time
    # Каждая итерация - это один полный период (HIGH-LOW), т.е. одно переключение
    frequency_hz = iterations / duration
    frequency_khz = frequency_hz / 1000
    frequency_mhz = frequency_khz / 1000

    print(f"\nТест завершен.")
    print(f"Выполнено {iterations:,} переключений за {duration:.4f} секунд.")
    print(f"Частота переключения: {frequency_khz:.2f} кГц ({frequency_mhz:.3f} МГц)")

    # Очистка
    mem.close()
    os.close(f)

if __name__ == '__main__':
    gpio_speed_test()

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

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

Знание архитектуры регистров превращает вас из простого пользователя библиотек в инженера, который может сделать осознанный выбор: когда достаточно удобного инструмента, а когда необходимо взяться за "скальпель" для решения действительно сложных и требовательных к скорости задач.