Модули Pycom

Эти модули специфичны для устройств Pycom и могут иметь реализации, немного отличающиеся от других вариантов MicroPython (то есть для устройств не Pycom). Модули включают в себя те, которые поддерживают доступ к базовому оборудованию, например, I2C, SPI, WLAN, Bluetooth и т.д.

MACHINE

Модуль machine содержит специальные функции, связанные с платой.

Пример использования

import machine

help(machine) # отобразить все элементы из модуля machine

machine.freq() # получить частоту процессора

machine.unique_id() # вернуть 6-байтовый уникальный идентификатор платы (MAC-адрес Wi-Fi LoPy)

Функции сброса

machine.reset()

Сброс устройства аналогично нажатию внешней кнопки RESET.

machine.reset_cause()

Вывод причины сброса.

Функции прерывания

machine.disable_irq()

Отключение запросов прерывания. Возвращает целое число, отображающее предыдущее состояние IRQ. Это возвращаемое значение можно передать в enable_irq, чтобы восстановить IRQ в исходное состояние.

machine.enable_irq([state])

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

Функции питания

machine.freq()

Возвращает частоту процессора в герцах.

machine.idle()

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

machine.deepsleep([time_ms])

Останавливает процессор и все периферийные устройства, включая сетевые интерфейсы (кроме LTE). Выполнение возобновляется из основного скрипта, как и при сбросе. Если задано значение в миллисекундах, то устройство «проснется» после этого периода времени, в противном случае оно будет находиться в состоянии глубокого сна, пока не будет нажата кнопка сброса.

Для продуктов с возможностью подключения LTE (FiPy, GPy, G01) требуется, чтобы радиостанция LTE была отключена отдельно через класс LTE перед входом в режим ожидания. Это требуется из-за того, что радиостанция LTE получает питание независимо и допускает случаи использования, которые требуют, чтобы система была выведена из спящего режима из-за события из сети LTE (например, полученных данных или SMS).

machine.pin_deepsleep_wakeup(pins, mode, enable_pull)

Настройка контактов для выхода из режима глубокого сна. Контакты, которые имеют эту возможность: P2, P3, P4, P6, P8 до P10 и P13 до P23.

Аргументы:

• pins - список или кортеж, содержащий GPIO, для настройки режима глубокого сна.
• mode - выбирает способ, которым сконфигурированные GPIO могут «разбудить» модуль. Возможные значения: machine.WAKEUP_ALL_LOW и machine.WAKEUP_ANY_HIGH.
• enable_pull - если установлено значение True, сохраняет резисторы повышающего или понижающего сопротивления во время глубокого сна. Если для этой переменной задано значение True, то активация ULP или емкостное касание не может использоваться в сочетании с активацией GPIO.

machine.wake_reason()

Получает причину пробуждения. Возвращает кортеж в форме: (wake_reason, gpio_list). Если причиной пробуждения является либо GPIO, либо сенсорная панель, то вторым элементом кортежа является список с GPIO, которые сгенерировали пробуждение.

machine.remaining_sleep_time()

Возвращает оставшуюся продолжительность таймера (в миллисекундах), если ESP32 «проснулся» из глубокого сна не из-за таймера. Например, если вы установите таймер на 30 секунд (30000 мс), ESP32 активируется через 10 секунд, тогда эта функция вернет 20000.

Разные функции

machine.main(filename)

Задаёт filename (имя файла) основного скрипта для запуска после завершения boot.py. Если эта функция не вызывается, то по умолчанию будет выполнен файл main.py.

Имеет смысл вызывать эту функцию только из boot.py.

machine.rng()

Возвращает 24-битное сгенерированное случайное число.

machine.unique_id ()

Возвращает байтовую строку с уникальным идентификатором платы/SoC. Она будет отличаться в зависимости от экземпляра платы/SoC, если позволяет оборудование. Длина зависит от аппаратного обеспечения (поэтому используйте подстроку с полным значением, если вы ожидаете короткий идентификатор). В некоторых портах MicroPython идентификатор соответствует MAC-адресу сети.

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

machine.info()

Возвращает верхнюю отметку стека, связанную с различными системными задачами (1 слово = 4 байта в ESP32). Если значение равно нулю, вероятно, задача переполнила свой стек. Если значение близко к нулю, то задача приблизилась к переполнению своего стека.

Константы

Причины сброса

machine.PWRON_RESET, machine.HARD_RESET, machine.WDT_RESET, machine.DEEPSLEEP_RESET, machine.SOFT_RESET, machine.BROWN_OUT_RESET

Причины «пробуждения»

machine.PWRON_WAKE, machine.PIN_WAKE, machine.RTC_WAKE, machine.ULP_WAKE

Режим Pin Wakeup 

machine.WAKEUP_ALL_LOW, machine.WAKEUP_ANY_HIGH

АЦП

Класс АЦП - аналого-цифровое преобразование

Пример использования

import machine

adc = machine.ADC()             # создать объект АЦП

apin = adc.channel(pin=‘P16‘)   # создать аналоговый вывод на P16

val = apin()                    # считать аналоговое значение

Конструкторы

класс machine.ADC(id = 0)

Создаёт объект АЦП; связать канал с выводом. Для получения дополнительной информации изучите раздел оборудования.

Методы

adc.init( * , bits=12)

Включает блок АЦП. Этот метод автоматически вызывается при создании объекта. Bits может принимать значения от 9 до 12

adc.deinit()

Отключает блок АЦП.

adc.channel(*, pin, attn = ADC.ATTN_0DB)

Создаёт аналоговый выход.

• pin - строковый аргумент только для ключевых слов. Допустимые контакты - от P13 до P20.
• attn - уровень ослабления. Поддерживаемые значения: ADC.ATTN_0DB, ADC.ATTN_2_5DB, ADC.ATTN_6DB, ADC.ATTN_11DB

Возвращает объект ADCChannel. Пример:

# включить канал АЦП на P16

apin = adc.channel(pin=‘P16‘)

 

adc.vref(vref)

Если эта функция вызывается без каких-либо аргументов, то она возвращает текущее калиброванное напряжение (в милливольтах) 1,1 В. В противном случае она обновляет калиброванное значение (в милливольтах) внутреннего 1.1 В.

adc.vref_to_pin(pin)

Подключает внутренний 1.1v к внешнему GPIO. Может быть подключен только к P22, P21 или P6. На WiPy рекомендуется использовать только P6, на других модулях этот вывод подключен к радио.

Константы

Значения затухания канала АЦП: ADC.ATTN_0DB, ADC.ATTN_2_5DB, ADC.ATTN_6DB, ADC.ATTN_11DB

Класс ADCChannel

Считывает аналоговые значения из внутренних / внешних источников. Каналы ADC могут быть подключены к внутренним точкам MCU или к выводам GPIO. Каналы АЦП создаются с использованием метода ADC.channel.

Методы

adcchannel()

Быстрый метод для чтения значения канала.

adcchannel.value()

Считывает значение канала.

adcchannel.init()

Инициирует и включает канал АЦП. Этот метод автоматически вызывается при создании объекта.

adcchannel.deinit()

Отключает канал АЦП.

adcchannel.voltage()

Считывает значение канала и преобразует его в напряжение (в милливольтах)

adcchannel.value_to_voltage(value)

Преобразует предоставленное значение в напряжение (в милливольтах)

Диапазон ввода контактов АЦП составляет 0-1,1 В. Максимальное значение может быть увеличено до 3,3 В с использованием максимального ослабления в 11 дБ. Не превышайте максимум 3,3 В, чтобы не повредить устройство.

ЦАП

Цифро-аналоговый преобразователь используется для вывода аналоговых значений (удельного напряжения) на контакт P22 или P21. Напряжение будет в диапазоне от 0 до 3,3 В.

Пример использования

import machine

dac = machine.DAC(‘P22‘) # создать объект ЦАП

dac.write(0.5) # установить вывод на 50%

dac_tone = machine.DAC(‘P21‘) # создать объект ЦАП

dac_tone.tone (1000, 0) # установить вывод на 1 кГц

Конструкторы

class class machine.DAC(pin)

Создает объект ЦАП, который позволит вам связать канал с выводом. Вывод может быть строковым аргументом.

Методы

dac.init()

Включает блок ЦАП. Этот метод автоматически вызывается при создании объекта.

dac.deinit()

Отключает блок ЦАП.

dac.write(value)

 Устанавливает уровень постоянного тока для контакта ЦАП. value является аргументом с плавающей точкой, значения которого находятся в диапазоне от 0 до 1.

dac.tone(frequency, amplitude)

Устанавливает тональный сигнал на указанную частоту на амплитудной шкале. Частота может быть от 125 Гц до 20 кГц с шагом 122 Гц. Амплитуда - это целое число, указывающее амплитуду тона для записи контакта ЦАП. Значение амплитуды представляет:

• 0 составляет 0 дБВ (~ 3 В при нагрузке 600 Ом)
• 1 составляет -6 дБВ (~ 1,5 Вpp), 2 составляет -12 дБВ (~ 0,8 Вpp)
• 3 составляет -18 дБВ (~ 0,4 В).

Генерируемый сигнал представляет собой синусоидальную волну со смещением постоянного тока VDD / 2.

I2C

I2C - это двухпроводной протокол связи между устройствами. На физическом уровне он состоит из двух проводов: SCL и SDA, соответствующих тактовой частоты и линии данных.

Объекты I2C создаются подключенными к определенной шине. Они могут быть инициализированы при создании или позже.

Пример использования входа по умолчанию

from machine import I2C

i2c = I2C(0)                         # создать на шине 0

i2c = I2C(0, I2C.MASTER)             # создать и пройти инициализацию как мастер

i2c = I2C(0, pins=(‘P10‘,‘P11‘))     # создать и использовать не назначенные по умолчанию PIN-коды (P10 = SDA, P11 = SCL)

i2c.init(I2C.MASTER, baudrate=20000) # пройти инициализацию как мастер

i2c.deinit()                         # выключить периферию

Пример использования неконтактного входа

from machine import I2C

i2c = I2C(0, pins=(‘P10‘,‘P11‘))     # создать и использовать не назначенные по умолчанию PIN-коды (P10 = SDA, P11 = SCL)

i2c.init(I2C.MASTER, baudrate=20000) # пройти инициализацию как мастер

i2c.deinit()                         # выключить периферию

Печать объекта i2c дает вам информацию о его конфигурации.

Мастер должен указать адрес получателя:

i2c.init(I2C.MASTER)

i2c.writeto(0x42, ‘123‘)        # отправляет 3 байта ведомому с адресом 0x42

i2c.writeto(addr=0x42, b‘456‘)  # ключевое слово для адресации

Мастер также имеет другие методы:

i2c.scan() # сканирует ведомых на шине, возвращая список действительных адресов

i2c.readfrom_mem(0x42, 2, 3) # читает 3 байта из памяти ведомого 0x42, начиная с адреса 2 в ведомом

i2c.writeto_mem(0x42, 2, ‘abc‘) # записывает ‘abc‘ (3 байта) в память ведомого 0x42, начиная с адреса 2 в ведомом; тайм-аут через 1 секунду

Пример использования

from machine import I2C

# настроить шину I2C

i2c = I2C(0, I2C.MASTER, baudrate=100000)

i2c.scan() # возвращает список адресов подчиненных

i2c.writeto(0x42, ‘hello‘) # отправляет 5 байтов ведомому с адресом 0x42

i2c.readfrom(0x42, 5) # получает 5 байт от ведомого

i2c.readfrom_mem(0x42, 0x10, 2) # считывает 2 байта из ведомого 0x42, slave memory 0x10

i2c.writeto_mem(0x42, 0x10, ‘xy‘) # записывает 2 байта в ведомое устройство 0x42, slave memory 0x10

Конструкторы

class machine.I2C(bus, …)

Построение объекта I2C на заданной шине. Шина может быть только 0, 1, 2. Если шина не указана, то будет выбрана шина по умолчанию (0). В шинах 0 и 1 используется аппаратная периферия ESP32 I2C, а в шине 2 реализован драйвер с побитовым софтом.

Методы

Общие методы

i2c.init(mode, * , baudrate=100000, pins=(SDA, SCL))

Инициализирует шину I2C с заданными параметрами:

• mode должен быть I2C.MASTER
• baudrate - тактовая частота SCL
• pins - это дополнительный кортеж с контактами для назначения на шину I2C. К выводам I2C по умолчанию относятся P9 (SDA) и P10 (SCL)

i2c.scan()

Сканирует все адреса I2C в диапазоне от 0x08 до 0x77 включительно и возвращает список отвечающих. Устройство отвечает, если оно выводит линию SDA в низкий уровень после того, как его адрес (включая бит чтения) отправлен на шину.

Стандартные операции

Следующие методы реализуют стандартные основные операции чтения и записи I2C, предназначенные для данного ведомого устройства.

i2c.readfrom(addr, nbytes)

Чтение nbytes из ведомого, указанного в addr. Возвращает объект байтов с прочитанными данными.

i2c.readfrom_into(addr, buf)

Чтение в buf от ведомого, указанного в addr. Количество прочитанных байтов будет длиной buf.

Возвращаемое значение - количество прочитанных байтов.

i2c.writeto(addr, buf, *, stop = True)

Записывает байты из buf в ведомое устройство, указанное в addr. Аргумент buf также может быть целым числом, которое будет обрабатываться как один байт. Если stop установлен на False, то условие останова отправляться не будет, и операция I2C может быть продолжена (обычно с транзакцией чтения).

Возвращаемое значение - количество записанных байтов.

Операции с памятью

Некоторые устройства I2C действуют как запоминающее устройство (или набор регистров), которые могут считываться и записываться. В этом случае с транзакцией I2C связаны два адреса: адрес ведомого и адрес памяти. Следующие методы являются вспомогательными функциями для связи с такими устройствами.

i2c.readfrom_mem(addr, memaddr, nbytes, *, addrsize = 8)

Считывает nbytes из ведомого, указанного в addr, начиная с адреса памяти, указанного в memaddr. Аргумент addrsize указывается в битах и может принимать только значения 8 или 16.

i2c.readfrom_mem_into(addr, memaddr, buf, *, addrsize = 8)

Чтение в buf от ведомого устройства, указанного в addr, начиная с адреса памяти, указанного в memaddr. Количество прочитанных байтов - это длина buf. Аргумент addrsize указывается в битах и может принимать только значения 8 или 16. Возвращаемое значение - это количество прочитанных байтов.

i2c.writeto_mem(addr, memaddr, buf *, addrsize = 8)

Записывает buf в ведомое устройство, указанное в addr, начиная с адреса памяти, указанного в memaddr. Аргумент buf также может быть целым числом, которое будет обрабатываться как один байт. Аргумент addrsize указывается в битах и может принимать только значения 8 или 16. Возвращаемое значение - количество записанных байтов.

Константы

I2C.MASTER: Используется для инициализации шины в режиме мастера.

Pin

Pin - основной объект для управления контактами ввода / вывода (также известными как GPIO - ввод / вывод общего назначения). У него есть методы для установки режима вывода (вход, выход и т. д.) и методы для получения и установки логического уровня. Аналоговое управление см. в классе ADC.

Пример использования

from machine import Pin

# инициализирует `P9` в режиме gpio и делает вывод

p_out = Pin(‘P9‘, mode=Pin.OUT)

p_out.value(1)

p_out.value(0)

p_out.toggle()

p_out(True)

# делает `P10` входом с подтягиванием

p_in = Pin(‘P10‘, mode=Pin.IN, pull=Pin.PULL_UP)

p_in() # получает значение, 0 или 1

Конструкторы

class machine.Pin(id, …)

Создает новый объект Pin, связанный с идентификатором строки. Если даны дополнительные аргументы, они используются для инициализации. Подробнее: pin.init ()

from machine import Pin

p = Pin(‘P10‘, mode=Pin.OUT, pull=None, alt=-1)

Методы

pin.init (mode, pull, *, alt)

Инициализация:

 

• mode может быть одним из:
  • Pin.IN - входной контакт.
  • Pin.OUT - выходной контакт в двухтактном режиме.
  • Pin.OPEN_DRAIN - входной или выходной контакт в режиме с открытым стоком.
• pull может быть одним из:
  • None - нет подтягивающего резистора.
  • Pin.PULL_UP – подтягивающий резистор включен.
  • Pin.PULL_DOWN – стягивающий резистор включен.
• *
  • Значение Pin: 0 или 1
• alt - идентификатор альтернативной функции.

Возвращает: None.

pin.id ()

Получает  идентификатор Pin

pin.value([value])

Получает или устанавливает цифровой логический уровень вывода:

• Без аргументов возвращает 0 или 1 в зависимости от логического уровня.
• При заданном значении установите логический уровень вывода. Значение может быть любым, которое преобразуется в логическое. Если он принимает значение «true», вывод устанавливается на высокий уровень, в противном случае он устанавливается на низкий уровень.

pin([value])

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

Пример:

from machine import Pin

pin = Pin(‘P12‘, mode=Pin.IN, pull=Pin.PULL_UP)

pin()  # быстрый метод для получения значения

Изучите pin.value () для более подробной информации.

pin.toggle()

Переключает значение вывода.

pin.mode([mode])

Получает или устанавливает режим вывода.

pin.pull([pull])

Получает или устанавливает тягу вывода.

pin.hold([hold])

Получает или устанавливает удержание вывода. Вы можете применить удержание, передав True (или очистив его, передав False). Когда вывод удерживается, его значение нельзя изменить с помощью Pin.value () или Pin.toggle (), пока удержание не будет снято. Эта функция может быть использована для сохранения состояния вывода в случае сброса ядра и системы, вызванных тайм-аутом таймера или событиями глубокого сна. Только вывода в домене питания RTC могут сохранять свое значение в режиме глубокого сна или сброса.

Это: P2, P3, P4, P6, P8, P9, P10, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23

pin.callback(trigger, handler=None, arg=None)

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

• trigger - это тип события, которое запускает обратный вызов. Возможные значения:
  • Pin.IRQ_FALLING прерывание по падающему фронту.
  • Pin.IRQ_RISING прерывание по нарастающему фронту.
  • Pin.IRQ_LOW_LEVEL прерывание на низком уровне.
  • Pin.IRQ_HIGH_LEVEL прерывание на высоком уровне.

Значения могут быть изменены, например trigger=Pin.IRQ_FALLING | Pin.IRQ_RISING

• handler - это функция, которая вызывается при возникновении события. Эта функция получает один аргумент. Установите handler в None, чтобы отключить его.
• arg является необязательным аргументом для передачи колбэка. Если оставить его пустым или установить None, функция получит объект вывода, который его активировал.

Пример:

from machine import Pin

def pin_handler(arg):

    print("got an interrupt in pin %s" % (arg.id()))

p_in = Pin(‘P10‘, mode=Pin.IN, pull=Pin.PULL_UP)

p_in.callback(Pin.IRQ_FALLING | Pin.IRQ_RISING, pin_handler)

Дополнительную информацию о том, как продукты Pycom обрабатывают прерывания, смотрите здесь.

Атрибуты

class pin.exp_board

Содержит все объекты Pin, поддерживаемые платой расширения. Примеры:

Pin.exp_board.G16

led = Pin(Pin.exp_board.G16, mode=Pin.OUT)

Pin.exp_board.G16.id()

 

class pin.module

Содержит все объекты Pin, поддерживаемые модулем. Примеры:

Pin.module.P9

led = Pin(Pin.module.P9, mode=Pin.OUT)

Pin.module.P9.id()

Константы

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

• Выбор режима вывода: Pin.IN, Pin.OUT, Pin.OPEN_DRAIN
• Включает подтягивающее или понижающее сопротивление: Pin.PULL_UP, Pin.PULL_DOWN

PWM

Класс ШИМ - широтно-импульсная модуляция

Пример использования

from machine import PWM

pwm = PWM(0, frequency=5000)  # использует таймер ШИМ 0 с частотой 5 кГц

# создает канал ШИМ на выводе P12 с коэффициентом заполнения 50%

pwm_c = pwm.channel(0, pin=‘P12‘, duty_cycle=0.5)

pwm_c.duty_cycle(0.3) # изменяет рабочий цикл до 30%

Конструкторы

class machine.PWM(timer, frequency)

Создает объект ШИМ. Настраивает таймер на колебания на указанной частоте. тайм timer ер - целое число от 0 до 3. frequency - целое число от 1 Гц до 78 кГц (это значение может измениться в будущих обновлениях).

Методы

pwm.channel(id, pin * , duty_cycle=0.5)

Подключает канал ШИМ к контакту, установив начальный рабочий цикл. id - это целое число от 0 до 7. pin - строковый аргумент. duty_cycle - аргумент с плавающей запятой только для ключевых слов, значения которого находятся в диапазоне от 0 до 1. Возвращает экземпляр PWMChannel.

class PWMChannel — PWM channel

Методы

pwmchannel.duty_cycle(value)

Устанавливает рабочий цикл для канала ШИМ. value является аргументом с плавающей запятой, значения которого находятся в диапазоне от 0 до 1.

RTC

RTC используется для отслеживания даты и времени.

Пример использования

from machine import RTC

rtc = RTC()

rtc.init((2014, 5, 1, 4, 13, 0, 0, 0))

print(rtc.now())

Конструкторы

class machine.RTC(id=0, …)

Создаёт объект RTC. Смотрит init для параметров инициализации.

# ID RTC может быть установлен, если есть множественное подключение. По умолчанию id = 0.

rtc = RTC (id = 0)

Методы

rtc.init(datetime=None, source=RTC.INTERNAL_RC)

Инициализируйте RTC. Аргументы:

• datetime при прохождении устанавливает текущее время. Это кортеж в форме: (year, month, day[, hour[, minute[, second[, microsecond[, tzinfo]]]]])
• source выбирает генератор, который управляет RTC. Возможные варианты: RTC.INTERNAL_RC и RTC.XTAL_32KHZ

Например:

# 2 февраля 2017 года в 10:30 (TZ 0)

rtc.init ((2017, 2, 28, 10, 30, 0, 0, 0))

tzinfo этим методом игнорируется. Используйте time.timezone для достижения аналогичных результатов.

rtc.now()

Получает текущий кортеж datetime:

# возвращает кортеж datetime

rtc.now ()

 

rtc.ntp_sync(server, * , update_period=3600)

Настраивает автоматическую выборку и обновляет время, используя NTP (SNTP).

• server - это URL-адрес NTP-сервера. Может быть установлен на None, чтобы отключить периодические обновления.
• update_period - количество секунд между обновлениями. Самый короткий период - 15 секунд.

Может использоваться как:

rtc.ntp_sync("pool.ntp.org")

# это пример. Вы можете выбрать более конкретный сервер в соответствии с вашим географическим положением

 

rtc.synced()

Возвращает True, если последний ntp_sync был завершен, иначе False:

rtc.synced ()

Константы

Источник синхронизации: RTC.INTERNAL_RC, RTC.XTAL_32KHZ

SPI

SPI - это последовательный протокол, который управляется мастером. На физическом уровне есть 3 линии: SCK, MOSI, MISO.

Изучите модель использования I2C; SPI очень похож. Основным отличием являются параметры для инициализации шины SPI:

from machine import SPI

spi = SPI(0, mode=SPI.MASTER, baudrate=1000000, polarity=0, phase=0, firstbit=SPI.MSB)

Единственным обязательным параметром является режим: должен быть SPI.MASTER. Полярность может быть 0 или 1, и это уровень, на котором находится линия бездействия. Фаза может быть 0 или 1 для выборки данных на первом или втором фронте тактового сигнала соответственно.

Пример использования

from machine import SPI

# настроить SPI master @ 2MHz

# используются выводы SPI по умолчанию для CLK, MOSI и MISO (`` P10``, `` P11`` и `` P14``)

spi = SPI(0, mode=SPI.MASTER, baudrate=2000000, polarity=0, phase=0)

spi.write(bytes([0x01, 0x02, 0x03, 0x04, 0x05])) # отправить 5 байтов на шину

spi.read (5) # получить 5 байтов в шине

rbuf = bytearray(5)

spi.write_readinto(bytes([0x01, 0x02, 0x03, 0x04, 0x05]), rbuf) # отправить 5 байт

Пример использования с использованием выводов не по умолчанию

from machine import SPI

# настроить SPI master @ 2MHz

# при этом используются выводы по умолчанию для SPI для CLK, MOSI и MISO (`` P19``, `` P20`` и `` P21``)

spi = SPI(0, mode=SPI.MASTER, baudrate=2000000, polarity=0, phase=0, pins=(‘P19‘,‘P20‘,‘P21‘))

spi.write(bytes([0x01, 0x02, 0x03, 0x04, 0x05])) # отправить 5 байтов на шину

spi.read(5) # получить 5 байтов в шине

rbuf = bytearray(5)

spi.write_readinto(bytes([0x01, 0x02, 0x03, 0x04, 0x05]), rbuf) # отправить 5 байт

Конструкторы

class machine.SPI(id, …)

Строит объект SPI на заданной шине. id может быть только 0. Объект SPI создается без каких-либо дополнительных параметров, но не инициализируется (он имеет настройки с последней инициализации шины, если таковые есть). Если заданы дополнительные аргументы, шина инициализируется. Смотрите init для параметров инициализации.

Методы

spi.init(mode, baudrate=1000000, * , polarity=0, phase=0, bits=8, firstbit=SPI.MSB, pins=(CLK, MOSI, MISO))

Инициализирует шину SPI с заданными параметрами:

• mode должен быть SPI.MASTER.
• baudrate - это тактовая частота SCK.
• polarity может быть 0 или 1, и это уровень, на котором находится линия холостого хода.
• phase может быть 0 или 1 для выборки данных на первом или втором фронте тактового сигнала соответственно.
• bits - ширина каждой передачи, допустимые значения 8, 16 и 32.
• firstbit может быть SPI.MSB или SPI.LSB.
• pins - это дополнительный кортеж с контактами, которые назначаются шине SPI. Если аргумент pins не указан, будут выбраны контакты по умолчанию (P10 как CLK, P11 как MOSI и P14 как MISO). Если контакты переданы как None, то назначения контактов не будет.

spi.deinit ()

Выключает шину SPI.

spi.write(buf)

Записывает данные, содержащиеся в buf. Возвращает количество записанных байтов.

spi.read (nbytes, *, write = 0x00)

Считывает nbytes во время записи данных, указанных write. Возвращает прочитанные байты.

spi.readinto(buf, * , write=0x00)

Считывает в буфер, указанный в buf, во время записи данных, указанных в записи. Возвращает количество прочитанных байтов.

spi.write_readinto(write_buf, read_buf)

Пишет из write_buf и читает в read_buf. Оба буфера должны иметь одинаковую длину. Возвращает количество записанных байтов

Константы

• Для инициализации шины SPI мастеру: SPI.MASTER
• Установите первый бит самым значимым: SPI.MSB
• Установите первый бит наименее значимым: SPI.LSB

УАПП (UART)

Универсальный асинхронный приёмопередатчик (UART) реализует стандартный протокол дуплексной последовательной связи UART/USART. На физическом уровне он состоит из двух строк: RXD и TXD. Единицей связи является символ (не путать со строковым символом), который может иметь ширину 5, 6, 7 или 8 бит.

Объекты UART могут быть созданы и инициализированы с помощью:

from machine import UART

uart = UART(1, 9600)                         # инициализация с заданной скоростью передачи данных

uart.init(9600, bits=8, parity=None, stop=1) # инициализация с заданными параметрами

Биты могут быть 5, 6, 7, 8. Четность может быть None, UART.EVEN или UART.ODD. Стоп может быть 1, 1,5 или 2.

Объект UART действует как потоковый объект, поэтому чтение и запись выполняются с использованием стандартных методов потока:

uart.read(10) # читает 10 символов, возвращает объект байтов

uart.readall() # читает все доступные символы

uart.readline() # читает строку

uart.readinto(buf) # читает и сохраняет в заданный буфер

uart.write(‘abc‘) # пишет 3 символа

Чтобы проверить, есть ли что-нибудь для чтения, используйте:

uart.any() # возвращает количество символов, доступных для чтения

Пример использования

from machine import UART

 # при этом используются выводы UART_1 для TXD и RXD по умолчанию (`` P3`` и `` P4``)

uart = UART(1, baudrate=9600)

uart.write(‘hello‘)

uart.read(5) # чтение до 5 байтов

Пример с использованием выводов не по умолчанию (только TXD / RXD)

from machine import UART

 # при этом используются нестандартные выводы UART_1 для TXD и RXD (`` P20`` и `` P21``)

uart = UART(1, baudrate=9600, pins=(‘P20‘,‘P21‘))

uart.write(‘hello‘)

uart.read(5)  # чтение до 5 байтов

Пример с использованием выводов не по умолчанию (TXD / RXD и управление потоком)

from machine import UART 

# при этом используются выводы UART_1, отличные от заданных по умолчанию, для TXD, RXD, RTS и CTS (`` P20``, `` P21``, `` P22`` и `` P23``)

uart = UART(1, baudrate=9600, pins=(‘P20‘, ‘P21‘, ‘P22‘, ‘P23‘))

uart.write(‘hello‘)

uart.read(5)  # чтение до 5 байтов

Конструкторы

class machine.UART(bus, …)

Строит объект UART на заданной шине. Шина может быть 0, 1 или 2. Если шина не задана, она будет выбрана по умолчанию (0) или выбор будет сделан на основе заданных выводов.

На GPy / FiPy UART2 недоступен, поскольку он используется для связи с сотовой радиосвязью.

Методы

uart.init(baudrate=9600, bits=8, parity=None, stop=1, * , timeout_chars=2, pins=(TXD, RXD, RTS, CTS))

Инициализируйте шину UART с заданными параметрами:

• baudrate - это тактовая частота.
• bits - это количество бит на символ. Может быть 5, 6, 7 или 8.
• parity - это паритет, None, UART.EVEN или UART.ODD.
• stop - это количество стоп-битов, 1 или 2.
• timeout_chars - Rx тайм-аут, определенный в количестве символов. Приведенное здесь значение будет умножено на время, необходимое для передачи символов с настроенной скоростью передачи данных.
• pins - это список из 4 или 2 элементов, обозначающий контакты TXD, RXD, RTS и CTS (в этом порядке). Любой из выводов может быть None, если вы хотите, чтобы UART работал с ограниченными функциональными возможностями. Если указан вывод RTS, то должен быть указан и вывод RX. То же относится и к CTS. Если выводы не заданы, то используется набор по умолчанию для TXD (P1) и RXD (P0), и аппаратное управление потоком будет отключено. Если pins=None, то назначения выводов не будет.

uart.deinit()

Выключает шину UART.

uart.any()

Возвращает количество символов, доступных для чтения.

uart.read([nbytes])

Читает символы. Если указано nbytes, то следует прочитать не более этого количества байтов. Возвращаемое значение: объект байтов, содержащий прочитанные байты. Возвращает None по истечении времени ожидания.

uart.readall()

Читает как можно больше данных. Возвращаемое значение: объект байтов или None по истечении времени ожидания.

uart.readinto(buf[, nbytes])

Читает байты в buf. Если указано nbytes, то следует прочитать не более этого количества байтов. В противном случае читает не более len(buf) байтов. Возвращаемое значение: количество байтов, прочитанных и сохраненных в buf или None по истечении времени ожидания.

uart.readline ()

Читает строку, заканчивающуюся символом новой строки. Если такая строка существует, немедленно возврат происходит. Если время истекло, то все доступные данные возвращаются независимо от того, существует ли новая строка. Возвращаемое значение: прочитанная строка или None по истечении времени ожидания.

uart.write(buf)

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

uart.sendbreak()

Отправляет условие брейка на шину. Это приводит к низкому уровню на шине в течение 13 бит. Возвращаемое значение: None.

uart.wait_tx_done(timeout_ms)

Выжидает максимально timeout_ms до завершения последней транзакции Tx. Возвращает True, если все данные были отправлены, и в буфере TX нет данных, в противном случае возвращает False.

Константы

• Типы четности (вместе с None): UART.EVEN, UART.ODD
• Источники триггера IRQ: UART.RX_ANY

WDT

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

Пример использования

from machine import WDT

wdt = WDT(timeout=2000)  # включает с таймаутом в 2 секунды

wdt.feed()

Конструкторы

class machine.WDT(id=0, timeout)

Создаёт объект WDT и запускает его. Идентификатор может быть только 0. См. init метод для параметров инициализации.

Методы

wdt.init(timeout)

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

wdt.feed()

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

Таймер

Класс Timer - измерение времени и установка будильников

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

Эти два понятия сгруппированы в два разных подкласса:

• Chrono: используется для измерения промежутков времени
• Alarm: используется для прерывания по истечении определенного интервала.

Вы можете создать столько объектов, сколько вам нужно.

Конструкторы

class Timer.Chrono()

Создаёт хронометрический объект

class Timer.Alarm(handler=None, s, * , ms, us, arg=None, periodic=False)

Создаёт объект будильника.

• handler: будет вызван по истечении интервала. Если установлено значение None, будильник будет отключен после создания.
• arg: необязательный аргумент может быть передан в функцию обработки обратного вызова. Если значение не указано, функция получит объект, вызвавший будильник.
• s, ms, us: интервал может быть указан в секундах (число с плавающей запятой), миллисекундах (целое число) или микросекундах (целое число). Только один интервал может быть указан за один раз.
• periodic: для многократного срабатывания будильника можно установить для этого параметра значение True.

Методы

Timer.sleep_us()

Задержка для заданного числа микросекунд должна быть положительной или равной нулю (для скорости условие необязательно). Внутренне она использует тот же таймер, что и другие элементы этого класса. Это компенсирует «накладные расходы» на вызовы, поэтому, например, 100мкс должно быть действительно близко к 100мкс. Для случаев, превышающих 10000 мкс, он освобождает GIL для запуска других потоков, поэтому точность не гарантируется для задержек, превышающих это значение.

class Chrono

Может использоваться для измерения промежутков времени.

Методы

chrono.start ()

Запускает хронометр.

chrono.stop ()

Останавливаки хронометр.

chrono.reset ()

Сбрасывает отсчет времени до 0.

chrono.read ()

Получает истекшее время в секундах.

chrono.read_ms ()

Получает истекшее время в миллисекундах.

chrono.read_us ()

Получает истекшее время в микросекундах.

Пример:

from machine import Timer

import time

chrono = Timer.Chrono()

chrono.start()

time.sleep(1.25)  # имитация первого круга заняла 1,25 секунды

lap = chrono.read() # чтение прошедшего времени без остановки

time.sleep(1.5)

chrono.stop()

total = chrono.read()

print()

print(" the racer took %f seconds to finish the race" % total)

print("  %f seconds in the first lap" % lap)

print("  %f seconds in the last lap" % (total - lap))

class Alarm – get interrupted after a specific interval

class Alarm

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

Методы

alarm.callback(handler, * , arg=None)

Укажите обработчик обратного вызова для тревоги. Если установлено значение None, будильник будет отключен. Необязательный аргумент arg может быть передан в функцию обработчика обратного вызова. Если значение не указано, функция получит объект, вызвавший тревогу.

alarm.cancel ()

Отключает будильник.

Пример:

class Clock:

    def __init__(self):

        self.seconds = 0

        self.__alarm = Timer.Alarm(self._seconds_handler, 1, periodic=True)

    def _seconds_handler(self, alarm):

        self.seconds += 1

        print("%02d seconds have passed" % self.seconds)

        if self.seconds == 10:

            alarm.cancel() №перестать считать через 10 секунд

clock = Clock()

Для получения дополнительной информации о том, как продукты Pycom обрабатывают прерывания, см. примечания.

SD

Класс SD-карт позволяет настраивать и включать модуль карты памяти вашего модуля Pycom и автоматически монтировать его как /sd как часть файловой системы. Существует одна комбинация выводов, которую можно использовать для SD-карты, и текущая реализация работает только в 1-битном режиме. Выходные соединения следующие:

P8: DAT0, P23: SCLK и P4: CMD (внешние подтягивающие резисторы не нужны)

Если у вас есть одна из плат расширения Pycom, просто вставьте карту в гнездо micro SD и запустите ваш скрипт. Убедитесь, что ваша SD-карта отформатирована как FAT16 или FAT32.

Пример использования:

import os

sd = SD()

os.mount(sd, ‘/sd‘)

# проверка содержимого

os.listdir(‘/sd‘)

# попробуйте некоторые стандартные файловые операции

f = open(‘/sd/test.txt‘, ‘w‘)

f.write(‘Testing SD card write operations‘)

f.close()

f = open(‘/sd/test.txt‘, ‘r‘)

f.readall()

f.close()

Конструкторы

class machine.SD(id, …)

Создайте объект SD-карты. Смотрите sd.init () для параметров при инициализации.

Методы

sd.init(id=0)

Включает SD-карту.

sd.deinit()

Отключает SD-карту.

Обратите внимание, что библиотека SD-карт в настоящее время поддерживает SD-карты в формате FAT16/32 объемом до 32 ГБ. Будущие обновления прошивки увеличат совместимость с дополнительными форматами и размерами.

CAN

Класс CAN поддерживает полную спецификацию CAN 2.0 со стандартными и расширенными фреймами, а также приемочную фильтрацию.

ESP32 имеет встроенный CAN-контроллер, но трансивер должен быть добавлен извне. Рекомендуемое устройство - SN65HVD230.

Пример использования

from machine import CAN

can = CAN(mode=CAN.NORMAL, baudrate=500000, pins=(‘P22‘, ‘P23‘))

can.send(id=12, data=bytes([1, 2, 3, 4, 5, 6, 7, 8]))

can.recv()

Конструкторы

class machine.CAN(bus=0, …)

Создаёт объект CAN. Для параметров инициализации:

# доступно только 1 периферийное устройство CAN, поэтому шина всегда должна быть 0

can = CAN(0, mode=CAN.NORMAL, baudrate=500000, pins=(‘P22‘, ‘P23‘)) # порядок выводов: Tx, Rx

Методы

can.init(mode=CAN.NORMAL, baudrate=500000, *, frame_format=CAN.FORMAT_STD, rx_queue_len=128, pins=(‘P22’, ‘P23’))

Инициализирует контроллер CAN. Аргументы:

• mode может принимать либо CAN.NORMAL или CAN.SILENT. Тихий режим полезен для того, чтобы исследовать шину
• baudrate устанавливает скорость шины. Допустимые значения от 1 до 1000000.
• frame_format определяет формат, который будет принят получателем. Полезно для фильтрации по длине идентификатора. Может быть CAN.FORMAT_STD, CAN.FORMAT_EXT или CAN.FORMAT_BOTH. Если выбран CAN.FORMAT_STD, расширенные фреймы не будут получены, и наоборот.
• rx_queue_len определяет количество сообщений, которое может быть поставлено в очередь получателем. Из-за того, что CAN является шиной с высоким трафиком, рекомендуются большие значения (>= 128), в противном случае сообщения будут отбрасываться, особенно если фильтрация не применяется.
• pins выбирает контакты Tx и Rx (в этом порядке).

can.deinit()

Отключает шину CAN.

can.send(id, * , data=None, rtr=False, extended=False)

Отправляет фрейм CAN на шину

• id - это идентификатор сообщения.
• data может занимать до 8 байт. Должно быть пустым, если отправляемое сообщение является удаленным запросом (rtr = True).
• rtr устанавливает его в false, чтобы отправить удаленный запрос.
• extnted указывает, должна ли ширина идентификатора сообщения быть 11-битной (стандартной) или 29-битной (расширенной).

Может использоваться как:

can.send(id=0x0020, data=bytes([0x01, 0x02, 0x03, 0x04, 0x05]), extended=True) # отправляет 5 байтов с расширенным идентификатором

can.send(id=0x010, data=bytes([0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08]))# отправляет 8 байтов со стандартным идентификатором

can.send (id = 0x012, rtr = True) # отправляет удаленный запрос на сообщение id = 0x12

 

can.recv(timeout=0)

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

(id, data, rtr, extended)

>>> can.recv()

(id=0x012, data=b‘123‘, rtr=False, extended=False)

 

can.soft_filter(mode, filter_list)

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

Есть 3 возможных режима фильтра:

• CAN.FILTER_LIST позволяет передать список идентификаторов, которые должны быть приняты.
• CAN.FILTER_RANGE позволяет передавать список или кортеж диапазонов ID, которые должны быть приняты.
• CAN.FILTER_MASK позволяет передать список кортежей вида: (filter, mask)

С программными фильтрами все сообщения в шине принимаются контроллером CAN, но только соответствующие сообщения передаются в очередь RX. Это означает, что очередь не будет заполнена несоответствующими сообщениями, но издержки прерывания останутся как обычно. Фильтр может содержать до 32 элементов.

Например:

can.soft_filter(CAN.FILTER_LIST, [0x100, 0x200, 0x300, 0x400])# принимает идентификаторы только от 0x100, 0x200, 0x300 и 0x400

can.soft_filter(CAN.FILTER_RANGE, [(0x001, 0x010), (0x020, 0x030), (0x040, 0x050)])# принимает идентификаторы только от 0x001 до 0x010, от 0x020 до 0x030 и от 0x040 до 0x050.

can.soft_filter(CAN.FILTER_MASK, [(0x100, 0x7FF), (0x200, 0x7FC)]) # классический метод Filter и Mask.

can.soft_filter(None)# отключает программные фильтры, все сообщения принимаются

 

can.callback(trigger, handler=None, arg=None)

Установите обратный вызов, который будет запускаться при наличии любого из этих 3 событий:

• триггер - это тип события, которое запускает обратный вызов. Возможные значения:
  • CAN.RX_FRAME прерывание всякий раз, когда принимается новый фрейм.
  • CAN.RX_FIFO_NOT_EMPTY прерывание, когда фрейм получен на пустом FIFO.
  • CAN.RX_FIFO_OVERRUN прерывание, когда сообщение получено и FIFO заполнен.

Значения могут быть изменены неодновременно, например trigger=CAN.RX_FRAME | CAN.RX_FIFO_OVERRUN 

• Обработчик - это функция, которая вызывается при возникновении события. Эта функция получит один аргумент. Установите для обработчика значение Нет, чтобы отключить обратный вызов.
• Аргумент является необязательным для передачи обратного вызова. Если оставить его пустым или установить None, функция получит объект CAN, который ее вызвал.

Это можно использовать так:

from machine import CAN

can = CAN(mode=CAN.NORMAL, baudrate=500000, pins=(‘P22‘, ‘P23‘))

def can_cb(can_o):

    print(‘CAN Rx:‘, can_o.recv())

can.callback(handler=can_cb, trigger=CAN.RX_FRAME)

 

can.events()

Этот метод возвращает значение с набором битов (если есть), указывая события, которые произошли на шине. Обратите внимание, что при вызове этой функции внутренний реестр событий очищается автоматически, поэтому при его немедленном повторном вызове, скорее всего, будет возвращено значение 0.

Константы

CAN.NORMAL, CAN.SILENT, CAN.FORMAT_STD, CAN.FORMAT_EXT, CAN.FORMAT_BOTH, CAN.RX_FRAME, CAN.RX_FIFO_NOT_EMPTY, CAN.RX_FIFO_OVERRUN, CAN.FILTER_LIST, CAN.FILTER_RANGE, CAN.FILTER_MASK