drivers: Remove drivers that are now in micropython-lib.
Signed-off-by: Jim Mussared <jim.mussared@gmail.com>
This commit is contained in:
Jim Mussared
parent
d84c6ef0e8
commit
24678fe452
@ -1,2 +1,2 @@
|
|||||||
This directory contains drivers for specific hardware. The drivers are
|
This directory contains C drivers for specific hardware. The drivers are
|
||||||
intended to work across multiple ports.
|
intended to work across multiple ports.
|
||||||
|
|||||||
@ -1 +0,0 @@
|
|||||||
module("wm8960.py", opt=3)
|
|
||||||
@ -1,753 +0,0 @@
|
|||||||
#
|
|
||||||
# Driver class for the WM8960 Codec to be used e.g. with MIMXRT_1xxx Boards.
|
|
||||||
# Derived from the NXP SDK drivers.
|
|
||||||
#
|
|
||||||
# Copyright (c) 2015, Freescale Semiconductor, Inc., (C-Code)
|
|
||||||
# Copyright 2016-2021 NXP, (C-Code)
|
|
||||||
# All rights reserved.
|
|
||||||
#
|
|
||||||
# Translated to MicroPython by Robert Hammelrath, 2022
|
|
||||||
#
|
|
||||||
# SPDX-License-Identifier: BSD-3-Clause
|
|
||||||
#
|
|
||||||
|
|
||||||
import array
|
|
||||||
from micropython import const
|
|
||||||
|
|
||||||
# Define the register addresses of WM8960.
|
|
||||||
_LINVOL = const(0x0)
|
|
||||||
_RINVOL = const(0x1)
|
|
||||||
_LOUT1 = const(0x2)
|
|
||||||
_ROUT1 = const(0x3)
|
|
||||||
_CLOCK1 = const(0x4)
|
|
||||||
_DACCTL1 = const(0x5)
|
|
||||||
_DACCTL2 = const(0x6)
|
|
||||||
_IFACE1 = const(0x7)
|
|
||||||
_CLOCK2 = const(0x8)
|
|
||||||
_IFACE2 = const(0x9)
|
|
||||||
_LDAC = const(0xA)
|
|
||||||
_RDAC = const(0xB)
|
|
||||||
_RESET = const(0xF)
|
|
||||||
_3D = const(0x10)
|
|
||||||
_ALC1 = const(0x11)
|
|
||||||
_ALC2 = const(0x12)
|
|
||||||
_ALC3 = const(0x13)
|
|
||||||
_NOISEG = const(0x14)
|
|
||||||
_LADC = const(0x15)
|
|
||||||
_RADC = const(0x16)
|
|
||||||
_ADDCTL1 = const(0x17)
|
|
||||||
# Register _ADDCTL2 = const(0x18)
|
|
||||||
_POWER1 = const(0x19)
|
|
||||||
_POWER2 = const(0x1A)
|
|
||||||
_ADDCTL3 = const(0x1B)
|
|
||||||
# Register _APOP1 = const(0x1C)
|
|
||||||
# Register _APOP2 = const(0x1D)
|
|
||||||
_LINPATH = const(0x20)
|
|
||||||
_RINPATH = const(0x21)
|
|
||||||
_LOUTMIX = const(0x22)
|
|
||||||
_ROUTMIX = const(0x25)
|
|
||||||
_MONOMIX1 = const(0x26)
|
|
||||||
_MONOMIX2 = const(0x27)
|
|
||||||
_LOUT2 = const(0x28)
|
|
||||||
_ROUT2 = const(0x29)
|
|
||||||
_MONO = const(0x2A)
|
|
||||||
_INBMIX1 = const(0x2B)
|
|
||||||
_INBMIX2 = const(0x2C)
|
|
||||||
_BYPASS1 = const(0x2D)
|
|
||||||
_BYPASS2 = const(0x2E)
|
|
||||||
_POWER3 = const(0x2F)
|
|
||||||
_ADDCTL4 = const(0x30)
|
|
||||||
_CLASSD1 = const(0x31)
|
|
||||||
# Register _CLASSD3 = const(0x33)
|
|
||||||
_PLL1 = const(0x34)
|
|
||||||
_PLL2 = const(0x35)
|
|
||||||
_PLL3 = const(0x36)
|
|
||||||
_PLL4 = const(0x37)
|
|
||||||
|
|
||||||
# WM8960 PLLN range */
|
|
||||||
_PLL_N_MIN_VALUE = const(6)
|
|
||||||
_PLL_N_MAX_VALUE = const(12)
|
|
||||||
|
|
||||||
# WM8960 CLOCK2 bits
|
|
||||||
_CLOCK2_BCLK_DIV_MASK = const(0x0F)
|
|
||||||
_CLOCK2_DCLK_DIV_MASK = const(0x1C0)
|
|
||||||
_CLOCK2_DCLK_DIV_SHIFT = const(0x06)
|
|
||||||
|
|
||||||
# Register _IFACE1
|
|
||||||
_IFACE1_FORMAT_MASK = const(0x03)
|
|
||||||
_IFACE1_WL_MASK = const(0x0C)
|
|
||||||
_IFACE1_WL_SHIFT = const(0x02)
|
|
||||||
_IFACE1_LRP_MASK = const(0x10)
|
|
||||||
_IFACE1_MS_MASK = const(0x40)
|
|
||||||
_IFACE1_DLRSWAP_MASK = const(0x20)
|
|
||||||
_IFACE1_ALRSWAP_MASK = const(0x100)
|
|
||||||
|
|
||||||
# Register _POWER1
|
|
||||||
_POWER1_VREF_MASK = const(0x40)
|
|
||||||
_POWER1_VREF_SHIFT = const(0x06)
|
|
||||||
_POWER1_AINL_MASK = const(0x20)
|
|
||||||
_POWER1_AINR_MASK = const(0x10)
|
|
||||||
_POWER1_ADCL_MASK = const(0x08)
|
|
||||||
_POWER1_ADCR_MASK = const(0x0)
|
|
||||||
_POWER1_MICB_MASK = const(0x02)
|
|
||||||
_POWER1_MICB_SHIFT = const(0x01)
|
|
||||||
|
|
||||||
# Register _POWER2
|
|
||||||
_POWER2_DACL_MASK = const(0x100)
|
|
||||||
_POWER2_DACR_MASK = const(0x80)
|
|
||||||
_POWER2_LOUT1_MASK = const(0x40)
|
|
||||||
_POWER2_ROUT1_MASK = const(0x20)
|
|
||||||
_POWER2_SPKL_MASK = const(0x10)
|
|
||||||
_POWER2_SPKR_MASK = const(0x08)
|
|
||||||
_POWER3_LMIC_MASK = const(0x20)
|
|
||||||
_POWER3_RMIC_MASK = const(0x10)
|
|
||||||
_POWER3_LOMIX_MASK = const(0x08)
|
|
||||||
_POWER3_ROMIX_MASK = const(0x04)
|
|
||||||
|
|
||||||
# Register _DACCTL1 .. 3
|
|
||||||
_DACCTL1_MONOMIX_MASK = const(0x10)
|
|
||||||
_DACCTL1_MONOMIX_SHIFT = const(0x4)
|
|
||||||
_DACCTL1_DACMU_MASK = const(0x08)
|
|
||||||
_DACCTL1_DEEM_MASK = const(0x06)
|
|
||||||
_DACCTL1_DEEM_SHIFT = const(0x01)
|
|
||||||
_DACCTL2_DACSMM_MASK = const(0x08)
|
|
||||||
_DACCTL2_DACMR_MASK = const(0x04)
|
|
||||||
_DACCTL3_ALCSR_MASK = const(0x07)
|
|
||||||
|
|
||||||
# _WM8060_ALC1 .. 3
|
|
||||||
_ALC_CHANNEL_MASK = const(0x180)
|
|
||||||
_ALC_CHANNEL_SHIFT = const(0x7)
|
|
||||||
_ALC_MODE_MASK = const(0x100)
|
|
||||||
_ALC_MODE_SHIFT = const(0x8)
|
|
||||||
_ALC_GAIN_MASK = const(0x70)
|
|
||||||
_ALC_GAIN_SHIFT = const(0x4)
|
|
||||||
_ALC_TARGET_MASK = const(0x0F)
|
|
||||||
_ALC_ATTACK_MASK = const(0x0F)
|
|
||||||
_ALC_DECAY_MASK = const(0xF0)
|
|
||||||
_ALC_DECAY_SHIFT = const(4)
|
|
||||||
_ALC_HOLD_MASK = const(0xF)
|
|
||||||
|
|
||||||
# Register _NOISEG
|
|
||||||
_NOISEG_LEVEL_SHIFT = const(3)
|
|
||||||
|
|
||||||
_I2C_ADDR = const(0x1A)
|
|
||||||
|
|
||||||
# WM8960 maximum volume values
|
|
||||||
_MAX_VOLUME_ADC = const(0xFF)
|
|
||||||
_MAX_VOLUME_DAC = const(0xFF)
|
|
||||||
_MAX_VOLUME_HEADPHONE = const(0x7F)
|
|
||||||
_MAX_VOLUME_LINEIN = const(0x3F)
|
|
||||||
_MAX_VOLUME_SPEAKER = const(0x7F)
|
|
||||||
|
|
||||||
# Config symbol names
|
|
||||||
# Modules
|
|
||||||
MODULE_ADC = const(0) # ADC module in WM8960
|
|
||||||
MODULE_DAC = const(1) # DAC module in WM8960
|
|
||||||
MODULE_VREF = const(2) # VREF module
|
|
||||||
MODULE_HEADPHONE = const(3) # Headphone
|
|
||||||
MODULE_MIC_BIAS = const(4) # Mic bias
|
|
||||||
MODULE_MIC = const(5) # Input Mic
|
|
||||||
MODULE_LINE_IN = const(6) # Analog in PGA
|
|
||||||
MODULE_LINE_OUT = const(7) # Line out module
|
|
||||||
MODULE_SPEAKER = const(8) # Speaker module
|
|
||||||
MODULE_OMIX = const(9) # Output mixer
|
|
||||||
MODULE_MONO_OUT = const(10) # Mono mix
|
|
||||||
|
|
||||||
# Route
|
|
||||||
ROUTE_BYPASS = const(0) # LINEIN->Headphone.
|
|
||||||
ROUTE_PLAYBACK = const(1) # I2SIN->DAC->Headphone.
|
|
||||||
ROUTE_PLAYBACK_RECORD = const(2) # I2SIN->DAC->Headphone, LINEIN->ADC->I2SOUT.
|
|
||||||
ROUTE_RECORD = const(5) # LINEIN->ADC->I2SOUT.
|
|
||||||
|
|
||||||
# Input
|
|
||||||
INPUT_CLOSED = const(0) # Input device is closed
|
|
||||||
INPUT_MIC1 = const(1) # Input as single ended mic, only use L/RINPUT1
|
|
||||||
INPUT_MIC2 = const(2) # Input as diff. mic, use L/RINPUT1 and L/RINPUT2
|
|
||||||
INPUT_MIC3 = const(3) # Input as diff. mic, use L/RINPUT1 and L/RINPUT3
|
|
||||||
INPUT_LINE2 = const(4) # Input as line input, only use L/RINPUT2
|
|
||||||
INPUT_LINE3 = const(5) # Input as line input, only use L/RINPUT3
|
|
||||||
|
|
||||||
# ADC sync input
|
|
||||||
SYNC_ADC = const(0) # Use ADCLRC pin for ADC sync
|
|
||||||
SYNC_DAC = const(1) # used DACLRC pin for ADC sync
|
|
||||||
|
|
||||||
# Protocol type
|
|
||||||
BUS_I2S = const(2) # I2S type
|
|
||||||
BUS_LEFT_JUSTIFIED = const(1) # Left justified mode
|
|
||||||
BUS_RIGHT_JUSTIFIED = const(0) # Right justified mode
|
|
||||||
BUS_PCMA = const(3) # PCM A mode
|
|
||||||
BUS_PCMB = const(3 | (1 << 4)) # PCM B mode
|
|
||||||
|
|
||||||
# Channel swap
|
|
||||||
SWAP_NONE = const(0)
|
|
||||||
SWAP_INPUT = const(1)
|
|
||||||
SWAP_OUTPUT = const(2)
|
|
||||||
|
|
||||||
# Mute settings
|
|
||||||
MUTE_FAST = const(0)
|
|
||||||
MUTE_SLOW = const(1)
|
|
||||||
|
|
||||||
# ALC settings
|
|
||||||
ALC_OFF = const(0)
|
|
||||||
ALC_RIGHT = const(1)
|
|
||||||
ALC_LEFT = const(2)
|
|
||||||
ALC_STEREO = const(3)
|
|
||||||
ALC_MODE = const(0) # ALC mode
|
|
||||||
ALC_LIMITER = const(1) # Limiter mode
|
|
||||||
|
|
||||||
# Clock Source
|
|
||||||
SYSCLK_MCLK = const(0) # sysclk source from external MCLK
|
|
||||||
SYSCLK_PLL = const(1) # sysclk source from internal PLL
|
|
||||||
|
|
||||||
|
|
||||||
class Regs:
|
|
||||||
# register cache of 56 register. Since registers cannot be read back, they are
|
|
||||||
# kept in the table for modification
|
|
||||||
# fmt: off
|
|
||||||
cache = array.array("H", (
|
|
||||||
0x0097, 0x0097, 0x0000, 0x0000, 0x0000, 0x0008, 0x0000,
|
|
||||||
0x000a, 0x01c0, 0x0000, 0x00ff, 0x00ff, 0x0000, 0x0000,
|
|
||||||
0x0000, 0x0000, 0x0000, 0x007b, 0x0100, 0x0032, 0x0000,
|
|
||||||
0x00c3, 0x00c3, 0x01c0, 0x0000, 0x0000, 0x0000, 0x0000,
|
|
||||||
0x0000, 0x0000, 0x0000, 0x0000, 0x0100, 0x0100, 0x0050,
|
|
||||||
0x0050, 0x0050, 0x0050, 0x0000, 0x0000, 0x0000, 0x0000,
|
|
||||||
0x0040, 0x0000, 0x0000, 0x0050, 0x0050, 0x0000, 0x0002,
|
|
||||||
0x0037, 0x004d, 0x0080, 0x0008, 0x0031, 0x0026, 0x00e9
|
|
||||||
))
|
|
||||||
# fmt: on
|
|
||||||
|
|
||||||
def __init__(self, i2c, i2c_address=_I2C_ADDR):
|
|
||||||
self.value_buffer = bytearray(2)
|
|
||||||
self.i2c = i2c
|
|
||||||
self.i2c_address = i2c_address
|
|
||||||
|
|
||||||
def __getitem__(self, reg):
|
|
||||||
return self.cache[reg]
|
|
||||||
|
|
||||||
def __setitem__(self, reg, value):
|
|
||||||
if type(reg) is tuple:
|
|
||||||
if type(value) is tuple:
|
|
||||||
self[reg[0]] = value[0]
|
|
||||||
self[reg[1]] = value[1]
|
|
||||||
else:
|
|
||||||
self[reg[0]] = value
|
|
||||||
self[reg[1]] = value
|
|
||||||
else:
|
|
||||||
if type(value) is tuple:
|
|
||||||
val = (self.cache[reg] & (~value[0] & 0xFFFF)) | value[1]
|
|
||||||
else:
|
|
||||||
val = value
|
|
||||||
self.cache[reg] = val
|
|
||||||
self.value_buffer[0] = (reg << 1) | ((val >> 8) & 0x01)
|
|
||||||
self.value_buffer[1] = val & 0xFF
|
|
||||||
self.i2c.writeto(self.i2c_address, self.value_buffer)
|
|
||||||
|
|
||||||
|
|
||||||
class WM8960:
|
|
||||||
|
|
||||||
_bit_clock_divider_table = {
|
|
||||||
2: 0,
|
|
||||||
3: 1,
|
|
||||||
4: 2,
|
|
||||||
6: 3,
|
|
||||||
8: 4,
|
|
||||||
11: 5,
|
|
||||||
12: 6,
|
|
||||||
16: 7,
|
|
||||||
22: 8,
|
|
||||||
24: 9,
|
|
||||||
32: 10,
|
|
||||||
44: 11,
|
|
||||||
48: 12,
|
|
||||||
}
|
|
||||||
|
|
||||||
_dac_divider_table = {
|
|
||||||
1.0 * 256: 0b000,
|
|
||||||
1.5 * 256: 0b001,
|
|
||||||
2 * 256: 0b010,
|
|
||||||
3 * 256: 0b011,
|
|
||||||
4 * 256: 0b100,
|
|
||||||
5.5 * 256: 0b101,
|
|
||||||
6 * 256: 0b110,
|
|
||||||
}
|
|
||||||
|
|
||||||
_audio_word_length_table = {
|
|
||||||
16: 0b00,
|
|
||||||
20: 0b01,
|
|
||||||
24: 0b10,
|
|
||||||
32: 0b11,
|
|
||||||
}
|
|
||||||
|
|
||||||
_alc_sample_rate_table = {
|
|
||||||
48000: 0,
|
|
||||||
44100: 0,
|
|
||||||
32000: 1,
|
|
||||||
24000: 2,
|
|
||||||
22050: 2,
|
|
||||||
16000: 3,
|
|
||||||
12000: 4,
|
|
||||||
11025: 4,
|
|
||||||
8000: 5,
|
|
||||||
}
|
|
||||||
|
|
||||||
_volume_config_table = {
|
|
||||||
MODULE_ADC: (_MAX_VOLUME_ADC, _LADC, 0x100),
|
|
||||||
MODULE_DAC: (_MAX_VOLUME_DAC, _LDAC, 0x100),
|
|
||||||
MODULE_HEADPHONE: (_MAX_VOLUME_HEADPHONE, _LOUT1, 0x180),
|
|
||||||
MODULE_LINE_IN: (_MAX_VOLUME_LINEIN, _LINVOL, 0x140),
|
|
||||||
MODULE_SPEAKER: (_MAX_VOLUME_SPEAKER, _LOUT2, 0x180),
|
|
||||||
}
|
|
||||||
|
|
||||||
_input_config_table = {
|
|
||||||
INPUT_CLOSED: None,
|
|
||||||
INPUT_MIC1: (0x138, 0x117),
|
|
||||||
INPUT_MIC2: (0x178, 0x117),
|
|
||||||
INPUT_MIC3: (0x1B8, 0x117),
|
|
||||||
INPUT_LINE2: (0, 0xE),
|
|
||||||
INPUT_LINE3: (0, 0x70),
|
|
||||||
}
|
|
||||||
|
|
||||||
def __init__(
|
|
||||||
self,
|
|
||||||
i2c,
|
|
||||||
sample_rate=16000,
|
|
||||||
bits=16,
|
|
||||||
swap=SWAP_NONE,
|
|
||||||
route=ROUTE_PLAYBACK_RECORD,
|
|
||||||
left_input=INPUT_MIC3,
|
|
||||||
right_input=INPUT_MIC2,
|
|
||||||
sysclk_source=SYSCLK_MCLK,
|
|
||||||
mclk_freq=None,
|
|
||||||
primary=False,
|
|
||||||
adc_sync=SYNC_DAC,
|
|
||||||
protocol=BUS_I2S,
|
|
||||||
i2c_address=_I2C_ADDR,
|
|
||||||
):
|
|
||||||
self.regs = regs = Regs(i2c, i2c_address)
|
|
||||||
self.sample_rate = sample_rate
|
|
||||||
|
|
||||||
# check parameter consistency and set the sysclk value
|
|
||||||
if sysclk_source == SYSCLK_PLL:
|
|
||||||
if sample_rate in (11025, 22050, 44100):
|
|
||||||
sysclk = 11289600
|
|
||||||
else:
|
|
||||||
sysclk = 12288000
|
|
||||||
if sysclk < sample_rate * 256:
|
|
||||||
sysclk = sample_rate * 256
|
|
||||||
if mclk_freq is None:
|
|
||||||
mclk_freq = sysclk
|
|
||||||
else: # sysclk_source == SYSCLK_MCLK
|
|
||||||
if mclk_freq is None:
|
|
||||||
mclk_freq = sample_rate * 256
|
|
||||||
sysclk = mclk_freq
|
|
||||||
|
|
||||||
regs[_RESET] = 0x00
|
|
||||||
# VMID=50K, Enable VREF, AINL, AINR, ADCL and ADCR
|
|
||||||
# I2S_IN (bit 0), I2S_OUT (bit 1), DAP (bit 4), DAC (bit 5), ADC (bit 6) are powered on
|
|
||||||
regs[_POWER1] = 0xFE
|
|
||||||
# Enable DACL, DACR, LOUT1, ROUT1, PLL down, SPKL, SPKR
|
|
||||||
regs[_POWER2] = 0x1F8
|
|
||||||
# Enable left and right channel input PGA, left and right output mixer
|
|
||||||
regs[_POWER3] = 0x3C
|
|
||||||
|
|
||||||
if adc_sync == SYNC_ADC:
|
|
||||||
# ADC and DAC use different Frame Clock Pins
|
|
||||||
regs[_IFACE2] = 0x00 # ADCLRC 0x00:Input 0x40:output.
|
|
||||||
else:
|
|
||||||
# ADC and DAC use the same Frame Clock Pin
|
|
||||||
regs[_IFACE2] = 0x40 # ADCLRC 0x00:Input 0x40:output.
|
|
||||||
self.set_data_route(route)
|
|
||||||
self.set_protocol(protocol)
|
|
||||||
|
|
||||||
if sysclk_source == SYSCLK_PLL:
|
|
||||||
self.set_internal_pll_config(mclk_freq, sysclk)
|
|
||||||
if primary:
|
|
||||||
self.set_master_clock(sysclk, sample_rate, bits)
|
|
||||||
# set master bit.
|
|
||||||
self.regs[_IFACE1] = (0, _IFACE1_MS_MASK)
|
|
||||||
|
|
||||||
self.set_speaker_clock(sysclk)
|
|
||||||
|
|
||||||
# swap channels
|
|
||||||
if swap & SWAP_INPUT:
|
|
||||||
regs[_IFACE1] = (0, _IFACE1_ALRSWAP_MASK)
|
|
||||||
if swap & SWAP_OUTPUT:
|
|
||||||
regs[_IFACE1] = (0, _IFACE1_DLRSWAP_MASK)
|
|
||||||
|
|
||||||
self.set_left_input(left_input)
|
|
||||||
self.set_right_input(right_input)
|
|
||||||
|
|
||||||
regs[_ADDCTL1] = 0x0C0
|
|
||||||
regs[_ADDCTL4] = 0x60 # Set GPIO1 to 0.
|
|
||||||
|
|
||||||
regs[_BYPASS1] = regs[_BYPASS2] = 0x0
|
|
||||||
# ADC volume, 0dB
|
|
||||||
regs[_LADC, _RADC] = 0x1C3
|
|
||||||
# Digital DAC volume, 0dB
|
|
||||||
regs[_LDAC, _RDAC] = 0x1FF
|
|
||||||
# Headphone volume, LOUT1 and ROUT1, 0dB
|
|
||||||
regs[_LOUT1, _ROUT1] = 0x16F
|
|
||||||
# speaker volume 6dB
|
|
||||||
regs[_LOUT2, _ROUT2] = 0x1FF
|
|
||||||
# enable class D output
|
|
||||||
regs[_CLASSD1] = 0xF7
|
|
||||||
# Unmute DAC.
|
|
||||||
regs[_DACCTL1] = 0x0000
|
|
||||||
# Input PGA volume 0 dB
|
|
||||||
regs[_LINVOL, _RINVOL] = 0x117
|
|
||||||
|
|
||||||
self.config_data_format(sysclk, sample_rate, bits)
|
|
||||||
|
|
||||||
def deinit(self):
|
|
||||||
|
|
||||||
self.set_module(MODULE_ADC, False)
|
|
||||||
self.set_module(MODULE_DAC, False)
|
|
||||||
self.set_module(MODULE_VREF, False)
|
|
||||||
self.set_module(MODULE_LINE_IN, False)
|
|
||||||
self.set_module(MODULE_LINE_OUT, False)
|
|
||||||
self.set_module(MODULE_SPEAKER, False)
|
|
||||||
|
|
||||||
def set_internal_pll_config(self, input_mclk, output_clk):
|
|
||||||
regs = self.regs
|
|
||||||
pllF2 = output_clk * 4
|
|
||||||
pll_prescale = 0
|
|
||||||
sysclk_div = 1
|
|
||||||
frac_mode = 0
|
|
||||||
|
|
||||||
# disable PLL power
|
|
||||||
regs[_POWER2] = (1, 0)
|
|
||||||
regs[_CLOCK1] = (7, 0)
|
|
||||||
|
|
||||||
pllN = pllF2 // input_mclk
|
|
||||||
if pllN < _PLL_N_MIN_VALUE:
|
|
||||||
input_mclk //= 2
|
|
||||||
pll_prescale = 1
|
|
||||||
pllN = pllF2 // input_mclk
|
|
||||||
if pllN < _PLL_N_MIN_VALUE:
|
|
||||||
sysclk_div = 2
|
|
||||||
pllF2 *= 2
|
|
||||||
pllN = pllF2 // input_mclk
|
|
||||||
|
|
||||||
if (pllN < _PLL_N_MIN_VALUE) or (pllN > _PLL_N_MAX_VALUE):
|
|
||||||
raise ValueError("Invalid MCLK vs. sysclk ratio")
|
|
||||||
|
|
||||||
pllK = ((pllF2 % input_mclk) * (1 << 24)) // input_mclk
|
|
||||||
if pllK != 0:
|
|
||||||
frac_mode = 1
|
|
||||||
|
|
||||||
regs[_PLL1] = (frac_mode << 5) | (pll_prescale << 4) | (pllN & 0x0F)
|
|
||||||
regs[_PLL2] = (pllK >> 16) & 0xFF
|
|
||||||
regs[_PLL3] = (pllK >> 8) & 0xFF
|
|
||||||
regs[_PLL4] = pllK & 0xFF
|
|
||||||
# enable PLL power
|
|
||||||
regs[_POWER2] = (1, 1)
|
|
||||||
regs[_CLOCK1] = (7, ((0 if sysclk_div == 1 else sysclk_div) << 1) | 1)
|
|
||||||
|
|
||||||
def set_master_clock(self, sysclk, sample_rate, bit_width):
|
|
||||||
bit_clock_divider = (sysclk * 2) // (sample_rate * bit_width * 2)
|
|
||||||
try:
|
|
||||||
reg_divider = self._bit_clock_divider_table[bit_clock_divider]
|
|
||||||
except:
|
|
||||||
raise ValueError("Invalid ratio of sysclk sample rate and bits")
|
|
||||||
# configure the master bit clock divider
|
|
||||||
self.regs[_CLOCK2] = (_CLOCK2_BCLK_DIV_MASK, reg_divider)
|
|
||||||
|
|
||||||
def set_speaker_clock(self, sysclk):
|
|
||||||
speaker_divider_table = (1.5, 2, 3, 4, 6, 8, 12, 16)
|
|
||||||
for val in range(8):
|
|
||||||
divider = speaker_divider_table[val]
|
|
||||||
f = sysclk / divider
|
|
||||||
if 500_000 < f < 1_000_000:
|
|
||||||
break
|
|
||||||
else:
|
|
||||||
val = 7
|
|
||||||
self.regs[_CLOCK2] = (
|
|
||||||
_CLOCK2_DCLK_DIV_MASK,
|
|
||||||
val << _CLOCK2_DCLK_DIV_SHIFT,
|
|
||||||
)
|
|
||||||
|
|
||||||
def set_module(self, module, is_enabled):
|
|
||||||
|
|
||||||
is_enabled = 1 if is_enabled else 0
|
|
||||||
regs = self.regs
|
|
||||||
|
|
||||||
if module == MODULE_ADC:
|
|
||||||
|
|
||||||
regs[_POWER1] = (
|
|
||||||
_POWER1_ADCL_MASK | _POWER1_ADCR_MASK,
|
|
||||||
(_POWER1_ADCL_MASK | _POWER1_ADCR_MASK) * is_enabled,
|
|
||||||
)
|
|
||||||
|
|
||||||
elif module == MODULE_DAC:
|
|
||||||
|
|
||||||
regs[_POWER2] = (
|
|
||||||
_POWER2_DACL_MASK | _POWER2_DACR_MASK,
|
|
||||||
(_POWER2_DACL_MASK | _POWER2_DACR_MASK) * is_enabled,
|
|
||||||
)
|
|
||||||
|
|
||||||
elif module == MODULE_VREF:
|
|
||||||
|
|
||||||
regs[_POWER1] = (
|
|
||||||
_POWER1_VREF_MASK,
|
|
||||||
(is_enabled << _POWER1_VREF_SHIFT),
|
|
||||||
)
|
|
||||||
|
|
||||||
elif module == MODULE_LINE_IN:
|
|
||||||
|
|
||||||
regs[_POWER1] = (
|
|
||||||
_POWER1_AINL_MASK | _POWER1_AINR_MASK,
|
|
||||||
(_POWER1_AINL_MASK | _POWER1_AINR_MASK) * is_enabled,
|
|
||||||
)
|
|
||||||
regs[_POWER3] = (
|
|
||||||
_POWER3_LMIC_MASK | _POWER3_RMIC_MASK,
|
|
||||||
(_POWER3_LMIC_MASK | _POWER3_RMIC_MASK) * is_enabled,
|
|
||||||
)
|
|
||||||
|
|
||||||
elif module == MODULE_LINE_OUT:
|
|
||||||
|
|
||||||
regs[_POWER2] = (
|
|
||||||
_POWER2_LOUT1_MASK | _POWER2_ROUT1_MASK,
|
|
||||||
(_POWER2_LOUT1_MASK | _POWER2_ROUT1_MASK) * is_enabled,
|
|
||||||
)
|
|
||||||
|
|
||||||
elif module == MODULE_MIC_BIAS:
|
|
||||||
|
|
||||||
regs[_POWER1] = (
|
|
||||||
_POWER1_MICB_MASK,
|
|
||||||
(is_enabled << _POWER1_MICB_SHIFT),
|
|
||||||
)
|
|
||||||
|
|
||||||
elif module == MODULE_SPEAKER:
|
|
||||||
|
|
||||||
regs[_POWER2] = (
|
|
||||||
_POWER2_SPKL_MASK | _POWER2_SPKR_MASK,
|
|
||||||
(_POWER2_SPKL_MASK | _POWER2_SPKR_MASK) * is_enabled,
|
|
||||||
)
|
|
||||||
regs[_CLASSD1] = 0xF7
|
|
||||||
|
|
||||||
elif module == MODULE_OMIX:
|
|
||||||
|
|
||||||
regs[_POWER3] = (
|
|
||||||
_POWER3_LOMIX_MASK | _POWER3_ROMIX_MASK,
|
|
||||||
(_POWER3_LOMIX_MASK | _POWER3_ROMIX_MASK) * is_enabled,
|
|
||||||
)
|
|
||||||
|
|
||||||
elif module == MODULE_MONO_OUT:
|
|
||||||
|
|
||||||
regs[_MONOMIX1] = regs[_MONOMIX2] = is_enabled << 7
|
|
||||||
regs[_MONO] = is_enabled << 6
|
|
||||||
|
|
||||||
else:
|
|
||||||
raise ValueError("Invalid module")
|
|
||||||
|
|
||||||
def enable_module(self, module):
|
|
||||||
self.set_module(module, True)
|
|
||||||
|
|
||||||
def disable_module(self, module):
|
|
||||||
self.set_module(module, False)
|
|
||||||
|
|
||||||
def set_data_route(self, route):
|
|
||||||
regs = self.regs
|
|
||||||
if route == ROUTE_BYPASS:
|
|
||||||
# Bypass means from line-in to HP
|
|
||||||
# Left LINPUT3 to left output mixer, LINPUT3 left output mixer volume = 0dB
|
|
||||||
# Right RINPUT3 to right output mixer, RINPUT3 right output mixer volume = 0dB
|
|
||||||
regs[_LOUTMIX, _ROUTMIX] = 0x80
|
|
||||||
|
|
||||||
elif route == ROUTE_PLAYBACK:
|
|
||||||
# Data route I2S_IN-> DAC-> HP
|
|
||||||
#
|
|
||||||
# Left DAC to left output mixer, LINPUT3 left output mixer volume = 0dB
|
|
||||||
# Right DAC to right output mixer, RINPUT3 right output mixer volume = 0dB
|
|
||||||
regs[_LOUTMIX, _ROUTMIX] = 0x100
|
|
||||||
regs[_POWER3] = 0x0C
|
|
||||||
# Set power for DAC
|
|
||||||
self.set_module(MODULE_DAC, True)
|
|
||||||
self.set_module(MODULE_OMIX, True)
|
|
||||||
self.set_module(MODULE_LINE_OUT, True)
|
|
||||||
|
|
||||||
elif route == ROUTE_PLAYBACK_RECORD:
|
|
||||||
#
|
|
||||||
# Left DAC to left output mixer, LINPUT3 left output mixer volume = 0dB
|
|
||||||
# Right DAC to right output mixer, RINPUT3 right output mixer volume = 0dB
|
|
||||||
regs[_LOUTMIX, _ROUTMIX] = 0x100
|
|
||||||
regs[_POWER3] = 0x3C
|
|
||||||
self.set_module(MODULE_DAC, True)
|
|
||||||
self.set_module(MODULE_ADC, True)
|
|
||||||
self.set_module(MODULE_LINE_IN, True)
|
|
||||||
self.set_module(MODULE_OMIX, True)
|
|
||||||
self.set_module(MODULE_LINE_OUT, True)
|
|
||||||
|
|
||||||
elif route == ROUTE_RECORD:
|
|
||||||
# LINE_IN->ADC->I2S_OUT
|
|
||||||
# Left and right input boost, LIN3BOOST and RIN3BOOST = 0dB
|
|
||||||
regs[_POWER3] = 0x30
|
|
||||||
# Power up ADC and AIN
|
|
||||||
self.set_module(MODULE_LINE_IN, True)
|
|
||||||
self.set_module(MODULE_ADC, True)
|
|
||||||
|
|
||||||
else:
|
|
||||||
raise ValueError("Invalid route")
|
|
||||||
|
|
||||||
def set_left_input(self, input):
|
|
||||||
if not input in self._input_config_table.keys():
|
|
||||||
raise ValueError("Invalid input")
|
|
||||||
|
|
||||||
input = self._input_config_table[input]
|
|
||||||
|
|
||||||
regs = self.regs
|
|
||||||
if input is None:
|
|
||||||
regs[_POWER1] = (_POWER1_AINL_MASK | _POWER1_ADCL_MASK, 0)
|
|
||||||
elif input[0] == 0:
|
|
||||||
regs[_POWER1] = (0, _POWER1_AINL_MASK | _POWER1_ADCL_MASK)
|
|
||||||
regs[_INBMIX1] = input
|
|
||||||
else:
|
|
||||||
regs[_POWER1] = (0, _POWER1_AINL_MASK | _POWER1_ADCL_MASK | _POWER1_MICB_MASK)
|
|
||||||
regs[_LINPATH] = input[0]
|
|
||||||
regs[_LINVOL] = input[1]
|
|
||||||
|
|
||||||
def set_right_input(self, input):
|
|
||||||
if not input in self._input_config_table.keys():
|
|
||||||
raise ValueError("Invalid input name")
|
|
||||||
|
|
||||||
input = self._input_config_table[input]
|
|
||||||
|
|
||||||
regs = self.regs
|
|
||||||
if input is None:
|
|
||||||
regs[_POWER1] = (_POWER1_AINR_MASK | _POWER1_ADCR_MASK, 0)
|
|
||||||
elif input[0] == 0:
|
|
||||||
regs[_POWER1] = (0, _POWER1_AINL_MASK | _POWER1_ADCR_MASK)
|
|
||||||
regs[_INBMIX2] = input
|
|
||||||
else:
|
|
||||||
regs[_POWER1] = (0, _POWER1_AINR_MASK | _POWER1_ADCR_MASK | _POWER1_MICB_MASK)
|
|
||||||
regs[_RINPATH] = input[0]
|
|
||||||
regs[_RINVOL] = input[1]
|
|
||||||
|
|
||||||
def set_protocol(self, protocol):
|
|
||||||
self.regs[_IFACE1] = (
|
|
||||||
_IFACE1_FORMAT_MASK | _IFACE1_LRP_MASK,
|
|
||||||
protocol,
|
|
||||||
)
|
|
||||||
|
|
||||||
def config_data_format(self, sysclk, sample_rate, bits):
|
|
||||||
# Compute sample rate divider, dac and adc are the same sample rate
|
|
||||||
try:
|
|
||||||
divider = self._dac_divider_table[sysclk // sample_rate]
|
|
||||||
wl = self._audio_word_length_table[bits]
|
|
||||||
except:
|
|
||||||
raise ValueError("Invalid ratio sysclk/sample_rate or invalid bit length")
|
|
||||||
|
|
||||||
self.regs[_CLOCK1] = (0x1F8, divider << 6 | divider << 3)
|
|
||||||
self.regs[_IFACE1] = (_IFACE1_WL_MASK, wl << _IFACE1_WL_SHIFT)
|
|
||||||
|
|
||||||
def volume(self, module, volume_l=None, volume_r=None):
|
|
||||||
if not module in self._volume_config_table.keys():
|
|
||||||
raise ValueError("Invalid module")
|
|
||||||
|
|
||||||
if volume_l is None: # get volume
|
|
||||||
vol_max, regnum, _ = self._volume_config_table[module]
|
|
||||||
return (
|
|
||||||
int((self.regs[regnum] & vol_max) * 100 / vol_max + 0.5),
|
|
||||||
int((self.regs[regnum + 1] & vol_max) * 100 / vol_max + 0.5),
|
|
||||||
)
|
|
||||||
else: # set volume
|
|
||||||
if volume_r is None:
|
|
||||||
volume_r = volume_l
|
|
||||||
|
|
||||||
if not ((0 <= volume_l <= 100) and (0 <= volume_r <= 100)):
|
|
||||||
raise ValueError("Invalid value for volume")
|
|
||||||
elif not module in self._volume_config_table.keys():
|
|
||||||
raise ValueError("Invalid module")
|
|
||||||
|
|
||||||
vol_max, regnum, flags = self._volume_config_table[module]
|
|
||||||
self.regs[regnum] = int(volume_l * vol_max / 100 + 0.5) | flags
|
|
||||||
self.regs[regnum + 1] = int(volume_r * vol_max / 100 + 0.5) | flags
|
|
||||||
|
|
||||||
def mute(self, enable, soft=True, ramp=MUTE_FAST):
|
|
||||||
enable = _DACCTL1_DACMU_MASK if enable else 0
|
|
||||||
soft = _DACCTL2_DACSMM_MASK if soft else 0
|
|
||||||
ramp = _DACCTL2_DACMR_MASK if ramp == MUTE_SLOW else 0
|
|
||||||
self.regs[_DACCTL1] = (_DACCTL1_DACMU_MASK, enable)
|
|
||||||
self.regs[_DACCTL2] = (
|
|
||||||
_DACCTL2_DACSMM_MASK | _DACCTL2_DACMR_MASK,
|
|
||||||
soft | ramp,
|
|
||||||
)
|
|
||||||
|
|
||||||
def expand_3d(self, depth=0):
|
|
||||||
depth &= 0x0F
|
|
||||||
cutoff = 0 if self.sample_rate >= 32000 else 0b1100000
|
|
||||||
self.regs[_3D] = cutoff | depth << 1 | (1 if depth > 0 else 0)
|
|
||||||
|
|
||||||
def mono(self, enable):
|
|
||||||
enable = 1 if enable else 0
|
|
||||||
self.regs[_DACCTL1] = (
|
|
||||||
_DACCTL1_MONOMIX_MASK,
|
|
||||||
enable << _DACCTL1_MONOMIX_SHIFT,
|
|
||||||
)
|
|
||||||
|
|
||||||
def alc_mode(self, channel, mode=ALC_MODE):
|
|
||||||
if mode != ALC_MODE:
|
|
||||||
mode = ALC_LIMITER
|
|
||||||
channel &= 3
|
|
||||||
self.regs[_ALC1] = (
|
|
||||||
_ALC_CHANNEL_MASK,
|
|
||||||
channel << _ALC_CHANNEL_SHIFT,
|
|
||||||
)
|
|
||||||
self.regs[_ALC3] = (_ALC_MODE_MASK, mode << _ALC_MODE_SHIFT)
|
|
||||||
try:
|
|
||||||
rate = _alc_sample_rate_table[self.sample_rate]
|
|
||||||
except:
|
|
||||||
rate = 0
|
|
||||||
self.regs[_ADDCTL3] = (_DACCTL3_ALCSR_MASK, rate)
|
|
||||||
|
|
||||||
def alc_gain(self, target=-12, max_gain=30, min_gain=-17.25, noise_gate=-78):
|
|
||||||
def limit(value, minval, maxval):
|
|
||||||
value = int(value)
|
|
||||||
if value < minval:
|
|
||||||
value = minval
|
|
||||||
if value > maxval:
|
|
||||||
value = maxval
|
|
||||||
return value
|
|
||||||
|
|
||||||
target = limit((16 + (target * 2) // 3), 0, 15)
|
|
||||||
max_gain = limit((max_gain + 12) // 6, 0, 7)
|
|
||||||
min_gain = limit((min_gain * 4 + 69) // 24, 0, 7)
|
|
||||||
noise_gate = limit((noise_gate * 2 + 153) // 3, -1, 31)
|
|
||||||
self.regs[_ALC1] = (
|
|
||||||
_ALC_GAIN_MASK | _ALC_TARGET_MASK,
|
|
||||||
(max_gain << _ALC_GAIN_SHIFT) | target,
|
|
||||||
)
|
|
||||||
self.regs[_ALC2] = (_ALC_GAIN_MASK, (min_gain << _ALC_GAIN_SHIFT))
|
|
||||||
if noise_gate >= 0:
|
|
||||||
self.regs[_NOISEG] = noise_gate << _NOISEG_LEVEL_SHIFT | 1
|
|
||||||
else:
|
|
||||||
self.regs[_NOISEG] = 0
|
|
||||||
|
|
||||||
def alc_time(self, attack=24, decay=192, hold=0):
|
|
||||||
def logb(value, limit):
|
|
||||||
value = int(value)
|
|
||||||
lb = 0
|
|
||||||
while value > 1:
|
|
||||||
value >>= 1
|
|
||||||
lb += 1
|
|
||||||
if lb > limit:
|
|
||||||
lb = limit
|
|
||||||
return lb
|
|
||||||
|
|
||||||
attack = logb(attack / 6, 7)
|
|
||||||
decay = logb(decay / 24, 7)
|
|
||||||
hold = logb((hold * 3) / 8, 15)
|
|
||||||
self.regs[_ALC2] = (_ALC_HOLD_MASK, hold)
|
|
||||||
self.regs[_ALC3] = (
|
|
||||||
_ALC_DECAY_MASK | _ALC_ATTACK_MASK,
|
|
||||||
(decay << _ALC_DECAY_SHIFT) | attack,
|
|
||||||
)
|
|
||||||
|
|
||||||
def deemphasis(self, enable):
|
|
||||||
deem_table = (32000, 44100, 48000)
|
|
||||||
enable = not not enable
|
|
||||||
if enable and self.sample_rate in deem_table:
|
|
||||||
val = deem_table.index(self.sample_rate) + 1
|
|
||||||
else:
|
|
||||||
val = 0
|
|
||||||
self.regs[_DACCTL1] = (_DACCTL1_DEEM_MASK, val << _DACCTL1_DEEM_SHIFT)
|
|
||||||
@ -1,46 +0,0 @@
|
|||||||
# DHT11/DHT22 driver for MicroPython on ESP8266
|
|
||||||
# MIT license; Copyright (c) 2016 Damien P. George
|
|
||||||
|
|
||||||
import sys
|
|
||||||
|
|
||||||
if sys.platform.startswith("esp"):
|
|
||||||
from esp import dht_readinto
|
|
||||||
elif sys.platform == "mimxrt":
|
|
||||||
from mimxrt import dht_readinto
|
|
||||||
elif sys.platform == "rp2":
|
|
||||||
from rp2 import dht_readinto
|
|
||||||
elif sys.platform == "pyboard":
|
|
||||||
from pyb import dht_readinto
|
|
||||||
else:
|
|
||||||
from machine import dht_readinto
|
|
||||||
|
|
||||||
|
|
||||||
class DHTBase:
|
|
||||||
def __init__(self, pin):
|
|
||||||
self.pin = pin
|
|
||||||
self.buf = bytearray(5)
|
|
||||||
|
|
||||||
def measure(self):
|
|
||||||
buf = self.buf
|
|
||||||
dht_readinto(self.pin, buf)
|
|
||||||
if (buf[0] + buf[1] + buf[2] + buf[3]) & 0xFF != buf[4]:
|
|
||||||
raise Exception("checksum error")
|
|
||||||
|
|
||||||
|
|
||||||
class DHT11(DHTBase):
|
|
||||||
def humidity(self):
|
|
||||||
return self.buf[0]
|
|
||||||
|
|
||||||
def temperature(self):
|
|
||||||
return self.buf[2]
|
|
||||||
|
|
||||||
|
|
||||||
class DHT22(DHTBase):
|
|
||||||
def humidity(self):
|
|
||||||
return (self.buf[0] << 8 | self.buf[1]) * 0.1
|
|
||||||
|
|
||||||
def temperature(self):
|
|
||||||
t = ((self.buf[2] & 0x7F) << 8 | self.buf[3]) * 0.1
|
|
||||||
if self.buf[2] & 0x80:
|
|
||||||
t = -t
|
|
||||||
return t
|
|
||||||
@ -1 +0,0 @@
|
|||||||
module("dht.py", opt=3)
|
|
||||||
@ -1,482 +0,0 @@
|
|||||||
# Driver for official MicroPython LCD160CR display
|
|
||||||
# MIT license; Copyright (c) 2017 Damien P. George
|
|
||||||
|
|
||||||
from micropython import const
|
|
||||||
from utime import sleep_ms
|
|
||||||
from ustruct import calcsize, pack_into
|
|
||||||
import uerrno, machine
|
|
||||||
|
|
||||||
# for set_orient
|
|
||||||
PORTRAIT = const(0)
|
|
||||||
LANDSCAPE = const(1)
|
|
||||||
PORTRAIT_UPSIDEDOWN = const(2)
|
|
||||||
LANDSCAPE_UPSIDEDOWN = const(3)
|
|
||||||
|
|
||||||
# for set_startup_deco; can be or'd
|
|
||||||
STARTUP_DECO_NONE = const(0)
|
|
||||||
STARTUP_DECO_MLOGO = const(1)
|
|
||||||
STARTUP_DECO_INFO = const(2)
|
|
||||||
|
|
||||||
_uart_baud_table = {
|
|
||||||
2400: 0,
|
|
||||||
4800: 1,
|
|
||||||
9600: 2,
|
|
||||||
19200: 3,
|
|
||||||
38400: 4,
|
|
||||||
57600: 5,
|
|
||||||
115200: 6,
|
|
||||||
230400: 7,
|
|
||||||
460800: 8,
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
class LCD160CR:
|
|
||||||
def __init__(self, connect=None, *, pwr=None, i2c=None, spi=None, i2c_addr=98):
|
|
||||||
if connect in ("X", "Y", "XY", "YX"):
|
|
||||||
i = connect[-1]
|
|
||||||
j = connect[0]
|
|
||||||
y = j + "4"
|
|
||||||
elif connect == "C":
|
|
||||||
i = 2
|
|
||||||
j = 2
|
|
||||||
y = "A7"
|
|
||||||
else:
|
|
||||||
if pwr is None or i2c is None or spi is None:
|
|
||||||
raise ValueError('must specify valid "connect" or all of "pwr", "i2c" and "spi"')
|
|
||||||
|
|
||||||
if pwr is None:
|
|
||||||
pwr = machine.Pin(y, machine.Pin.OUT)
|
|
||||||
if i2c is None:
|
|
||||||
i2c = machine.I2C(i, freq=1000000)
|
|
||||||
if spi is None:
|
|
||||||
spi = machine.SPI(j, baudrate=13500000, polarity=0, phase=0)
|
|
||||||
|
|
||||||
if not pwr.value():
|
|
||||||
pwr(1)
|
|
||||||
sleep_ms(10)
|
|
||||||
# else:
|
|
||||||
# alread have power
|
|
||||||
# lets be optimistic...
|
|
||||||
|
|
||||||
# set connections
|
|
||||||
self.pwr = pwr
|
|
||||||
self.i2c = i2c
|
|
||||||
self.spi = spi
|
|
||||||
self.i2c_addr = i2c_addr
|
|
||||||
|
|
||||||
# create temp buffers and memoryviews
|
|
||||||
self.buf16 = bytearray(16)
|
|
||||||
self.buf19 = bytearray(19)
|
|
||||||
self.buf = [None] * 10
|
|
||||||
for i in range(1, 10):
|
|
||||||
self.buf[i] = memoryview(self.buf16)[0:i]
|
|
||||||
self.buf1 = self.buf[1]
|
|
||||||
self.array4 = [0, 0, 0, 0]
|
|
||||||
|
|
||||||
# set default orientation and window
|
|
||||||
self.set_orient(PORTRAIT)
|
|
||||||
self._fcmd2b("<BBBBBB", 0x76, 0, 0, self.w, self.h) # viewport 'v'
|
|
||||||
self._fcmd2b("<BBBBBB", 0x79, 0, 0, self.w, self.h) # window 'y'
|
|
||||||
|
|
||||||
def _send(self, cmd):
|
|
||||||
i = self.i2c.writeto(self.i2c_addr, cmd)
|
|
||||||
if i == len(cmd):
|
|
||||||
return
|
|
||||||
cmd = memoryview(cmd)
|
|
||||||
n = len(cmd)
|
|
||||||
while True:
|
|
||||||
i += self.i2c.writeto(self.i2c_addr, cmd[i:])
|
|
||||||
if i == n:
|
|
||||||
return
|
|
||||||
sleep_ms(10)
|
|
||||||
|
|
||||||
def _fcmd2(self, fmt, a0, a1=0, a2=0):
|
|
||||||
buf = self.buf[calcsize(fmt)]
|
|
||||||
pack_into(fmt, buf, 0, 2, a0, a1, a2)
|
|
||||||
self._send(buf)
|
|
||||||
|
|
||||||
def _fcmd2b(self, fmt, a0, a1, a2, a3, a4=0):
|
|
||||||
buf = self.buf[calcsize(fmt)]
|
|
||||||
pack_into(fmt, buf, 0, 2, a0, a1, a2, a3, a4)
|
|
||||||
self._send(buf)
|
|
||||||
|
|
||||||
def _waitfor(self, n, buf):
|
|
||||||
t = 5000
|
|
||||||
while t:
|
|
||||||
self.i2c.readfrom_into(self.i2c_addr, self.buf1)
|
|
||||||
if self.buf1[0] >= n:
|
|
||||||
self.i2c.readfrom_into(self.i2c_addr, buf)
|
|
||||||
return
|
|
||||||
t -= 1
|
|
||||||
sleep_ms(1)
|
|
||||||
raise OSError(uerrno.ETIMEDOUT)
|
|
||||||
|
|
||||||
def oflush(self, n=255):
|
|
||||||
t = 5000
|
|
||||||
while t:
|
|
||||||
self.i2c.readfrom_into(self.i2c_addr + 1, self.buf1)
|
|
||||||
r = self.buf1[0]
|
|
||||||
if r >= n:
|
|
||||||
return
|
|
||||||
t -= 1
|
|
||||||
machine.idle()
|
|
||||||
raise OSError(uerrno.ETIMEDOUT)
|
|
||||||
|
|
||||||
def iflush(self):
|
|
||||||
t = 5000
|
|
||||||
while t:
|
|
||||||
self.i2c.readfrom_into(self.i2c_addr, self.buf16)
|
|
||||||
if self.buf16[0] == 0:
|
|
||||||
return
|
|
||||||
t -= 1
|
|
||||||
sleep_ms(1)
|
|
||||||
raise OSError(uerrno.ETIMEDOUT)
|
|
||||||
|
|
||||||
#### MISC METHODS ####
|
|
||||||
|
|
||||||
@staticmethod
|
|
||||||
def rgb(r, g, b):
|
|
||||||
return ((b & 0xF8) << 8) | ((g & 0xFC) << 3) | (r >> 3)
|
|
||||||
|
|
||||||
@staticmethod
|
|
||||||
def clip_line(c, w, h):
|
|
||||||
while True:
|
|
||||||
ca = ce = 0
|
|
||||||
if c[1] < 0:
|
|
||||||
ca |= 8
|
|
||||||
elif c[1] > h:
|
|
||||||
ca |= 4
|
|
||||||
if c[0] < 0:
|
|
||||||
ca |= 1
|
|
||||||
elif c[0] > w:
|
|
||||||
ca |= 2
|
|
||||||
if c[3] < 0:
|
|
||||||
ce |= 8
|
|
||||||
elif c[3] > h:
|
|
||||||
ce |= 4
|
|
||||||
if c[2] < 0:
|
|
||||||
ce |= 1
|
|
||||||
elif c[2] > w:
|
|
||||||
ce |= 2
|
|
||||||
if ca & ce:
|
|
||||||
return False
|
|
||||||
elif ca | ce:
|
|
||||||
ca |= ce
|
|
||||||
if ca & 1:
|
|
||||||
if c[2] < c[0]:
|
|
||||||
c[0], c[2] = c[2], c[0]
|
|
||||||
c[1], c[3] = c[3], c[1]
|
|
||||||
c[1] += ((-c[0]) * (c[3] - c[1])) // (c[2] - c[0])
|
|
||||||
c[0] = 0
|
|
||||||
elif ca & 2:
|
|
||||||
if c[2] < c[0]:
|
|
||||||
c[0], c[2] = c[2], c[0]
|
|
||||||
c[1], c[3] = c[3], c[1]
|
|
||||||
c[3] += ((w - 1 - c[2]) * (c[3] - c[1])) // (c[2] - c[0])
|
|
||||||
c[2] = w - 1
|
|
||||||
elif ca & 4:
|
|
||||||
if c[0] == c[2]:
|
|
||||||
if c[1] >= h:
|
|
||||||
c[1] = h - 1
|
|
||||||
if c[3] >= h:
|
|
||||||
c[3] = h - 1
|
|
||||||
else:
|
|
||||||
if c[3] < c[1]:
|
|
||||||
c[0], c[2] = c[2], c[0]
|
|
||||||
c[1], c[3] = c[3], c[1]
|
|
||||||
c[2] += ((h - 1 - c[3]) * (c[2] - c[0])) // (c[3] - c[1])
|
|
||||||
c[3] = h - 1
|
|
||||||
else:
|
|
||||||
if c[0] == c[2]:
|
|
||||||
if c[1] < 0:
|
|
||||||
c[1] = 0
|
|
||||||
if c[3] < 0:
|
|
||||||
c[3] = 0
|
|
||||||
else:
|
|
||||||
if c[3] < c[1]:
|
|
||||||
c[0], c[2] = c[2], c[0]
|
|
||||||
c[1], c[3] = c[3], c[1]
|
|
||||||
c[0] += ((-c[1]) * (c[2] - c[0])) // (c[3] - c[1])
|
|
||||||
c[1] = 0
|
|
||||||
else:
|
|
||||||
return True
|
|
||||||
|
|
||||||
#### SETUP COMMANDS ####
|
|
||||||
|
|
||||||
def set_power(self, on):
|
|
||||||
self.pwr(on)
|
|
||||||
sleep_ms(15)
|
|
||||||
|
|
||||||
def set_orient(self, orient):
|
|
||||||
self._fcmd2("<BBB", 0x14, (orient & 3) + 4)
|
|
||||||
# update width and height variables
|
|
||||||
self.iflush()
|
|
||||||
self._send(b"\x02g0")
|
|
||||||
self._waitfor(4, self.buf[5])
|
|
||||||
self.w = self.buf[5][1]
|
|
||||||
self.h = self.buf[5][2]
|
|
||||||
|
|
||||||
def set_brightness(self, value):
|
|
||||||
self._fcmd2("<BBB", 0x16, value)
|
|
||||||
|
|
||||||
def set_i2c_addr(self, addr):
|
|
||||||
# 0x0e set i2c addr
|
|
||||||
if addr & 3:
|
|
||||||
raise ValueError("must specify mod 4 aligned address")
|
|
||||||
self._fcmd2("<BBW", 0x0E, 0x433249 | (addr << 24))
|
|
||||||
|
|
||||||
def set_uart_baudrate(self, baudrate):
|
|
||||||
try:
|
|
||||||
baudrate = _uart_baud_table[baudrate]
|
|
||||||
except KeyError:
|
|
||||||
raise ValueError("invalid baudrate")
|
|
||||||
self._fcmd2("<BBB", 0x18, baudrate)
|
|
||||||
|
|
||||||
def set_startup_deco(self, value):
|
|
||||||
self._fcmd2("<BBB", 0x19, value)
|
|
||||||
|
|
||||||
def save_to_flash(self):
|
|
||||||
self._send(b"\x02fn")
|
|
||||||
|
|
||||||
#### PIXEL ACCESS ####
|
|
||||||
|
|
||||||
def set_pixel(self, x, y, c):
|
|
||||||
self._fcmd2b("<BBBBH", 0x41, x, y, c)
|
|
||||||
|
|
||||||
def get_pixel(self, x, y):
|
|
||||||
self._fcmd2("<BBBB", 0x61, x, y)
|
|
||||||
t = 1000
|
|
||||||
while t:
|
|
||||||
self.i2c.readfrom_into(self.i2c_addr, self.buf1)
|
|
||||||
if self.buf1[0] >= 2:
|
|
||||||
self.i2c.readfrom_into(self.i2c_addr, self.buf[3])
|
|
||||||
return self.buf[3][1] | self.buf[3][2] << 8
|
|
||||||
t -= 1
|
|
||||||
sleep_ms(1)
|
|
||||||
raise OSError(uerrno.ETIMEDOUT)
|
|
||||||
|
|
||||||
def get_line(self, x, y, buf):
|
|
||||||
l = len(buf) // 2
|
|
||||||
self._fcmd2b("<BBBBB", 0x10, l, x, y)
|
|
||||||
l *= 2
|
|
||||||
t = 1000
|
|
||||||
while t:
|
|
||||||
self.i2c.readfrom_into(self.i2c_addr, self.buf1)
|
|
||||||
if self.buf1[0] >= l:
|
|
||||||
self.i2c.readfrom_into(self.i2c_addr, buf)
|
|
||||||
return
|
|
||||||
t -= 1
|
|
||||||
sleep_ms(1)
|
|
||||||
raise OSError(uerrno.ETIMEDOUT)
|
|
||||||
|
|
||||||
def screen_dump(self, buf, x=0, y=0, w=None, h=None):
|
|
||||||
if w is None:
|
|
||||||
w = self.w - x
|
|
||||||
if h is None:
|
|
||||||
h = self.h - y
|
|
||||||
if w <= 127:
|
|
||||||
line = bytearray(2 * w + 1)
|
|
||||||
line2 = None
|
|
||||||
else:
|
|
||||||
# split line if more than 254 bytes needed
|
|
||||||
buflen = (w + 1) // 2
|
|
||||||
line = bytearray(2 * buflen + 1)
|
|
||||||
line2 = memoryview(line)[: 2 * (w - buflen) + 1]
|
|
||||||
for i in range(min(len(buf) // (2 * w), h)):
|
|
||||||
ix = i * w * 2
|
|
||||||
self.get_line(x, y + i, line)
|
|
||||||
buf[ix : ix + len(line) - 1] = memoryview(line)[1:]
|
|
||||||
ix += len(line) - 1
|
|
||||||
if line2:
|
|
||||||
self.get_line(x + buflen, y + i, line2)
|
|
||||||
buf[ix : ix + len(line2) - 1] = memoryview(line2)[1:]
|
|
||||||
ix += len(line2) - 1
|
|
||||||
|
|
||||||
def screen_load(self, buf):
|
|
||||||
l = self.w * self.h * 2 + 2
|
|
||||||
self._fcmd2b("<BBHBBB", 0x70, l, 16, self.w, self.h)
|
|
||||||
n = 0
|
|
||||||
ar = memoryview(buf)
|
|
||||||
while n < len(buf):
|
|
||||||
if len(buf) - n >= 0x200:
|
|
||||||
self._send(ar[n : n + 0x200])
|
|
||||||
n += 0x200
|
|
||||||
else:
|
|
||||||
self._send(ar[n:])
|
|
||||||
while n < self.w * self.h * 2:
|
|
||||||
self._send(b"\x00")
|
|
||||||
n += 1
|
|
||||||
|
|
||||||
#### TEXT COMMANDS ####
|
|
||||||
|
|
||||||
def set_pos(self, x, y):
|
|
||||||
self._fcmd2("<BBBB", 0x58, x, y)
|
|
||||||
|
|
||||||
def set_text_color(self, fg, bg):
|
|
||||||
self._fcmd2("<BBHH", 0x63, fg, bg)
|
|
||||||
|
|
||||||
def set_font(self, font, scale=0, bold=0, trans=0, scroll=0):
|
|
||||||
self._fcmd2(
|
|
||||||
"<BBBB",
|
|
||||||
0x46,
|
|
||||||
(scroll << 7) | (trans << 6) | ((font & 3) << 4) | (bold & 0xF),
|
|
||||||
scale & 0xFF,
|
|
||||||
)
|
|
||||||
|
|
||||||
def write(self, s):
|
|
||||||
# TODO: eventually check for room in LCD input queue
|
|
||||||
self._send(s)
|
|
||||||
|
|
||||||
#### PRIMITIVE DRAWING COMMANDS ####
|
|
||||||
|
|
||||||
def set_pen(self, line, fill):
|
|
||||||
self._fcmd2("<BBHH", 0x50, line, fill)
|
|
||||||
|
|
||||||
def erase(self):
|
|
||||||
self._send(b"\x02\x45")
|
|
||||||
|
|
||||||
def dot(self, x, y):
|
|
||||||
if 0 <= x < self.w and 0 <= y < self.h:
|
|
||||||
self._fcmd2("<BBBB", 0x4B, x, y)
|
|
||||||
|
|
||||||
def rect(self, x, y, w, h, cmd=0x72):
|
|
||||||
if x + w <= 0 or y + h <= 0 or x >= self.w or y >= self.h:
|
|
||||||
return
|
|
||||||
elif x < 0 or y < 0:
|
|
||||||
left = top = True
|
|
||||||
if x < 0:
|
|
||||||
left = False
|
|
||||||
w += x
|
|
||||||
x = 0
|
|
||||||
if y < 0:
|
|
||||||
top = False
|
|
||||||
h += y
|
|
||||||
y = 0
|
|
||||||
if cmd == 0x51 or cmd == 0x72:
|
|
||||||
# draw interior
|
|
||||||
self._fcmd2b("<BBBBBB", 0x51, x, y, min(w, 255), min(h, 255))
|
|
||||||
if cmd == 0x57 or cmd == 0x72:
|
|
||||||
# draw outline
|
|
||||||
if left:
|
|
||||||
self._fcmd2b("<BBBBBB", 0x57, x, y, 1, min(h, 255))
|
|
||||||
if top:
|
|
||||||
self._fcmd2b("<BBBBBB", 0x57, x, y, min(w, 255), 1)
|
|
||||||
if x + w < self.w:
|
|
||||||
self._fcmd2b("<BBBBBB", 0x57, x + w, y, 1, min(h, 255))
|
|
||||||
if y + h < self.h:
|
|
||||||
self._fcmd2b("<BBBBBB", 0x57, x, y + h, min(w, 255), 1)
|
|
||||||
else:
|
|
||||||
self._fcmd2b("<BBBBBB", cmd, x, y, min(w, 255), min(h, 255))
|
|
||||||
|
|
||||||
def rect_outline(self, x, y, w, h):
|
|
||||||
self.rect(x, y, w, h, 0x57)
|
|
||||||
|
|
||||||
def rect_interior(self, x, y, w, h):
|
|
||||||
self.rect(x, y, w, h, 0x51)
|
|
||||||
|
|
||||||
def line(self, x1, y1, x2, y2):
|
|
||||||
ar4 = self.array4
|
|
||||||
ar4[0] = x1
|
|
||||||
ar4[1] = y1
|
|
||||||
ar4[2] = x2
|
|
||||||
ar4[3] = y2
|
|
||||||
if self.clip_line(ar4, self.w, self.h):
|
|
||||||
self._fcmd2b("<BBBBBB", 0x4C, ar4[0], ar4[1], ar4[2], ar4[3])
|
|
||||||
|
|
||||||
def dot_no_clip(self, x, y):
|
|
||||||
self._fcmd2("<BBBB", 0x4B, x, y)
|
|
||||||
|
|
||||||
def rect_no_clip(self, x, y, w, h):
|
|
||||||
self._fcmd2b("<BBBBBB", 0x72, x, y, w, h)
|
|
||||||
|
|
||||||
def rect_outline_no_clip(self, x, y, w, h):
|
|
||||||
self._fcmd2b("<BBBBBB", 0x57, x, y, w, h)
|
|
||||||
|
|
||||||
def rect_interior_no_clip(self, x, y, w, h):
|
|
||||||
self._fcmd2b("<BBBBBB", 0x51, x, y, w, h)
|
|
||||||
|
|
||||||
def line_no_clip(self, x1, y1, x2, y2):
|
|
||||||
self._fcmd2b("<BBBBBB", 0x4C, x1, y1, x2, y2)
|
|
||||||
|
|
||||||
def poly_dot(self, data):
|
|
||||||
if len(data) & 1:
|
|
||||||
raise ValueError("must specify even number of bytes")
|
|
||||||
self._fcmd2("<BBB", 0x71, len(data) // 2)
|
|
||||||
self._send(data)
|
|
||||||
|
|
||||||
def poly_line(self, data):
|
|
||||||
if len(data) & 1:
|
|
||||||
raise ValueError("must specify even number of bytes")
|
|
||||||
self._fcmd2("<BBB", 0x78, len(data) // 2)
|
|
||||||
self._send(data)
|
|
||||||
|
|
||||||
#### TOUCH COMMANDS ####
|
|
||||||
|
|
||||||
def touch_config(self, calib=False, save=False, irq=None):
|
|
||||||
self._fcmd2("<BBBB", 0x7A, (irq is not None) << 2 | save << 1 | calib, bool(irq) << 7)
|
|
||||||
|
|
||||||
def is_touched(self):
|
|
||||||
self._send(b"\x02T")
|
|
||||||
b = self.buf[4]
|
|
||||||
self._waitfor(3, b)
|
|
||||||
return b[1] >> 7 != 0
|
|
||||||
|
|
||||||
def get_touch(self):
|
|
||||||
self._send(b"\x02T") # implicit LCD output flush
|
|
||||||
b = self.buf[4]
|
|
||||||
self._waitfor(3, b)
|
|
||||||
return b[1] >> 7, b[2], b[3]
|
|
||||||
|
|
||||||
#### ADVANCED COMMANDS ####
|
|
||||||
|
|
||||||
def set_spi_win(self, x, y, w, h):
|
|
||||||
pack_into(
|
|
||||||
"<BBBHHHHHHHH", self.buf19, 0, 2, 0x55, 10, x, y, x + w - 1, y + h - 1, 0, 0, 0, 0xFFFF
|
|
||||||
)
|
|
||||||
self._send(self.buf19)
|
|
||||||
|
|
||||||
def fast_spi(self, flush=True):
|
|
||||||
self._send(b"\x02\x12")
|
|
||||||
if flush:
|
|
||||||
self.oflush()
|
|
||||||
return self.spi
|
|
||||||
|
|
||||||
def show_framebuf(self, buf):
|
|
||||||
self.fast_spi().write(buf)
|
|
||||||
|
|
||||||
def set_scroll(self, on):
|
|
||||||
self._fcmd2("<BBB", 0x15, on)
|
|
||||||
|
|
||||||
def set_scroll_win(self, win, x=-1, y=0, w=0, h=0, vec=0, pat=0, fill=0x07E0, color=0):
|
|
||||||
pack_into("<BBBHHHHHHHH", self.buf19, 0, 2, 0x55, win, x, y, w, h, vec, pat, fill, color)
|
|
||||||
self._send(self.buf19)
|
|
||||||
|
|
||||||
def set_scroll_win_param(self, win, param, value):
|
|
||||||
self._fcmd2b("<BBBBH", 0x75, win, param, value)
|
|
||||||
|
|
||||||
def set_scroll_buf(self, s):
|
|
||||||
l = len(s)
|
|
||||||
if l > 32:
|
|
||||||
raise ValueError("length must be 32 or less")
|
|
||||||
self._fcmd2("<BBB", 0x11, l)
|
|
||||||
self._send(s)
|
|
||||||
|
|
||||||
def jpeg_start(self, l):
|
|
||||||
if l > 0xFFFF:
|
|
||||||
raise ValueError("length must be 65535 or less")
|
|
||||||
self.oflush()
|
|
||||||
self._fcmd2("<BBH", 0x6A, l)
|
|
||||||
|
|
||||||
def jpeg_data(self, buf):
|
|
||||||
self._send(buf)
|
|
||||||
|
|
||||||
def jpeg(self, buf):
|
|
||||||
self.jpeg_start(len(buf))
|
|
||||||
self.jpeg_data(buf)
|
|
||||||
|
|
||||||
def feed_wdt(self):
|
|
||||||
self._send(b"\x02\x17")
|
|
||||||
|
|
||||||
def reset(self):
|
|
||||||
self._send(b"\x02Y\xef\xbe\xad\xde")
|
|
||||||
sleep_ms(15)
|
|
||||||
@ -1,187 +0,0 @@
|
|||||||
# Driver test for official MicroPython LCD160CR display
|
|
||||||
# MIT license; Copyright (c) 2017 Damien P. George
|
|
||||||
|
|
||||||
import time, math, framebuf, lcd160cr
|
|
||||||
|
|
||||||
|
|
||||||
def get_lcd(lcd):
|
|
||||||
if type(lcd) is str:
|
|
||||||
lcd = lcd160cr.LCD160CR(lcd)
|
|
||||||
return lcd
|
|
||||||
|
|
||||||
|
|
||||||
def show_adc(lcd, adc):
|
|
||||||
data = [adc.read_core_temp(), adc.read_core_vbat(), 3.3]
|
|
||||||
try:
|
|
||||||
data[2] = adc.read_vref()
|
|
||||||
except:
|
|
||||||
pass
|
|
||||||
for i in range(3):
|
|
||||||
lcd.set_text_color((825, 1625, 1600)[i], 0)
|
|
||||||
if lcd.h == 160:
|
|
||||||
lcd.set_font(2)
|
|
||||||
lcd.set_pos(0, 100 + i * 16)
|
|
||||||
else:
|
|
||||||
lcd.set_font(2, trans=1)
|
|
||||||
lcd.set_pos(0, lcd.h - 60 + i * 16)
|
|
||||||
lcd.write("%4s: " % ("TEMP", "VBAT", "VREF")[i])
|
|
||||||
if i > 0:
|
|
||||||
s = "%6.3fV" % data[i]
|
|
||||||
else:
|
|
||||||
s = "%5.1f°C" % data[i]
|
|
||||||
if lcd.h == 160:
|
|
||||||
lcd.set_font(1, bold=0, scale=1)
|
|
||||||
else:
|
|
||||||
lcd.set_font(1, bold=0, scale=1, trans=1)
|
|
||||||
lcd.set_pos(45, lcd.h - 60 + i * 16)
|
|
||||||
lcd.write(s)
|
|
||||||
|
|
||||||
|
|
||||||
def test_features(lcd, orient=lcd160cr.PORTRAIT):
|
|
||||||
# if we run on pyboard then use ADC and RTC features
|
|
||||||
try:
|
|
||||||
import pyb
|
|
||||||
|
|
||||||
adc = pyb.ADCAll(12, 0xF0000)
|
|
||||||
rtc = pyb.RTC()
|
|
||||||
except:
|
|
||||||
adc = None
|
|
||||||
rtc = None
|
|
||||||
|
|
||||||
# set orientation and clear screen
|
|
||||||
lcd = get_lcd(lcd)
|
|
||||||
lcd.set_orient(orient)
|
|
||||||
lcd.set_pen(0, 0)
|
|
||||||
lcd.erase()
|
|
||||||
|
|
||||||
# create M-logo
|
|
||||||
mlogo = framebuf.FrameBuffer(bytearray(17 * 17 * 2), 17, 17, framebuf.RGB565)
|
|
||||||
mlogo.fill(0)
|
|
||||||
mlogo.fill_rect(1, 1, 15, 15, 0xFFFFFF)
|
|
||||||
mlogo.vline(4, 4, 12, 0)
|
|
||||||
mlogo.vline(8, 1, 12, 0)
|
|
||||||
mlogo.vline(12, 4, 12, 0)
|
|
||||||
mlogo.vline(14, 13, 2, 0)
|
|
||||||
|
|
||||||
# create inline framebuf
|
|
||||||
offx = 14
|
|
||||||
offy = 19
|
|
||||||
w = 100
|
|
||||||
h = 75
|
|
||||||
fbuf = framebuf.FrameBuffer(bytearray(w * h * 2), w, h, framebuf.RGB565)
|
|
||||||
lcd.set_spi_win(offx, offy, w, h)
|
|
||||||
|
|
||||||
# initialise loop parameters
|
|
||||||
tx = ty = 0
|
|
||||||
t0 = time.ticks_us()
|
|
||||||
|
|
||||||
for i in range(300):
|
|
||||||
# update position of cross-hair
|
|
||||||
t, tx2, ty2 = lcd.get_touch()
|
|
||||||
if t:
|
|
||||||
tx2 -= offx
|
|
||||||
ty2 -= offy
|
|
||||||
if tx2 >= 0 and ty2 >= 0 and tx2 < w and ty2 < h:
|
|
||||||
tx, ty = tx2, ty2
|
|
||||||
else:
|
|
||||||
tx = (tx + 1) % w
|
|
||||||
ty = (ty + 1) % h
|
|
||||||
|
|
||||||
# create and show the inline framebuf
|
|
||||||
fbuf.fill(lcd.rgb(128 + int(64 * math.cos(0.1 * i)), 128, 192))
|
|
||||||
fbuf.line(
|
|
||||||
w // 2,
|
|
||||||
h // 2,
|
|
||||||
w // 2 + int(40 * math.cos(0.2 * i)),
|
|
||||||
h // 2 + int(40 * math.sin(0.2 * i)),
|
|
||||||
lcd.rgb(128, 255, 64),
|
|
||||||
)
|
|
||||||
fbuf.hline(0, ty, w, lcd.rgb(64, 64, 64))
|
|
||||||
fbuf.vline(tx, 0, h, lcd.rgb(64, 64, 64))
|
|
||||||
fbuf.rect(tx - 3, ty - 3, 7, 7, lcd.rgb(64, 64, 64))
|
|
||||||
for phase in (-0.2, 0, 0.2):
|
|
||||||
x = w // 2 - 8 + int(50 * math.cos(0.05 * i + phase))
|
|
||||||
y = h // 2 - 8 + int(32 * math.sin(0.05 * i + phase))
|
|
||||||
fbuf.blit(mlogo, x, y)
|
|
||||||
for j in range(-3, 3):
|
|
||||||
fbuf.text(
|
|
||||||
"MicroPython",
|
|
||||||
5,
|
|
||||||
h // 2 + 9 * j + int(20 * math.sin(0.1 * (i + j))),
|
|
||||||
lcd.rgb(128 + 10 * j, 0, 128 - 10 * j),
|
|
||||||
)
|
|
||||||
lcd.show_framebuf(fbuf)
|
|
||||||
|
|
||||||
# show results from the ADC
|
|
||||||
if adc:
|
|
||||||
show_adc(lcd, adc)
|
|
||||||
|
|
||||||
# show the time
|
|
||||||
if rtc:
|
|
||||||
lcd.set_pos(2, 0)
|
|
||||||
lcd.set_font(1)
|
|
||||||
t = rtc.datetime()
|
|
||||||
lcd.write(
|
|
||||||
"%4d-%02d-%02d %2d:%02d:%02d.%01d"
|
|
||||||
% (t[0], t[1], t[2], t[4], t[5], t[6], t[7] // 100000)
|
|
||||||
)
|
|
||||||
|
|
||||||
# compute the frame rate
|
|
||||||
t1 = time.ticks_us()
|
|
||||||
dt = time.ticks_diff(t1, t0)
|
|
||||||
t0 = t1
|
|
||||||
|
|
||||||
# show the frame rate
|
|
||||||
lcd.set_pos(2, 9)
|
|
||||||
lcd.write("%.2f fps" % (1000000 / dt))
|
|
||||||
|
|
||||||
|
|
||||||
def test_mandel(lcd, orient=lcd160cr.PORTRAIT):
|
|
||||||
# set orientation and clear screen
|
|
||||||
lcd = get_lcd(lcd)
|
|
||||||
lcd.set_orient(orient)
|
|
||||||
lcd.set_pen(0, 0xFFFF)
|
|
||||||
lcd.erase()
|
|
||||||
|
|
||||||
# function to compute Mandelbrot pixels
|
|
||||||
def in_set(c):
|
|
||||||
z = 0
|
|
||||||
for i in range(32):
|
|
||||||
z = z * z + c
|
|
||||||
if abs(z) > 100:
|
|
||||||
return i
|
|
||||||
return 0
|
|
||||||
|
|
||||||
# cache width and height of LCD
|
|
||||||
w = lcd.w
|
|
||||||
h = lcd.h
|
|
||||||
|
|
||||||
# create the buffer for each line and set SPI parameters
|
|
||||||
line = bytearray(w * 2)
|
|
||||||
lcd.set_spi_win(0, 0, w, h)
|
|
||||||
spi = lcd.fast_spi()
|
|
||||||
|
|
||||||
# draw the Mandelbrot set line-by-line
|
|
||||||
hh = (h - 1) / 3.2
|
|
||||||
ww = (w - 1) / 2.4
|
|
||||||
for v in range(h):
|
|
||||||
for u in range(w):
|
|
||||||
c = in_set((v / hh - 2.3) + (u / ww - 1.2) * 1j)
|
|
||||||
if c < 16:
|
|
||||||
rgb = c << 12 | c << 6
|
|
||||||
else:
|
|
||||||
rgb = 0xF800 | c << 6
|
|
||||||
line[2 * u] = rgb
|
|
||||||
line[2 * u + 1] = rgb >> 8
|
|
||||||
spi.write(line)
|
|
||||||
|
|
||||||
|
|
||||||
def test_all(lcd, orient=lcd160cr.PORTRAIT):
|
|
||||||
lcd = get_lcd(lcd)
|
|
||||||
test_features(lcd, orient)
|
|
||||||
test_mandel(lcd, orient)
|
|
||||||
|
|
||||||
|
|
||||||
print("To run all tests: test_all(<lcd>)")
|
|
||||||
print("Individual tests are: test_features, test_mandel")
|
|
||||||
print('<lcd> argument should be a connection, eg "X", or an LCD160CR object')
|
|
||||||
@ -1,11 +0,0 @@
|
|||||||
# TODO: Split these into separate directories with their own manifests.
|
|
||||||
options.defaults(lcd160cr=False, ssd1306=False, test=False)
|
|
||||||
|
|
||||||
if options.lcd160cr:
|
|
||||||
module("lcd160cr.py", opt=3)
|
|
||||||
|
|
||||||
if options.test:
|
|
||||||
module("lcd160cr_test.py", opt=3)
|
|
||||||
|
|
||||||
if options.ssd1306:
|
|
||||||
module("ssd1306.py", opt=3)
|
|
||||||
@ -1,163 +0,0 @@
|
|||||||
# MicroPython SSD1306 OLED driver, I2C and SPI interfaces
|
|
||||||
|
|
||||||
from micropython import const
|
|
||||||
import framebuf
|
|
||||||
|
|
||||||
|
|
||||||
# register definitions
|
|
||||||
SET_CONTRAST = const(0x81)
|
|
||||||
SET_ENTIRE_ON = const(0xA4)
|
|
||||||
SET_NORM_INV = const(0xA6)
|
|
||||||
SET_DISP = const(0xAE)
|
|
||||||
SET_MEM_ADDR = const(0x20)
|
|
||||||
SET_COL_ADDR = const(0x21)
|
|
||||||
SET_PAGE_ADDR = const(0x22)
|
|
||||||
SET_DISP_START_LINE = const(0x40)
|
|
||||||
SET_SEG_REMAP = const(0xA0)
|
|
||||||
SET_MUX_RATIO = const(0xA8)
|
|
||||||
SET_IREF_SELECT = const(0xAD)
|
|
||||||
SET_COM_OUT_DIR = const(0xC0)
|
|
||||||
SET_DISP_OFFSET = const(0xD3)
|
|
||||||
SET_COM_PIN_CFG = const(0xDA)
|
|
||||||
SET_DISP_CLK_DIV = const(0xD5)
|
|
||||||
SET_PRECHARGE = const(0xD9)
|
|
||||||
SET_VCOM_DESEL = const(0xDB)
|
|
||||||
SET_CHARGE_PUMP = const(0x8D)
|
|
||||||
|
|
||||||
# Subclassing FrameBuffer provides support for graphics primitives
|
|
||||||
# http://docs.micropython.org/en/latest/pyboard/library/framebuf.html
|
|
||||||
class SSD1306(framebuf.FrameBuffer):
|
|
||||||
def __init__(self, width, height, external_vcc):
|
|
||||||
self.width = width
|
|
||||||
self.height = height
|
|
||||||
self.external_vcc = external_vcc
|
|
||||||
self.pages = self.height // 8
|
|
||||||
self.buffer = bytearray(self.pages * self.width)
|
|
||||||
super().__init__(self.buffer, self.width, self.height, framebuf.MONO_VLSB)
|
|
||||||
self.init_display()
|
|
||||||
|
|
||||||
def init_display(self):
|
|
||||||
for cmd in (
|
|
||||||
SET_DISP, # display off
|
|
||||||
# address setting
|
|
||||||
SET_MEM_ADDR,
|
|
||||||
0x00, # horizontal
|
|
||||||
# resolution and layout
|
|
||||||
SET_DISP_START_LINE, # start at line 0
|
|
||||||
SET_SEG_REMAP | 0x01, # column addr 127 mapped to SEG0
|
|
||||||
SET_MUX_RATIO,
|
|
||||||
self.height - 1,
|
|
||||||
SET_COM_OUT_DIR | 0x08, # scan from COM[N] to COM0
|
|
||||||
SET_DISP_OFFSET,
|
|
||||||
0x00,
|
|
||||||
SET_COM_PIN_CFG,
|
|
||||||
0x02 if self.width > 2 * self.height else 0x12,
|
|
||||||
# timing and driving scheme
|
|
||||||
SET_DISP_CLK_DIV,
|
|
||||||
0x80,
|
|
||||||
SET_PRECHARGE,
|
|
||||||
0x22 if self.external_vcc else 0xF1,
|
|
||||||
SET_VCOM_DESEL,
|
|
||||||
0x30, # 0.83*Vcc
|
|
||||||
# display
|
|
||||||
SET_CONTRAST,
|
|
||||||
0xFF, # maximum
|
|
||||||
SET_ENTIRE_ON, # output follows RAM contents
|
|
||||||
SET_NORM_INV, # not inverted
|
|
||||||
SET_IREF_SELECT,
|
|
||||||
0x30, # enable internal IREF during display on
|
|
||||||
# charge pump
|
|
||||||
SET_CHARGE_PUMP,
|
|
||||||
0x10 if self.external_vcc else 0x14,
|
|
||||||
SET_DISP | 0x01, # display on
|
|
||||||
): # on
|
|
||||||
self.write_cmd(cmd)
|
|
||||||
self.fill(0)
|
|
||||||
self.show()
|
|
||||||
|
|
||||||
def poweroff(self):
|
|
||||||
self.write_cmd(SET_DISP)
|
|
||||||
|
|
||||||
def poweron(self):
|
|
||||||
self.write_cmd(SET_DISP | 0x01)
|
|
||||||
|
|
||||||
def contrast(self, contrast):
|
|
||||||
self.write_cmd(SET_CONTRAST)
|
|
||||||
self.write_cmd(contrast)
|
|
||||||
|
|
||||||
def invert(self, invert):
|
|
||||||
self.write_cmd(SET_NORM_INV | (invert & 1))
|
|
||||||
|
|
||||||
def rotate(self, rotate):
|
|
||||||
self.write_cmd(SET_COM_OUT_DIR | ((rotate & 1) << 3))
|
|
||||||
self.write_cmd(SET_SEG_REMAP | (rotate & 1))
|
|
||||||
|
|
||||||
def show(self):
|
|
||||||
x0 = 0
|
|
||||||
x1 = self.width - 1
|
|
||||||
if self.width != 128:
|
|
||||||
# narrow displays use centred columns
|
|
||||||
col_offset = (128 - self.width) // 2
|
|
||||||
x0 += col_offset
|
|
||||||
x1 += col_offset
|
|
||||||
self.write_cmd(SET_COL_ADDR)
|
|
||||||
self.write_cmd(x0)
|
|
||||||
self.write_cmd(x1)
|
|
||||||
self.write_cmd(SET_PAGE_ADDR)
|
|
||||||
self.write_cmd(0)
|
|
||||||
self.write_cmd(self.pages - 1)
|
|
||||||
self.write_data(self.buffer)
|
|
||||||
|
|
||||||
|
|
||||||
class SSD1306_I2C(SSD1306):
|
|
||||||
def __init__(self, width, height, i2c, addr=0x3C, external_vcc=False):
|
|
||||||
self.i2c = i2c
|
|
||||||
self.addr = addr
|
|
||||||
self.temp = bytearray(2)
|
|
||||||
self.write_list = [b"\x40", None] # Co=0, D/C#=1
|
|
||||||
super().__init__(width, height, external_vcc)
|
|
||||||
|
|
||||||
def write_cmd(self, cmd):
|
|
||||||
self.temp[0] = 0x80 # Co=1, D/C#=0
|
|
||||||
self.temp[1] = cmd
|
|
||||||
self.i2c.writeto(self.addr, self.temp)
|
|
||||||
|
|
||||||
def write_data(self, buf):
|
|
||||||
self.write_list[1] = buf
|
|
||||||
self.i2c.writevto(self.addr, self.write_list)
|
|
||||||
|
|
||||||
|
|
||||||
class SSD1306_SPI(SSD1306):
|
|
||||||
def __init__(self, width, height, spi, dc, res, cs, external_vcc=False):
|
|
||||||
self.rate = 10 * 1024 * 1024
|
|
||||||
dc.init(dc.OUT, value=0)
|
|
||||||
res.init(res.OUT, value=0)
|
|
||||||
cs.init(cs.OUT, value=1)
|
|
||||||
self.spi = spi
|
|
||||||
self.dc = dc
|
|
||||||
self.res = res
|
|
||||||
self.cs = cs
|
|
||||||
import time
|
|
||||||
|
|
||||||
self.res(1)
|
|
||||||
time.sleep_ms(1)
|
|
||||||
self.res(0)
|
|
||||||
time.sleep_ms(10)
|
|
||||||
self.res(1)
|
|
||||||
super().__init__(width, height, external_vcc)
|
|
||||||
|
|
||||||
def write_cmd(self, cmd):
|
|
||||||
self.spi.init(baudrate=self.rate, polarity=0, phase=0)
|
|
||||||
self.cs(1)
|
|
||||||
self.dc(0)
|
|
||||||
self.cs(0)
|
|
||||||
self.spi.write(bytearray([cmd]))
|
|
||||||
self.cs(1)
|
|
||||||
|
|
||||||
def write_data(self, buf):
|
|
||||||
self.spi.init(baudrate=self.rate, polarity=0, phase=0)
|
|
||||||
self.cs(1)
|
|
||||||
self.dc(1)
|
|
||||||
self.cs(0)
|
|
||||||
self.spi.write(buf)
|
|
||||||
self.cs(1)
|
|
||||||
@ -1,91 +0,0 @@
|
|||||||
"""
|
|
||||||
The MIT License (MIT)
|
|
||||||
|
|
||||||
Copyright (c) 2013-2022 Ibrahim Abdelkader <iabdalkader@openmv.io>
|
|
||||||
Copyright (c) 2013-2022 Kwabena W. Agyeman <kwagyeman@openmv.io>
|
|
||||||
|
|
||||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
||||||
of this software and associated documentation files (the "Software"), to deal
|
|
||||||
in the Software without restriction, including without limitation the rights
|
|
||||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
||||||
copies of the Software, and to permit persons to whom the Software is
|
|
||||||
furnished to do so, subject to the following conditions:
|
|
||||||
|
|
||||||
The above copyright notice and this permission notice shall be included in
|
|
||||||
all copies or substantial portions of the Software.
|
|
||||||
|
|
||||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
||||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
||||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
||||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
||||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
||||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
||||||
THE SOFTWARE.
|
|
||||||
|
|
||||||
HTS221 driver driver for MicroPython.
|
|
||||||
Original source: https://github.com/ControlEverythingCommunity/HTS221/blob/master/Python/HTS221.py
|
|
||||||
|
|
||||||
Example usage:
|
|
||||||
|
|
||||||
import time
|
|
||||||
import hts221
|
|
||||||
from machine import Pin, I2C
|
|
||||||
|
|
||||||
bus = I2C(1, scl=Pin(15), sda=Pin(14))
|
|
||||||
hts = hts221.HTS221(bus)
|
|
||||||
|
|
||||||
while (True):
|
|
||||||
rH = hts.humidity()
|
|
||||||
temp = hts.temperature()
|
|
||||||
print ("rH: %.2f%% T: %.2fC" %(rH, temp))
|
|
||||||
time.sleep_ms(100)
|
|
||||||
"""
|
|
||||||
|
|
||||||
import struct
|
|
||||||
|
|
||||||
|
|
||||||
class HTS221:
|
|
||||||
def __init__(self, i2c, data_rate=1, address=0x5F):
|
|
||||||
self.bus = i2c
|
|
||||||
self.odr = data_rate
|
|
||||||
self.slv_addr = address
|
|
||||||
|
|
||||||
# Set configuration register
|
|
||||||
# Humidity and temperature average configuration
|
|
||||||
self.bus.writeto_mem(self.slv_addr, 0x10, b"\x1B")
|
|
||||||
|
|
||||||
# Set control register
|
|
||||||
# PD | BDU | ODR
|
|
||||||
cfg = 0x80 | 0x04 | (self.odr & 0x3)
|
|
||||||
self.bus.writeto_mem(self.slv_addr, 0x20, bytes([cfg]))
|
|
||||||
|
|
||||||
# Read Calibration values from non-volatile memory of the device
|
|
||||||
# Humidity Calibration values
|
|
||||||
self.H0 = self._read_reg(0x30, 1) / 2
|
|
||||||
self.H1 = self._read_reg(0x31, 1) / 2
|
|
||||||
self.H2 = self._read_reg(0x36, 2)
|
|
||||||
self.H3 = self._read_reg(0x3A, 2)
|
|
||||||
|
|
||||||
# Temperature Calibration values
|
|
||||||
raw = self._read_reg(0x35, 1)
|
|
||||||
self.T0 = ((raw & 0x03) * 256) + self._read_reg(0x32, 1)
|
|
||||||
self.T1 = ((raw & 0x0C) * 64) + self._read_reg(0x33, 1)
|
|
||||||
self.T2 = self._read_reg(0x3C, 2)
|
|
||||||
self.T3 = self._read_reg(0x3E, 2)
|
|
||||||
|
|
||||||
def _read_reg(self, reg_addr, size):
|
|
||||||
fmt = "B" if size == 1 else "H"
|
|
||||||
reg_addr = reg_addr if size == 1 else reg_addr | 0x80
|
|
||||||
return struct.unpack(fmt, self.bus.readfrom_mem(self.slv_addr, reg_addr, size))[0]
|
|
||||||
|
|
||||||
def humidity(self):
|
|
||||||
rH = self._read_reg(0x28, 2)
|
|
||||||
return (self.H1 - self.H0) * (rH - self.H2) / (self.H3 - self.H2) + self.H0
|
|
||||||
|
|
||||||
def temperature(self):
|
|
||||||
temp = self._read_reg(0x2A, 2)
|
|
||||||
if temp > 32767:
|
|
||||||
temp -= 65536
|
|
||||||
return ((self.T1 - self.T0) / 8.0) * (temp - self.T2) / (self.T3 - self.T2) + (
|
|
||||||
self.T0 / 8.0
|
|
||||||
)
|
|
||||||
@ -1 +0,0 @@
|
|||||||
module("hts221.py", opt=3)
|
|
||||||
@ -1,109 +0,0 @@
|
|||||||
"""
|
|
||||||
The MIT License (MIT)
|
|
||||||
|
|
||||||
Copyright (c) 2016-2019 shaoziyang <shaoziyang@micropython.org.cn>
|
|
||||||
Copyright (c) 2022 Ibrahim Abdelkader <iabdalkader@openmv.io>
|
|
||||||
|
|
||||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
||||||
of this software and associated documentation files (the "Software"), to deal
|
|
||||||
in the Software without restriction, including without limitation the rights
|
|
||||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
||||||
copies of the Software, and to permit persons to whom the Software is
|
|
||||||
furnished to do so, subject to the following conditions:
|
|
||||||
|
|
||||||
The above copyright notice and this permission notice shall be included in
|
|
||||||
all copies or substantial portions of the Software.
|
|
||||||
|
|
||||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
||||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
||||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
||||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
||||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
||||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
||||||
THE SOFTWARE.
|
|
||||||
|
|
||||||
LPS22HB/HH pressure sensor driver for MicroPython.
|
|
||||||
|
|
||||||
Example usage:
|
|
||||||
|
|
||||||
import time
|
|
||||||
from lps22h import LPS22H
|
|
||||||
from machine import Pin, I2C
|
|
||||||
|
|
||||||
bus = I2C(1, scl=Pin(15), sda=Pin(14))
|
|
||||||
lps = LPS22H(bus, oneshot=False)
|
|
||||||
|
|
||||||
while (True):
|
|
||||||
print("Pressure: %.2f hPa Temperature: %.2f C"%(lps.pressure(), lps.temperature()))
|
|
||||||
time.sleep_ms(10)
|
|
||||||
"""
|
|
||||||
import machine
|
|
||||||
|
|
||||||
_LPS22_CTRL_REG1 = const(0x10)
|
|
||||||
_LPS22_CTRL_REG2 = const(0x11)
|
|
||||||
_LPS22_STATUS = const(0x27)
|
|
||||||
_LPS22_TEMP_OUT_L = const(0x2B)
|
|
||||||
_LPS22_PRESS_OUT_XL = const(0x28)
|
|
||||||
_LPS22_PRESS_OUT_L = const(0x29)
|
|
||||||
|
|
||||||
|
|
||||||
class LPS22H:
|
|
||||||
def __init__(self, i2c, address=0x5C, oneshot=False):
|
|
||||||
self.i2c = i2c
|
|
||||||
self.addr = address
|
|
||||||
self.oneshot = oneshot
|
|
||||||
self.buf = bytearray(1)
|
|
||||||
# ODR=1 EN_LPFP=1 BDU=1
|
|
||||||
self._write_reg(_LPS22_CTRL_REG1, 0x1A)
|
|
||||||
self.set_oneshot_mode(self.oneshot)
|
|
||||||
|
|
||||||
def _int16(self, d):
|
|
||||||
return d if d < 0x8000 else d - 0x10000
|
|
||||||
|
|
||||||
def _write_reg(self, reg, dat):
|
|
||||||
self.buf[0] = dat
|
|
||||||
self.i2c.writeto_mem(self.addr, reg, self.buf)
|
|
||||||
|
|
||||||
def _read_reg(self, reg, width=8):
|
|
||||||
self.i2c.readfrom_mem_into(self.addr, reg, self.buf)
|
|
||||||
val = self.buf[0]
|
|
||||||
if width == 16:
|
|
||||||
val |= self._read_reg(reg + 1) << 8
|
|
||||||
return val
|
|
||||||
|
|
||||||
def _tigger_oneshot(self, b):
|
|
||||||
if self.oneshot:
|
|
||||||
self._write_reg(_LPS22_CTRL_REG2, self._read_reg(_LPS22_CTRL_REG2) | 0x01)
|
|
||||||
self._read_reg(0x28 + b * 2)
|
|
||||||
while True:
|
|
||||||
if self._read_reg(_LPS22_STATUS) & b:
|
|
||||||
return
|
|
||||||
machine.idle()
|
|
||||||
|
|
||||||
def set_oneshot_mode(self, oneshot):
|
|
||||||
self._read_reg(_LPS22_CTRL_REG1)
|
|
||||||
self.oneshot = oneshot
|
|
||||||
if oneshot:
|
|
||||||
self.buf[0] &= 0x0F
|
|
||||||
else:
|
|
||||||
self.buf[0] |= 0x10
|
|
||||||
self._write_reg(_LPS22_CTRL_REG1, self.buf[0])
|
|
||||||
|
|
||||||
def pressure(self):
|
|
||||||
if self.oneshot:
|
|
||||||
self._tigger_oneshot(1)
|
|
||||||
return (
|
|
||||||
self._read_reg(_LPS22_PRESS_OUT_XL) + self._read_reg(_LPS22_PRESS_OUT_L, 16) * 256
|
|
||||||
) / 4096
|
|
||||||
|
|
||||||
def temperature(self):
|
|
||||||
if self.oneshot:
|
|
||||||
self._tigger_oneshot(2)
|
|
||||||
return self._int16(self._read_reg(_LPS22_TEMP_OUT_L, 16)) / 100
|
|
||||||
|
|
||||||
def altitude(self):
|
|
||||||
return (
|
|
||||||
(((1013.25 / self.pressure()) ** (1 / 5.257)) - 1.0)
|
|
||||||
* (self.temperature() + 273.15)
|
|
||||||
/ 0.0065
|
|
||||||
)
|
|
||||||
@ -1 +0,0 @@
|
|||||||
module("lps22h.py", opt=3)
|
|
||||||
@ -1,271 +0,0 @@
|
|||||||
"""
|
|
||||||
LSM6DSOX STMicro driver for MicroPython based on LSM9DS1:
|
|
||||||
Source repo: https://github.com/hoihu/projects/tree/master/raspi-hat
|
|
||||||
|
|
||||||
The MIT License (MIT)
|
|
||||||
|
|
||||||
Copyright (c) 2021 Damien P. George
|
|
||||||
Copyright (c) 2021-2022 Ibrahim Abdelkader <iabdalkader@openmv.io>
|
|
||||||
|
|
||||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
||||||
of this software and associated documentation files (the "Software"), to deal
|
|
||||||
in the Software without restriction, including without limitation the rights
|
|
||||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
||||||
copies of the Software, and to permit persons to whom the Software is
|
|
||||||
furnished to do so, subject to the following conditions:
|
|
||||||
|
|
||||||
The above copyright notice and this permission notice shall be included in
|
|
||||||
all copies or substantial portions of the Software.
|
|
||||||
|
|
||||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
||||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
||||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
||||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
||||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
||||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
||||||
THE SOFTWARE.
|
|
||||||
|
|
||||||
Basic example usage:
|
|
||||||
|
|
||||||
import time
|
|
||||||
from lsm6dsox import LSM6DSOX
|
|
||||||
|
|
||||||
from machine import Pin, SPI, I2C
|
|
||||||
# Init in I2C mode.
|
|
||||||
lsm = LSM6DSOX(I2C(0, scl=Pin(13), sda=Pin(12)))
|
|
||||||
|
|
||||||
# Or init in SPI mode.
|
|
||||||
#lsm = LSM6DSOX(SPI(5), cs_pin=Pin(10))
|
|
||||||
|
|
||||||
while (True):
|
|
||||||
print('Accelerometer: x:{:>8.3f} y:{:>8.3f} z:{:>8.3f}'.format(*lsm.read_accel()))
|
|
||||||
print('Gyroscope: x:{:>8.3f} y:{:>8.3f} z:{:>8.3f}'.format(*lsm.read_gyro()))
|
|
||||||
print("")
|
|
||||||
time.sleep_ms(100)
|
|
||||||
"""
|
|
||||||
|
|
||||||
import array
|
|
||||||
from micropython import const
|
|
||||||
|
|
||||||
|
|
||||||
class LSM6DSOX:
|
|
||||||
_CTRL3_C = const(0x12)
|
|
||||||
_CTRL1_XL = const(0x10)
|
|
||||||
_CTRL8_XL = const(0x17)
|
|
||||||
_CTRL9_XL = const(0x18)
|
|
||||||
|
|
||||||
_CTRL2_G = const(0x11)
|
|
||||||
_CTRL7_G = const(0x16)
|
|
||||||
|
|
||||||
_OUTX_L_G = const(0x22)
|
|
||||||
_OUTX_L_XL = const(0x28)
|
|
||||||
_MLC_STATUS = const(0x38)
|
|
||||||
|
|
||||||
_DEFAULT_ADDR = const(0x6A)
|
|
||||||
_WHO_AM_I_REG = const(0x0F)
|
|
||||||
|
|
||||||
_FUNC_CFG_ACCESS = const(0x01)
|
|
||||||
_FUNC_CFG_BANK_USER = const(0)
|
|
||||||
_FUNC_CFG_BANK_HUB = const(1)
|
|
||||||
_FUNC_CFG_BANK_EMBED = const(2)
|
|
||||||
|
|
||||||
_MLC0_SRC = const(0x70)
|
|
||||||
_MLC_INT1 = const(0x0D)
|
|
||||||
_TAP_CFG0 = const(0x56)
|
|
||||||
|
|
||||||
_EMB_FUNC_EN_A = const(0x04)
|
|
||||||
_EMB_FUNC_EN_B = const(0x05)
|
|
||||||
|
|
||||||
def __init__(
|
|
||||||
self,
|
|
||||||
bus,
|
|
||||||
cs_pin=None,
|
|
||||||
address=_DEFAULT_ADDR,
|
|
||||||
gyro_odr=104,
|
|
||||||
accel_odr=104,
|
|
||||||
gyro_scale=2000,
|
|
||||||
accel_scale=4,
|
|
||||||
ucf=None,
|
|
||||||
):
|
|
||||||
"""Initalizes Gyro and Accelerator.
|
|
||||||
accel_odr: (0, 1.6Hz, 3.33Hz, 6.66Hz, 12.5Hz, 26Hz, 52Hz, 104Hz, 208Hz, 416Hz, 888Hz)
|
|
||||||
gyro_odr: (0, 1.6Hz, 3.33Hz, 6.66Hz, 12.5Hz, 26Hz, 52Hz, 104Hz, 208Hz, 416Hz, 888Hz)
|
|
||||||
gyro_scale: (245dps, 500dps, 1000dps, 2000dps)
|
|
||||||
accel_scale: (+/-2g, +/-4g, +/-8g, +-16g)
|
|
||||||
ucf: MLC program to load.
|
|
||||||
"""
|
|
||||||
self.bus = bus
|
|
||||||
self.cs_pin = cs_pin
|
|
||||||
self.address = address
|
|
||||||
self._use_i2c = hasattr(self.bus, "readfrom_mem")
|
|
||||||
|
|
||||||
if not self._use_i2c and cs_pin is None:
|
|
||||||
raise ValueError("A CS pin must be provided in SPI mode")
|
|
||||||
|
|
||||||
# check the id of the Accelerometer/Gyro
|
|
||||||
if self.__read_reg(_WHO_AM_I_REG) != 108:
|
|
||||||
raise OSError("No LSM6DS device was found at address 0x%x" % (self.address))
|
|
||||||
|
|
||||||
# allocate scratch buffer for efficient conversions and memread op's
|
|
||||||
self.scratch_int = array.array("h", [0, 0, 0])
|
|
||||||
|
|
||||||
SCALE_GYRO = {250: 0, 500: 1, 1000: 2, 2000: 3}
|
|
||||||
SCALE_ACCEL = {2: 0, 4: 2, 8: 3, 16: 1}
|
|
||||||
# XL_HM_MODE = 0 by default. G_HM_MODE = 0 by default.
|
|
||||||
ODR = {
|
|
||||||
0: 0x00,
|
|
||||||
1.6: 0x08,
|
|
||||||
3.33: 0x09,
|
|
||||||
6.66: 0x0A,
|
|
||||||
12.5: 0x01,
|
|
||||||
26: 0x02,
|
|
||||||
52: 0x03,
|
|
||||||
104: 0x04,
|
|
||||||
208: 0x05,
|
|
||||||
416: 0x06,
|
|
||||||
888: 0x07,
|
|
||||||
}
|
|
||||||
|
|
||||||
gyro_odr = round(gyro_odr, 2)
|
|
||||||
accel_odr = round(accel_odr, 2)
|
|
||||||
|
|
||||||
# Sanity checks
|
|
||||||
if not gyro_odr in ODR:
|
|
||||||
raise ValueError("Invalid sampling rate: %d" % accel_odr)
|
|
||||||
if not gyro_scale in SCALE_GYRO:
|
|
||||||
raise ValueError("invalid gyro scaling: %d" % gyro_scale)
|
|
||||||
if not accel_odr in ODR:
|
|
||||||
raise ValueError("Invalid sampling rate: %d" % accel_odr)
|
|
||||||
if not accel_scale in SCALE_ACCEL:
|
|
||||||
raise ValueError("invalid accelerometer scaling: %d" % accel_scale)
|
|
||||||
|
|
||||||
# Soft-reset the device.
|
|
||||||
self.reset()
|
|
||||||
|
|
||||||
# Load and configure MLC if UCF file is provided
|
|
||||||
if ucf != None:
|
|
||||||
self.load_mlc(ucf)
|
|
||||||
|
|
||||||
# Set Gyroscope datarate and scale.
|
|
||||||
# Note output from LPF2 second filtering stage is selected. See Figure 18.
|
|
||||||
self.__write_reg(_CTRL1_XL, (ODR[accel_odr] << 4) | (SCALE_ACCEL[accel_scale] << 2) | 2)
|
|
||||||
|
|
||||||
# Enable LPF2 and HPF fast-settling mode, ODR/4
|
|
||||||
self.__write_reg(_CTRL8_XL, 0x09)
|
|
||||||
|
|
||||||
# Set Gyroscope datarate and scale.
|
|
||||||
self.__write_reg(_CTRL2_G, (ODR[gyro_odr] << 4) | (SCALE_GYRO[gyro_scale] << 2) | 0)
|
|
||||||
|
|
||||||
self.gyro_scale = 32768 / gyro_scale
|
|
||||||
self.accel_scale = 32768 / accel_scale
|
|
||||||
|
|
||||||
def __read_reg(self, reg, size=1):
|
|
||||||
if self._use_i2c:
|
|
||||||
buf = self.bus.readfrom_mem(self.address, reg, size)
|
|
||||||
else:
|
|
||||||
try:
|
|
||||||
self.cs_pin(0)
|
|
||||||
self.bus.write(bytes([reg | 0x80]))
|
|
||||||
buf = self.bus.read(size)
|
|
||||||
finally:
|
|
||||||
self.cs_pin(1)
|
|
||||||
if size == 1:
|
|
||||||
return int(buf[0])
|
|
||||||
return [int(x) for x in buf]
|
|
||||||
|
|
||||||
def __write_reg(self, reg, val):
|
|
||||||
if self._use_i2c:
|
|
||||||
self.bus.writeto_mem(self.address, reg, bytes([val]))
|
|
||||||
else:
|
|
||||||
try:
|
|
||||||
self.cs_pin(0)
|
|
||||||
self.bus.write(bytes([reg, val]))
|
|
||||||
finally:
|
|
||||||
self.cs_pin(1)
|
|
||||||
|
|
||||||
def __read_reg_into(self, reg, buf):
|
|
||||||
if self._use_i2c:
|
|
||||||
self.bus.readfrom_mem_into(self.address, reg, buf)
|
|
||||||
else:
|
|
||||||
try:
|
|
||||||
self.cs_pin(0)
|
|
||||||
self.bus.write(bytes([reg | 0x80]))
|
|
||||||
self.bus.readinto(buf)
|
|
||||||
finally:
|
|
||||||
self.cs_pin(1)
|
|
||||||
|
|
||||||
def reset(self):
|
|
||||||
self.__write_reg(_CTRL3_C, self.__read_reg(_CTRL3_C) | 0x1)
|
|
||||||
for i in range(0, 10):
|
|
||||||
if (self.__read_reg(_CTRL3_C) & 0x01) == 0:
|
|
||||||
return
|
|
||||||
time.sleep_ms(10)
|
|
||||||
raise OSError("Failed to reset LSM6DS device.")
|
|
||||||
|
|
||||||
def set_mem_bank(self, bank):
|
|
||||||
cfg = self.__read_reg(_FUNC_CFG_ACCESS) & 0x3F
|
|
||||||
self.__write_reg(_FUNC_CFG_ACCESS, cfg | (bank << 6))
|
|
||||||
|
|
||||||
def set_embedded_functions(self, enable, emb_ab=None):
|
|
||||||
self.set_mem_bank(_FUNC_CFG_BANK_EMBED)
|
|
||||||
if enable:
|
|
||||||
self.__write_reg(_EMB_FUNC_EN_A, emb_ab[0])
|
|
||||||
self.__write_reg(_EMB_FUNC_EN_B, emb_ab[1])
|
|
||||||
else:
|
|
||||||
emb_a = self.__read_reg(_EMB_FUNC_EN_A)
|
|
||||||
emb_b = self.__read_reg(_EMB_FUNC_EN_B)
|
|
||||||
self.__write_reg(_EMB_FUNC_EN_A, (emb_a & 0xC7))
|
|
||||||
self.__write_reg(_EMB_FUNC_EN_B, (emb_b & 0xE6))
|
|
||||||
emb_ab = (emb_a, emb_b)
|
|
||||||
|
|
||||||
self.set_mem_bank(_FUNC_CFG_BANK_USER)
|
|
||||||
return emb_ab
|
|
||||||
|
|
||||||
def load_mlc(self, ucf):
|
|
||||||
# Load MLC config from file
|
|
||||||
with open(ucf, "r") as ucf_file:
|
|
||||||
for l in ucf_file:
|
|
||||||
if l.startswith("Ac"):
|
|
||||||
v = [int(v, 16) for v in l.strip().split(" ")[1:3]]
|
|
||||||
self.__write_reg(v[0], v[1])
|
|
||||||
|
|
||||||
emb_ab = self.set_embedded_functions(False)
|
|
||||||
|
|
||||||
# Disable I3C interface
|
|
||||||
self.__write_reg(_CTRL9_XL, self.__read_reg(_CTRL9_XL) | 0x01)
|
|
||||||
|
|
||||||
# Enable Block Data Update
|
|
||||||
self.__write_reg(_CTRL3_C, self.__read_reg(_CTRL3_C) | 0x40)
|
|
||||||
|
|
||||||
# Route signals on interrupt pin 1
|
|
||||||
self.set_mem_bank(_FUNC_CFG_BANK_EMBED)
|
|
||||||
self.__write_reg(_MLC_INT1, self.__read_reg(_MLC_INT1) & 0x01)
|
|
||||||
self.set_mem_bank(_FUNC_CFG_BANK_USER)
|
|
||||||
|
|
||||||
# Configure interrupt pin mode
|
|
||||||
self.__write_reg(_TAP_CFG0, self.__read_reg(_TAP_CFG0) | 0x41)
|
|
||||||
|
|
||||||
self.set_embedded_functions(True, emb_ab)
|
|
||||||
|
|
||||||
def read_mlc_output(self):
|
|
||||||
buf = None
|
|
||||||
if self.__read_reg(_MLC_STATUS) & 0x1:
|
|
||||||
self.__read_reg(0x1A, size=12)
|
|
||||||
self.set_mem_bank(_FUNC_CFG_BANK_EMBED)
|
|
||||||
buf = self.__read_reg(_MLC0_SRC, 8)
|
|
||||||
self.set_mem_bank(_FUNC_CFG_BANK_USER)
|
|
||||||
return buf
|
|
||||||
|
|
||||||
def read_gyro(self):
|
|
||||||
"""Returns gyroscope vector in degrees/sec."""
|
|
||||||
mv = memoryview(self.scratch_int)
|
|
||||||
f = self.gyro_scale
|
|
||||||
self.__read_reg_into(_OUTX_L_G, mv)
|
|
||||||
return (mv[0] / f, mv[1] / f, mv[2] / f)
|
|
||||||
|
|
||||||
def read_accel(self):
|
|
||||||
"""Returns acceleration vector in gravity units (9.81m/s^2)."""
|
|
||||||
mv = memoryview(self.scratch_int)
|
|
||||||
f = self.accel_scale
|
|
||||||
self.__read_reg_into(_OUTX_L_XL, mv)
|
|
||||||
return (mv[0] / f, mv[1] / f, mv[2] / f)
|
|
||||||
@ -1,15 +0,0 @@
|
|||||||
# LSM6DSOX Basic Example.
|
|
||||||
import time
|
|
||||||
from lsm6dsox import LSM6DSOX
|
|
||||||
|
|
||||||
from machine import Pin, I2C
|
|
||||||
|
|
||||||
lsm = LSM6DSOX(I2C(0, scl=Pin(13), sda=Pin(12)))
|
|
||||||
# Or init in SPI mode.
|
|
||||||
# lsm = LSM6DSOX(SPI(5), cs_pin=Pin(10))
|
|
||||||
|
|
||||||
while True:
|
|
||||||
print("Accelerometer: x:{:>8.3f} y:{:>8.3f} z:{:>8.3f}".format(*lsm.read_accel()))
|
|
||||||
print("Gyroscope: x:{:>8.3f} y:{:>8.3f} z:{:>8.3f}".format(*lsm.read_gyro()))
|
|
||||||
print("")
|
|
||||||
time.sleep_ms(100)
|
|
||||||
@ -1,48 +0,0 @@
|
|||||||
# LSM6DSOX IMU MLC (Machine Learning Core) Example.
|
|
||||||
# Download the raw UCF file, copy to storage and reset.
|
|
||||||
|
|
||||||
# NOTE: The pre-trained models (UCF files) for the examples can be found here:
|
|
||||||
# https://github.com/STMicroelectronics/STMems_Machine_Learning_Core/tree/master/application_examples/lsm6dsox
|
|
||||||
|
|
||||||
import time
|
|
||||||
from lsm6dsox import LSM6DSOX
|
|
||||||
from machine import Pin, I2C
|
|
||||||
|
|
||||||
INT_MODE = True # Run in interrupt mode.
|
|
||||||
INT_FLAG = False # Set True on interrupt.
|
|
||||||
|
|
||||||
|
|
||||||
def imu_int_handler(pin):
|
|
||||||
global INT_FLAG
|
|
||||||
INT_FLAG = True
|
|
||||||
|
|
||||||
|
|
||||||
if INT_MODE == True:
|
|
||||||
int_pin = Pin(24)
|
|
||||||
int_pin.irq(handler=imu_int_handler, trigger=Pin.IRQ_RISING)
|
|
||||||
|
|
||||||
i2c = I2C(0, scl=Pin(13), sda=Pin(12))
|
|
||||||
|
|
||||||
# Vibration detection example
|
|
||||||
UCF_FILE = "lsm6dsox_vibration_monitoring.ucf"
|
|
||||||
UCF_LABELS = {0: "no vibration", 1: "low vibration", 2: "high vibration"}
|
|
||||||
# NOTE: Selected data rate and scale must match the MLC data rate and scale.
|
|
||||||
lsm = LSM6DSOX(i2c, gyro_odr=26, accel_odr=26, gyro_scale=2000, accel_scale=4, ucf=UCF_FILE)
|
|
||||||
|
|
||||||
# Head gestures example
|
|
||||||
# UCF_FILE = "lsm6dsox_head_gestures.ucf"
|
|
||||||
# UCF_LABELS = {0:"Nod", 1:"Shake", 2:"Stationary", 3:"Swing", 4:"Walk"}
|
|
||||||
# NOTE: Selected data rate and scale must match the MLC data rate and scale.
|
|
||||||
# lsm = LSM6DSOX(i2c, gyro_odr=26, accel_odr=26, gyro_scale=250, accel_scale=2, ucf=UCF_FILE)
|
|
||||||
|
|
||||||
print("MLC configured...")
|
|
||||||
|
|
||||||
while True:
|
|
||||||
if INT_MODE:
|
|
||||||
if INT_FLAG:
|
|
||||||
INT_FLAG = False
|
|
||||||
print(UCF_LABELS[lsm.read_mlc_output()[0]])
|
|
||||||
else:
|
|
||||||
buf = lsm.read_mlc_output()
|
|
||||||
if buf != None:
|
|
||||||
print(UCF_LABELS[buf[0]])
|
|
||||||
@ -1 +0,0 @@
|
|||||||
module("lsm6dsox.py", opt=3)
|
|
||||||
@ -1,189 +0,0 @@
|
|||||||
"""
|
|
||||||
The MIT License (MIT)
|
|
||||||
|
|
||||||
Copyright (c) 2013, 2014 Damien P. George
|
|
||||||
|
|
||||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
||||||
of this software and associated documentation files (the "Software"), to deal
|
|
||||||
in the Software without restriction, including without limitation the rights
|
|
||||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
||||||
copies of the Software, and to permit persons to whom the Software is
|
|
||||||
furnished to do so, subject to the following conditions:
|
|
||||||
|
|
||||||
The above copyright notice and this permission notice shall be included in
|
|
||||||
all copies or substantial portions of the Software.
|
|
||||||
|
|
||||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
||||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
||||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
||||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
||||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
||||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
||||||
THE SOFTWARE.
|
|
||||||
|
|
||||||
|
|
||||||
LSM9DS1 - 9DOF inertial sensor of STMicro driver for MicroPython.
|
|
||||||
The sensor contains an accelerometer / gyroscope / magnetometer
|
|
||||||
Uses the internal FIFO to store up to 16 gyro/accel data, use the iter_accel_gyro generator to access it.
|
|
||||||
|
|
||||||
Example usage:
|
|
||||||
|
|
||||||
import time
|
|
||||||
from lsm9ds1 import LSM9DS1
|
|
||||||
from machine import Pin, I2C
|
|
||||||
|
|
||||||
lsm = LSM9DS1(I2C(1, scl=Pin(15), sda=Pin(14)))
|
|
||||||
|
|
||||||
while (True):
|
|
||||||
#for g,a in lsm.iter_accel_gyro(): print(g,a) # using fifo
|
|
||||||
print('Accelerometer: x:{:>8.3f} y:{:>8.3f} z:{:>8.3f}'.format(*lsm.accel()))
|
|
||||||
print('Magnetometer: x:{:>8.3f} y:{:>8.3f} z:{:>8.3f}'.format(*lsm.magnet()))
|
|
||||||
print('Gyroscope: x:{:>8.3f} y:{:>8.3f} z:{:>8.3f}'.format(*lsm.gyro()))
|
|
||||||
print("")
|
|
||||||
time.sleep_ms(100)
|
|
||||||
"""
|
|
||||||
import array
|
|
||||||
|
|
||||||
|
|
||||||
_WHO_AM_I = const(0xF)
|
|
||||||
_CTRL_REG1_G = const(0x10)
|
|
||||||
_INT_GEN_SRC_G = const(0x14)
|
|
||||||
_OUT_TEMP = const(0x15)
|
|
||||||
_OUT_G = const(0x18)
|
|
||||||
_CTRL_REG4_G = const(0x1E)
|
|
||||||
_STATUS_REG = const(0x27)
|
|
||||||
_OUT_XL = const(0x28)
|
|
||||||
_FIFO_CTRL_REG = const(0x2E)
|
|
||||||
_FIFO_SRC = const(0x2F)
|
|
||||||
_OFFSET_REG_X_M = const(0x05)
|
|
||||||
_CTRL_REG1_M = const(0x20)
|
|
||||||
_OUT_M = const(0x28)
|
|
||||||
_SCALE_GYRO = const(((245, 0), (500, 1), (2000, 3)))
|
|
||||||
_SCALE_ACCEL = const(((2, 0), (4, 2), (8, 3), (16, 1)))
|
|
||||||
|
|
||||||
|
|
||||||
class LSM9DS1:
|
|
||||||
def __init__(self, i2c, address_gyro=0x6B, address_magnet=0x1E):
|
|
||||||
self.i2c = i2c
|
|
||||||
self.address_gyro = address_gyro
|
|
||||||
self.address_magnet = address_magnet
|
|
||||||
# check id's of accelerometer/gyro and magnetometer
|
|
||||||
if (self.magent_id() != b"=") or (self.gyro_id() != b"h"):
|
|
||||||
raise OSError(
|
|
||||||
"Invalid LSM9DS1 device, using address {}/{}".format(address_gyro, address_magnet)
|
|
||||||
)
|
|
||||||
# allocate scratch buffer for efficient conversions and memread op's
|
|
||||||
self.scratch = array.array("B", [0, 0, 0, 0, 0, 0])
|
|
||||||
self.scratch_int = array.array("h", [0, 0, 0])
|
|
||||||
self.init_gyro_accel()
|
|
||||||
self.init_magnetometer()
|
|
||||||
|
|
||||||
def init_gyro_accel(self, sample_rate=6, scale_gyro=0, scale_accel=0):
|
|
||||||
"""Initalizes Gyro and Accelerator.
|
|
||||||
sample rate: 0-6 (off, 14.9Hz, 59.5Hz, 119Hz, 238Hz, 476Hz, 952Hz)
|
|
||||||
scale_gyro: 0-2 (245dps, 500dps, 2000dps )
|
|
||||||
scale_accel: 0-3 (+/-2g, +/-4g, +/-8g, +-16g)
|
|
||||||
"""
|
|
||||||
assert sample_rate <= 6, "invalid sampling rate: %d" % sample_rate
|
|
||||||
assert scale_gyro <= 2, "invalid gyro scaling: %d" % scale_gyro
|
|
||||||
assert scale_accel <= 3, "invalid accelerometer scaling: %d" % scale_accel
|
|
||||||
|
|
||||||
i2c = self.i2c
|
|
||||||
addr = self.address_gyro
|
|
||||||
mv = memoryview(self.scratch)
|
|
||||||
# angular control registers 1-3 / Orientation
|
|
||||||
mv[0] = ((sample_rate & 0x07) << 5) | ((_SCALE_GYRO[scale_gyro][1] & 0x3) << 3)
|
|
||||||
mv[1:4] = b"\x00\x00\x00"
|
|
||||||
i2c.writeto_mem(addr, _CTRL_REG1_G, mv[:5])
|
|
||||||
# ctrl4 - enable x,y,z, outputs, no irq latching, no 4D
|
|
||||||
# ctrl5 - enable all axes, no decimation
|
|
||||||
# ctrl6 - set scaling and sample rate of accel
|
|
||||||
# ctrl7,8 - leave at default values
|
|
||||||
# ctrl9 - FIFO enabled
|
|
||||||
mv[0] = mv[1] = 0x38
|
|
||||||
mv[2] = ((sample_rate & 7) << 5) | ((_SCALE_ACCEL[scale_accel][1] & 0x3) << 3)
|
|
||||||
mv[3] = 0x00
|
|
||||||
mv[4] = 0x4
|
|
||||||
mv[5] = 0x2
|
|
||||||
i2c.writeto_mem(addr, _CTRL_REG4_G, mv[:6])
|
|
||||||
|
|
||||||
# fifo: use continous mode (overwrite old data if overflow)
|
|
||||||
i2c.writeto_mem(addr, _FIFO_CTRL_REG, b"\x00")
|
|
||||||
i2c.writeto_mem(addr, _FIFO_CTRL_REG, b"\xc0")
|
|
||||||
|
|
||||||
self.scale_gyro = 32768 / _SCALE_GYRO[scale_gyro][0]
|
|
||||||
self.scale_accel = 32768 / _SCALE_ACCEL[scale_accel][0]
|
|
||||||
|
|
||||||
def init_magnetometer(self, sample_rate=7, scale_magnet=0):
|
|
||||||
"""
|
|
||||||
sample rates = 0-7 (0.625, 1.25, 2.5, 5, 10, 20, 40, 80Hz)
|
|
||||||
scaling = 0-3 (+/-4, +/-8, +/-12, +/-16 Gauss)
|
|
||||||
"""
|
|
||||||
assert sample_rate < 8, "invalid sample rate: %d (0-7)" % sample_rate
|
|
||||||
assert scale_magnet < 4, "invalid scaling: %d (0-3)" % scale_magnet
|
|
||||||
i2c = self.i2c
|
|
||||||
addr = self.address_magnet
|
|
||||||
mv = memoryview(self.scratch)
|
|
||||||
mv[0] = 0x40 | (sample_rate << 2) # ctrl1: high performance mode
|
|
||||||
mv[1] = scale_magnet << 5 # ctrl2: scale, normal mode, no reset
|
|
||||||
mv[2] = 0x00 # ctrl3: continous conversion, no low power, I2C
|
|
||||||
mv[3] = 0x08 # ctrl4: high performance z-axis
|
|
||||||
mv[4] = 0x00 # ctr5: no fast read, no block update
|
|
||||||
i2c.writeto_mem(addr, _CTRL_REG1_M, mv[:5])
|
|
||||||
self.scale_factor_magnet = 32768 / ((scale_magnet + 1) * 4)
|
|
||||||
|
|
||||||
def calibrate_magnet(self, offset):
|
|
||||||
"""
|
|
||||||
offset is a magnet vecor that will be substracted by the magnetometer
|
|
||||||
for each measurement. It is written to the magnetometer's offset register
|
|
||||||
"""
|
|
||||||
offset = [int(i * self.scale_factor_magnet) for i in offset]
|
|
||||||
mv = memoryview(self.scratch)
|
|
||||||
mv[0] = offset[0] & 0xFF
|
|
||||||
mv[1] = offset[0] >> 8
|
|
||||||
mv[2] = offset[1] & 0xFF
|
|
||||||
mv[3] = offset[1] >> 8
|
|
||||||
mv[4] = offset[2] & 0xFF
|
|
||||||
mv[5] = offset[2] >> 8
|
|
||||||
self.i2c.writeto_mem(self.address_magnet, _OFFSET_REG_X_M, mv[:6])
|
|
||||||
|
|
||||||
def gyro_id(self):
|
|
||||||
return self.i2c.readfrom_mem(self.address_gyro, _WHO_AM_I, 1)
|
|
||||||
|
|
||||||
def magent_id(self):
|
|
||||||
return self.i2c.readfrom_mem(self.address_magnet, _WHO_AM_I, 1)
|
|
||||||
|
|
||||||
def magnet(self):
|
|
||||||
"""Returns magnetometer vector in gauss.
|
|
||||||
raw_values: if True, the non-scaled adc values are returned
|
|
||||||
"""
|
|
||||||
mv = memoryview(self.scratch_int)
|
|
||||||
f = self.scale_factor_magnet
|
|
||||||
self.i2c.readfrom_mem_into(self.address_magnet, _OUT_M | 0x80, mv)
|
|
||||||
return (mv[0] / f, mv[1] / f, mv[2] / f)
|
|
||||||
|
|
||||||
def gyro(self):
|
|
||||||
"""Returns gyroscope vector in degrees/sec."""
|
|
||||||
mv = memoryview(self.scratch_int)
|
|
||||||
f = self.scale_gyro
|
|
||||||
self.i2c.readfrom_mem_into(self.address_gyro, _OUT_G | 0x80, mv)
|
|
||||||
return (mv[0] / f, mv[1] / f, mv[2] / f)
|
|
||||||
|
|
||||||
def accel(self):
|
|
||||||
"""Returns acceleration vector in gravity units (9.81m/s^2)."""
|
|
||||||
mv = memoryview(self.scratch_int)
|
|
||||||
f = self.scale_accel
|
|
||||||
self.i2c.readfrom_mem_into(self.address_gyro, _OUT_XL | 0x80, mv)
|
|
||||||
return (mv[0] / f, mv[1] / f, mv[2] / f)
|
|
||||||
|
|
||||||
def iter_accel_gyro(self):
|
|
||||||
"""A generator that returns tuples of (gyro,accelerometer) data from the fifo."""
|
|
||||||
while True:
|
|
||||||
fifo_state = int.from_bytes(
|
|
||||||
self.i2c.readfrom_mem(self.address_gyro, _FIFO_SRC, 1), "big"
|
|
||||||
)
|
|
||||||
if fifo_state & 0x3F:
|
|
||||||
# print("Available samples=%d" % (fifo_state & 0x1f))
|
|
||||||
yield self.gyro(), self.accel()
|
|
||||||
else:
|
|
||||||
break
|
|
||||||
@ -1 +0,0 @@
|
|||||||
module("lsm9ds1.py", opt=3)
|
|
||||||
@ -1 +0,0 @@
|
|||||||
module("neopixel.py", opt=3)
|
|
||||||
@ -1,50 +0,0 @@
|
|||||||
# NeoPixel driver for MicroPython
|
|
||||||
# MIT license; Copyright (c) 2016 Damien P. George, 2021 Jim Mussared
|
|
||||||
|
|
||||||
from machine import bitstream
|
|
||||||
|
|
||||||
|
|
||||||
class NeoPixel:
|
|
||||||
# G R B W
|
|
||||||
ORDER = (1, 0, 2, 3)
|
|
||||||
|
|
||||||
def __init__(self, pin, n, bpp=3, timing=1):
|
|
||||||
self.pin = pin
|
|
||||||
self.n = n
|
|
||||||
self.bpp = bpp
|
|
||||||
self.buf = bytearray(n * bpp)
|
|
||||||
self.pin.init(pin.OUT)
|
|
||||||
# Timing arg can either be 1 for 800kHz or 0 for 400kHz,
|
|
||||||
# or a user-specified timing ns tuple (high_0, low_0, high_1, low_1).
|
|
||||||
self.timing = (
|
|
||||||
((400, 850, 800, 450) if timing else (800, 1700, 1600, 900))
|
|
||||||
if isinstance(timing, int)
|
|
||||||
else timing
|
|
||||||
)
|
|
||||||
|
|
||||||
def __len__(self):
|
|
||||||
return self.n
|
|
||||||
|
|
||||||
def __setitem__(self, i, v):
|
|
||||||
offset = i * self.bpp
|
|
||||||
for i in range(self.bpp):
|
|
||||||
self.buf[offset + self.ORDER[i]] = v[i]
|
|
||||||
|
|
||||||
def __getitem__(self, i):
|
|
||||||
offset = i * self.bpp
|
|
||||||
return tuple(self.buf[offset + self.ORDER[i]] for i in range(self.bpp))
|
|
||||||
|
|
||||||
def fill(self, v):
|
|
||||||
b = self.buf
|
|
||||||
l = len(self.buf)
|
|
||||||
bpp = self.bpp
|
|
||||||
for i in range(bpp):
|
|
||||||
c = v[i]
|
|
||||||
j = self.ORDER[i]
|
|
||||||
while j < l:
|
|
||||||
b[j] = c
|
|
||||||
j += bpp
|
|
||||||
|
|
||||||
def write(self):
|
|
||||||
# BITSTREAM_TYPE_HIGH_LOW = 0
|
|
||||||
bitstream(self.pin, 0, self.timing, self.buf)
|
|
||||||
@ -1 +0,0 @@
|
|||||||
module("nrf24l01.py", opt=3)
|
|
||||||
@ -1,252 +0,0 @@
|
|||||||
"""NRF24L01 driver for MicroPython
|
|
||||||
"""
|
|
||||||
|
|
||||||
from micropython import const
|
|
||||||
import utime
|
|
||||||
|
|
||||||
# nRF24L01+ registers
|
|
||||||
CONFIG = const(0x00)
|
|
||||||
EN_RXADDR = const(0x02)
|
|
||||||
SETUP_AW = const(0x03)
|
|
||||||
SETUP_RETR = const(0x04)
|
|
||||||
RF_CH = const(0x05)
|
|
||||||
RF_SETUP = const(0x06)
|
|
||||||
STATUS = const(0x07)
|
|
||||||
RX_ADDR_P0 = const(0x0A)
|
|
||||||
TX_ADDR = const(0x10)
|
|
||||||
RX_PW_P0 = const(0x11)
|
|
||||||
FIFO_STATUS = const(0x17)
|
|
||||||
DYNPD = const(0x1C)
|
|
||||||
|
|
||||||
# CONFIG register
|
|
||||||
EN_CRC = const(0x08) # enable CRC
|
|
||||||
CRCO = const(0x04) # CRC encoding scheme; 0=1 byte, 1=2 bytes
|
|
||||||
PWR_UP = const(0x02) # 1=power up, 0=power down
|
|
||||||
PRIM_RX = const(0x01) # RX/TX control; 0=PTX, 1=PRX
|
|
||||||
|
|
||||||
# RF_SETUP register
|
|
||||||
POWER_0 = const(0x00) # -18 dBm
|
|
||||||
POWER_1 = const(0x02) # -12 dBm
|
|
||||||
POWER_2 = const(0x04) # -6 dBm
|
|
||||||
POWER_3 = const(0x06) # 0 dBm
|
|
||||||
SPEED_1M = const(0x00)
|
|
||||||
SPEED_2M = const(0x08)
|
|
||||||
SPEED_250K = const(0x20)
|
|
||||||
|
|
||||||
# STATUS register
|
|
||||||
RX_DR = const(0x40) # RX data ready; write 1 to clear
|
|
||||||
TX_DS = const(0x20) # TX data sent; write 1 to clear
|
|
||||||
MAX_RT = const(0x10) # max retransmits reached; write 1 to clear
|
|
||||||
|
|
||||||
# FIFO_STATUS register
|
|
||||||
RX_EMPTY = const(0x01) # 1 if RX FIFO is empty
|
|
||||||
|
|
||||||
# constants for instructions
|
|
||||||
R_RX_PL_WID = const(0x60) # read RX payload width
|
|
||||||
R_RX_PAYLOAD = const(0x61) # read RX payload
|
|
||||||
W_TX_PAYLOAD = const(0xA0) # write TX payload
|
|
||||||
FLUSH_TX = const(0xE1) # flush TX FIFO
|
|
||||||
FLUSH_RX = const(0xE2) # flush RX FIFO
|
|
||||||
NOP = const(0xFF) # use to read STATUS register
|
|
||||||
|
|
||||||
|
|
||||||
class NRF24L01:
|
|
||||||
def __init__(self, spi, cs, ce, channel=46, payload_size=16):
|
|
||||||
assert payload_size <= 32
|
|
||||||
|
|
||||||
self.buf = bytearray(1)
|
|
||||||
|
|
||||||
# store the pins
|
|
||||||
self.spi = spi
|
|
||||||
self.cs = cs
|
|
||||||
self.ce = ce
|
|
||||||
|
|
||||||
# init the SPI bus and pins
|
|
||||||
self.init_spi(4000000)
|
|
||||||
|
|
||||||
# reset everything
|
|
||||||
ce.init(ce.OUT, value=0)
|
|
||||||
cs.init(cs.OUT, value=1)
|
|
||||||
|
|
||||||
self.payload_size = payload_size
|
|
||||||
self.pipe0_read_addr = None
|
|
||||||
utime.sleep_ms(5)
|
|
||||||
|
|
||||||
# set address width to 5 bytes and check for device present
|
|
||||||
self.reg_write(SETUP_AW, 0b11)
|
|
||||||
if self.reg_read(SETUP_AW) != 0b11:
|
|
||||||
raise OSError("nRF24L01+ Hardware not responding")
|
|
||||||
|
|
||||||
# disable dynamic payloads
|
|
||||||
self.reg_write(DYNPD, 0)
|
|
||||||
|
|
||||||
# auto retransmit delay: 1750us
|
|
||||||
# auto retransmit count: 8
|
|
||||||
self.reg_write(SETUP_RETR, (6 << 4) | 8)
|
|
||||||
|
|
||||||
# set rf power and speed
|
|
||||||
self.set_power_speed(POWER_3, SPEED_250K) # Best for point to point links
|
|
||||||
|
|
||||||
# init CRC
|
|
||||||
self.set_crc(2)
|
|
||||||
|
|
||||||
# clear status flags
|
|
||||||
self.reg_write(STATUS, RX_DR | TX_DS | MAX_RT)
|
|
||||||
|
|
||||||
# set channel
|
|
||||||
self.set_channel(channel)
|
|
||||||
|
|
||||||
# flush buffers
|
|
||||||
self.flush_rx()
|
|
||||||
self.flush_tx()
|
|
||||||
|
|
||||||
def init_spi(self, baudrate):
|
|
||||||
try:
|
|
||||||
master = self.spi.MASTER
|
|
||||||
except AttributeError:
|
|
||||||
self.spi.init(baudrate=baudrate, polarity=0, phase=0)
|
|
||||||
else:
|
|
||||||
self.spi.init(master, baudrate=baudrate, polarity=0, phase=0)
|
|
||||||
|
|
||||||
def reg_read(self, reg):
|
|
||||||
self.cs(0)
|
|
||||||
self.spi.readinto(self.buf, reg)
|
|
||||||
self.spi.readinto(self.buf)
|
|
||||||
self.cs(1)
|
|
||||||
return self.buf[0]
|
|
||||||
|
|
||||||
def reg_write_bytes(self, reg, buf):
|
|
||||||
self.cs(0)
|
|
||||||
self.spi.readinto(self.buf, 0x20 | reg)
|
|
||||||
self.spi.write(buf)
|
|
||||||
self.cs(1)
|
|
||||||
return self.buf[0]
|
|
||||||
|
|
||||||
def reg_write(self, reg, value):
|
|
||||||
self.cs(0)
|
|
||||||
self.spi.readinto(self.buf, 0x20 | reg)
|
|
||||||
ret = self.buf[0]
|
|
||||||
self.spi.readinto(self.buf, value)
|
|
||||||
self.cs(1)
|
|
||||||
return ret
|
|
||||||
|
|
||||||
def flush_rx(self):
|
|
||||||
self.cs(0)
|
|
||||||
self.spi.readinto(self.buf, FLUSH_RX)
|
|
||||||
self.cs(1)
|
|
||||||
|
|
||||||
def flush_tx(self):
|
|
||||||
self.cs(0)
|
|
||||||
self.spi.readinto(self.buf, FLUSH_TX)
|
|
||||||
self.cs(1)
|
|
||||||
|
|
||||||
# power is one of POWER_x defines; speed is one of SPEED_x defines
|
|
||||||
def set_power_speed(self, power, speed):
|
|
||||||
setup = self.reg_read(RF_SETUP) & 0b11010001
|
|
||||||
self.reg_write(RF_SETUP, setup | power | speed)
|
|
||||||
|
|
||||||
# length in bytes: 0, 1 or 2
|
|
||||||
def set_crc(self, length):
|
|
||||||
config = self.reg_read(CONFIG) & ~(CRCO | EN_CRC)
|
|
||||||
if length == 0:
|
|
||||||
pass
|
|
||||||
elif length == 1:
|
|
||||||
config |= EN_CRC
|
|
||||||
else:
|
|
||||||
config |= EN_CRC | CRCO
|
|
||||||
self.reg_write(CONFIG, config)
|
|
||||||
|
|
||||||
def set_channel(self, channel):
|
|
||||||
self.reg_write(RF_CH, min(channel, 125))
|
|
||||||
|
|
||||||
# address should be a bytes object 5 bytes long
|
|
||||||
def open_tx_pipe(self, address):
|
|
||||||
assert len(address) == 5
|
|
||||||
self.reg_write_bytes(RX_ADDR_P0, address)
|
|
||||||
self.reg_write_bytes(TX_ADDR, address)
|
|
||||||
self.reg_write(RX_PW_P0, self.payload_size)
|
|
||||||
|
|
||||||
# address should be a bytes object 5 bytes long
|
|
||||||
# pipe 0 and 1 have 5 byte address
|
|
||||||
# pipes 2-5 use same 4 most-significant bytes as pipe 1, plus 1 extra byte
|
|
||||||
def open_rx_pipe(self, pipe_id, address):
|
|
||||||
assert len(address) == 5
|
|
||||||
assert 0 <= pipe_id <= 5
|
|
||||||
if pipe_id == 0:
|
|
||||||
self.pipe0_read_addr = address
|
|
||||||
if pipe_id < 2:
|
|
||||||
self.reg_write_bytes(RX_ADDR_P0 + pipe_id, address)
|
|
||||||
else:
|
|
||||||
self.reg_write(RX_ADDR_P0 + pipe_id, address[0])
|
|
||||||
self.reg_write(RX_PW_P0 + pipe_id, self.payload_size)
|
|
||||||
self.reg_write(EN_RXADDR, self.reg_read(EN_RXADDR) | (1 << pipe_id))
|
|
||||||
|
|
||||||
def start_listening(self):
|
|
||||||
self.reg_write(CONFIG, self.reg_read(CONFIG) | PWR_UP | PRIM_RX)
|
|
||||||
self.reg_write(STATUS, RX_DR | TX_DS | MAX_RT)
|
|
||||||
|
|
||||||
if self.pipe0_read_addr is not None:
|
|
||||||
self.reg_write_bytes(RX_ADDR_P0, self.pipe0_read_addr)
|
|
||||||
|
|
||||||
self.flush_rx()
|
|
||||||
self.flush_tx()
|
|
||||||
self.ce(1)
|
|
||||||
utime.sleep_us(130)
|
|
||||||
|
|
||||||
def stop_listening(self):
|
|
||||||
self.ce(0)
|
|
||||||
self.flush_tx()
|
|
||||||
self.flush_rx()
|
|
||||||
|
|
||||||
# returns True if any data available to recv
|
|
||||||
def any(self):
|
|
||||||
return not bool(self.reg_read(FIFO_STATUS) & RX_EMPTY)
|
|
||||||
|
|
||||||
def recv(self):
|
|
||||||
# get the data
|
|
||||||
self.cs(0)
|
|
||||||
self.spi.readinto(self.buf, R_RX_PAYLOAD)
|
|
||||||
buf = self.spi.read(self.payload_size)
|
|
||||||
self.cs(1)
|
|
||||||
# clear RX ready flag
|
|
||||||
self.reg_write(STATUS, RX_DR)
|
|
||||||
|
|
||||||
return buf
|
|
||||||
|
|
||||||
# blocking wait for tx complete
|
|
||||||
def send(self, buf, timeout=500):
|
|
||||||
self.send_start(buf)
|
|
||||||
start = utime.ticks_ms()
|
|
||||||
result = None
|
|
||||||
while result is None and utime.ticks_diff(utime.ticks_ms(), start) < timeout:
|
|
||||||
result = self.send_done() # 1 == success, 2 == fail
|
|
||||||
if result == 2:
|
|
||||||
raise OSError("send failed")
|
|
||||||
|
|
||||||
# non-blocking tx
|
|
||||||
def send_start(self, buf):
|
|
||||||
# power up
|
|
||||||
self.reg_write(CONFIG, (self.reg_read(CONFIG) | PWR_UP) & ~PRIM_RX)
|
|
||||||
utime.sleep_us(150)
|
|
||||||
# send the data
|
|
||||||
self.cs(0)
|
|
||||||
self.spi.readinto(self.buf, W_TX_PAYLOAD)
|
|
||||||
self.spi.write(buf)
|
|
||||||
if len(buf) < self.payload_size:
|
|
||||||
self.spi.write(b"\x00" * (self.payload_size - len(buf))) # pad out data
|
|
||||||
self.cs(1)
|
|
||||||
|
|
||||||
# enable the chip so it can send the data
|
|
||||||
self.ce(1)
|
|
||||||
utime.sleep_us(15) # needs to be >10us
|
|
||||||
self.ce(0)
|
|
||||||
|
|
||||||
# returns None if send still in progress, 1 for success, 2 for fail
|
|
||||||
def send_done(self):
|
|
||||||
if not (self.reg_read(STATUS) & (TX_DS | MAX_RT)):
|
|
||||||
return None # tx not finished
|
|
||||||
|
|
||||||
# either finished or failed: get and clear status flags, power down
|
|
||||||
status = self.reg_write(STATUS, RX_DR | TX_DS | MAX_RT)
|
|
||||||
self.reg_write(CONFIG, self.reg_read(CONFIG) & ~PWR_UP)
|
|
||||||
return 1 if status & TX_DS else 2
|
|
||||||
@ -1,150 +0,0 @@
|
|||||||
"""Test for nrf24l01 module. Portable between MicroPython targets."""
|
|
||||||
|
|
||||||
import usys
|
|
||||||
import ustruct as struct
|
|
||||||
import utime
|
|
||||||
from machine import Pin, SPI
|
|
||||||
from nrf24l01 import NRF24L01
|
|
||||||
from micropython import const
|
|
||||||
|
|
||||||
# Slave pause between receiving data and checking for further packets.
|
|
||||||
_RX_POLL_DELAY = const(15)
|
|
||||||
# Slave pauses an additional _SLAVE_SEND_DELAY ms after receiving data and before
|
|
||||||
# transmitting to allow the (remote) master time to get into receive mode. The
|
|
||||||
# master may be a slow device. Value tested with Pyboard, ESP32 and ESP8266.
|
|
||||||
_SLAVE_SEND_DELAY = const(10)
|
|
||||||
|
|
||||||
if usys.platform == "pyboard":
|
|
||||||
cfg = {"spi": 2, "miso": "Y7", "mosi": "Y8", "sck": "Y6", "csn": "Y5", "ce": "Y4"}
|
|
||||||
elif usys.platform == "esp8266": # Hardware SPI
|
|
||||||
cfg = {"spi": 1, "miso": 12, "mosi": 13, "sck": 14, "csn": 4, "ce": 5}
|
|
||||||
elif usys.platform == "esp32": # Software SPI
|
|
||||||
cfg = {"spi": -1, "miso": 32, "mosi": 33, "sck": 25, "csn": 26, "ce": 27}
|
|
||||||
else:
|
|
||||||
raise ValueError("Unsupported platform {}".format(usys.platform))
|
|
||||||
|
|
||||||
# Addresses are in little-endian format. They correspond to big-endian
|
|
||||||
# 0xf0f0f0f0e1, 0xf0f0f0f0d2
|
|
||||||
pipes = (b"\xe1\xf0\xf0\xf0\xf0", b"\xd2\xf0\xf0\xf0\xf0")
|
|
||||||
|
|
||||||
|
|
||||||
def master():
|
|
||||||
csn = Pin(cfg["csn"], mode=Pin.OUT, value=1)
|
|
||||||
ce = Pin(cfg["ce"], mode=Pin.OUT, value=0)
|
|
||||||
if cfg["spi"] == -1:
|
|
||||||
spi = SPI(-1, sck=Pin(cfg["sck"]), mosi=Pin(cfg["mosi"]), miso=Pin(cfg["miso"]))
|
|
||||||
nrf = NRF24L01(spi, csn, ce, payload_size=8)
|
|
||||||
else:
|
|
||||||
nrf = NRF24L01(SPI(cfg["spi"]), csn, ce, payload_size=8)
|
|
||||||
|
|
||||||
nrf.open_tx_pipe(pipes[0])
|
|
||||||
nrf.open_rx_pipe(1, pipes[1])
|
|
||||||
nrf.start_listening()
|
|
||||||
|
|
||||||
num_needed = 16
|
|
||||||
num_successes = 0
|
|
||||||
num_failures = 0
|
|
||||||
led_state = 0
|
|
||||||
|
|
||||||
print("NRF24L01 master mode, sending %d packets..." % num_needed)
|
|
||||||
|
|
||||||
while num_successes < num_needed and num_failures < num_needed:
|
|
||||||
# stop listening and send packet
|
|
||||||
nrf.stop_listening()
|
|
||||||
millis = utime.ticks_ms()
|
|
||||||
led_state = max(1, (led_state << 1) & 0x0F)
|
|
||||||
print("sending:", millis, led_state)
|
|
||||||
try:
|
|
||||||
nrf.send(struct.pack("ii", millis, led_state))
|
|
||||||
except OSError:
|
|
||||||
pass
|
|
||||||
|
|
||||||
# start listening again
|
|
||||||
nrf.start_listening()
|
|
||||||
|
|
||||||
# wait for response, with 250ms timeout
|
|
||||||
start_time = utime.ticks_ms()
|
|
||||||
timeout = False
|
|
||||||
while not nrf.any() and not timeout:
|
|
||||||
if utime.ticks_diff(utime.ticks_ms(), start_time) > 250:
|
|
||||||
timeout = True
|
|
||||||
|
|
||||||
if timeout:
|
|
||||||
print("failed, response timed out")
|
|
||||||
num_failures += 1
|
|
||||||
|
|
||||||
else:
|
|
||||||
# recv packet
|
|
||||||
(got_millis,) = struct.unpack("i", nrf.recv())
|
|
||||||
|
|
||||||
# print response and round-trip delay
|
|
||||||
print(
|
|
||||||
"got response:",
|
|
||||||
got_millis,
|
|
||||||
"(delay",
|
|
||||||
utime.ticks_diff(utime.ticks_ms(), got_millis),
|
|
||||||
"ms)",
|
|
||||||
)
|
|
||||||
num_successes += 1
|
|
||||||
|
|
||||||
# delay then loop
|
|
||||||
utime.sleep_ms(250)
|
|
||||||
|
|
||||||
print("master finished sending; successes=%d, failures=%d" % (num_successes, num_failures))
|
|
||||||
|
|
||||||
|
|
||||||
def slave():
|
|
||||||
csn = Pin(cfg["csn"], mode=Pin.OUT, value=1)
|
|
||||||
ce = Pin(cfg["ce"], mode=Pin.OUT, value=0)
|
|
||||||
if cfg["spi"] == -1:
|
|
||||||
spi = SPI(-1, sck=Pin(cfg["sck"]), mosi=Pin(cfg["mosi"]), miso=Pin(cfg["miso"]))
|
|
||||||
nrf = NRF24L01(spi, csn, ce, payload_size=8)
|
|
||||||
else:
|
|
||||||
nrf = NRF24L01(SPI(cfg["spi"]), csn, ce, payload_size=8)
|
|
||||||
|
|
||||||
nrf.open_tx_pipe(pipes[1])
|
|
||||||
nrf.open_rx_pipe(1, pipes[0])
|
|
||||||
nrf.start_listening()
|
|
||||||
|
|
||||||
print("NRF24L01 slave mode, waiting for packets... (ctrl-C to stop)")
|
|
||||||
|
|
||||||
while True:
|
|
||||||
if nrf.any():
|
|
||||||
while nrf.any():
|
|
||||||
buf = nrf.recv()
|
|
||||||
millis, led_state = struct.unpack("ii", buf)
|
|
||||||
print("received:", millis, led_state)
|
|
||||||
for led in leds:
|
|
||||||
if led_state & 1:
|
|
||||||
led.on()
|
|
||||||
else:
|
|
||||||
led.off()
|
|
||||||
led_state >>= 1
|
|
||||||
utime.sleep_ms(_RX_POLL_DELAY)
|
|
||||||
|
|
||||||
# Give master time to get into receive mode.
|
|
||||||
utime.sleep_ms(_SLAVE_SEND_DELAY)
|
|
||||||
nrf.stop_listening()
|
|
||||||
try:
|
|
||||||
nrf.send(struct.pack("i", millis))
|
|
||||||
except OSError:
|
|
||||||
pass
|
|
||||||
print("sent response")
|
|
||||||
nrf.start_listening()
|
|
||||||
|
|
||||||
|
|
||||||
try:
|
|
||||||
import pyb
|
|
||||||
|
|
||||||
leds = [pyb.LED(i + 1) for i in range(4)]
|
|
||||||
except:
|
|
||||||
leds = []
|
|
||||||
|
|
||||||
print("NRF24L01 test module loaded")
|
|
||||||
print("NRF24L01 pinout for test:")
|
|
||||||
print(" CE on", cfg["ce"])
|
|
||||||
print(" CSN on", cfg["csn"])
|
|
||||||
print(" SCK on", cfg["sck"])
|
|
||||||
print(" MISO on", cfg["miso"])
|
|
||||||
print(" MOSI on", cfg["mosi"])
|
|
||||||
print("run nrf24l01test.slave() on slave, then nrf24l01test.master() on master")
|
|
||||||
@ -1,52 +0,0 @@
|
|||||||
# DS18x20 temperature sensor driver for MicroPython.
|
|
||||||
# MIT license; Copyright (c) 2016 Damien P. George
|
|
||||||
|
|
||||||
from micropython import const
|
|
||||||
|
|
||||||
_CONVERT = const(0x44)
|
|
||||||
_RD_SCRATCH = const(0xBE)
|
|
||||||
_WR_SCRATCH = const(0x4E)
|
|
||||||
|
|
||||||
|
|
||||||
class DS18X20:
|
|
||||||
def __init__(self, onewire):
|
|
||||||
self.ow = onewire
|
|
||||||
self.buf = bytearray(9)
|
|
||||||
|
|
||||||
def scan(self):
|
|
||||||
return [rom for rom in self.ow.scan() if rom[0] in (0x10, 0x22, 0x28)]
|
|
||||||
|
|
||||||
def convert_temp(self):
|
|
||||||
self.ow.reset(True)
|
|
||||||
self.ow.writebyte(self.ow.SKIP_ROM)
|
|
||||||
self.ow.writebyte(_CONVERT)
|
|
||||||
|
|
||||||
def read_scratch(self, rom):
|
|
||||||
self.ow.reset(True)
|
|
||||||
self.ow.select_rom(rom)
|
|
||||||
self.ow.writebyte(_RD_SCRATCH)
|
|
||||||
self.ow.readinto(self.buf)
|
|
||||||
if self.ow.crc8(self.buf):
|
|
||||||
raise Exception("CRC error")
|
|
||||||
return self.buf
|
|
||||||
|
|
||||||
def write_scratch(self, rom, buf):
|
|
||||||
self.ow.reset(True)
|
|
||||||
self.ow.select_rom(rom)
|
|
||||||
self.ow.writebyte(_WR_SCRATCH)
|
|
||||||
self.ow.write(buf)
|
|
||||||
|
|
||||||
def read_temp(self, rom):
|
|
||||||
buf = self.read_scratch(rom)
|
|
||||||
if rom[0] == 0x10:
|
|
||||||
if buf[1]:
|
|
||||||
t = buf[0] >> 1 | 0x80
|
|
||||||
t = -((~t + 1) & 0xFF)
|
|
||||||
else:
|
|
||||||
t = buf[0] >> 1
|
|
||||||
return t - 0.25 + (buf[7] - buf[6]) / buf[7]
|
|
||||||
else:
|
|
||||||
t = buf[1] << 8 | buf[0]
|
|
||||||
if t & 0x8000: # sign bit set
|
|
||||||
t = -((t ^ 0xFFFF) + 1)
|
|
||||||
return t / 16
|
|
||||||
@ -1,6 +0,0 @@
|
|||||||
options.defaults(ds18x20=False)
|
|
||||||
|
|
||||||
module("onewire.py", opt=3)
|
|
||||||
|
|
||||||
if options.ds18x20:
|
|
||||||
module("ds18x20.py", opt=3)
|
|
||||||
@ -1,92 +0,0 @@
|
|||||||
# 1-Wire driver for MicroPython
|
|
||||||
# MIT license; Copyright (c) 2016 Damien P. George
|
|
||||||
|
|
||||||
import _onewire as _ow
|
|
||||||
|
|
||||||
|
|
||||||
class OneWireError(Exception):
|
|
||||||
pass
|
|
||||||
|
|
||||||
|
|
||||||
class OneWire:
|
|
||||||
SEARCH_ROM = 0xF0
|
|
||||||
MATCH_ROM = 0x55
|
|
||||||
SKIP_ROM = 0xCC
|
|
||||||
|
|
||||||
def __init__(self, pin):
|
|
||||||
self.pin = pin
|
|
||||||
self.pin.init(pin.OPEN_DRAIN, pin.PULL_UP)
|
|
||||||
|
|
||||||
def reset(self, required=False):
|
|
||||||
reset = _ow.reset(self.pin)
|
|
||||||
if required and not reset:
|
|
||||||
raise OneWireError
|
|
||||||
return reset
|
|
||||||
|
|
||||||
def readbit(self):
|
|
||||||
return _ow.readbit(self.pin)
|
|
||||||
|
|
||||||
def readbyte(self):
|
|
||||||
return _ow.readbyte(self.pin)
|
|
||||||
|
|
||||||
def readinto(self, buf):
|
|
||||||
for i in range(len(buf)):
|
|
||||||
buf[i] = _ow.readbyte(self.pin)
|
|
||||||
|
|
||||||
def writebit(self, value):
|
|
||||||
return _ow.writebit(self.pin, value)
|
|
||||||
|
|
||||||
def writebyte(self, value):
|
|
||||||
return _ow.writebyte(self.pin, value)
|
|
||||||
|
|
||||||
def write(self, buf):
|
|
||||||
for b in buf:
|
|
||||||
_ow.writebyte(self.pin, b)
|
|
||||||
|
|
||||||
def select_rom(self, rom):
|
|
||||||
self.reset()
|
|
||||||
self.writebyte(self.MATCH_ROM)
|
|
||||||
self.write(rom)
|
|
||||||
|
|
||||||
def scan(self):
|
|
||||||
devices = []
|
|
||||||
diff = 65
|
|
||||||
rom = False
|
|
||||||
for i in range(0xFF):
|
|
||||||
rom, diff = self._search_rom(rom, diff)
|
|
||||||
if rom:
|
|
||||||
devices += [rom]
|
|
||||||
if diff == 0:
|
|
||||||
break
|
|
||||||
return devices
|
|
||||||
|
|
||||||
def _search_rom(self, l_rom, diff):
|
|
||||||
if not self.reset():
|
|
||||||
return None, 0
|
|
||||||
self.writebyte(self.SEARCH_ROM)
|
|
||||||
if not l_rom:
|
|
||||||
l_rom = bytearray(8)
|
|
||||||
rom = bytearray(8)
|
|
||||||
next_diff = 0
|
|
||||||
i = 64
|
|
||||||
for byte in range(8):
|
|
||||||
r_b = 0
|
|
||||||
for bit in range(8):
|
|
||||||
b = self.readbit()
|
|
||||||
if self.readbit():
|
|
||||||
if b: # there are no devices or there is an error on the bus
|
|
||||||
return None, 0
|
|
||||||
else:
|
|
||||||
if not b: # collision, two devices with different bit meaning
|
|
||||||
if diff > i or ((l_rom[byte] & (1 << bit)) and diff != i):
|
|
||||||
b = 1
|
|
||||||
next_diff = i
|
|
||||||
self.writebit(b)
|
|
||||||
if b:
|
|
||||||
r_b |= 1 << bit
|
|
||||||
i -= 1
|
|
||||||
rom[byte] = r_b
|
|
||||||
return rom, next_diff
|
|
||||||
|
|
||||||
def crc8(self, data):
|
|
||||||
return _ow.crc8(data)
|
|
||||||
@ -1 +0,0 @@
|
|||||||
module("sdcard.py", opt=3)
|
|
||||||
@ -1,299 +0,0 @@
|
|||||||
"""
|
|
||||||
MicroPython driver for SD cards using SPI bus.
|
|
||||||
|
|
||||||
Requires an SPI bus and a CS pin. Provides readblocks and writeblocks
|
|
||||||
methods so the device can be mounted as a filesystem.
|
|
||||||
|
|
||||||
Example usage on pyboard:
|
|
||||||
|
|
||||||
import pyb, sdcard, os
|
|
||||||
sd = sdcard.SDCard(pyb.SPI(1), pyb.Pin.board.X5)
|
|
||||||
pyb.mount(sd, '/sd2')
|
|
||||||
os.listdir('/')
|
|
||||||
|
|
||||||
Example usage on ESP8266:
|
|
||||||
|
|
||||||
import machine, sdcard, os
|
|
||||||
sd = sdcard.SDCard(machine.SPI(1), machine.Pin(15))
|
|
||||||
os.mount(sd, '/sd')
|
|
||||||
os.listdir('/')
|
|
||||||
|
|
||||||
"""
|
|
||||||
|
|
||||||
from micropython import const
|
|
||||||
import time
|
|
||||||
|
|
||||||
|
|
||||||
_CMD_TIMEOUT = const(100)
|
|
||||||
|
|
||||||
_R1_IDLE_STATE = const(1 << 0)
|
|
||||||
# R1_ERASE_RESET = const(1 << 1)
|
|
||||||
_R1_ILLEGAL_COMMAND = const(1 << 2)
|
|
||||||
# R1_COM_CRC_ERROR = const(1 << 3)
|
|
||||||
# R1_ERASE_SEQUENCE_ERROR = const(1 << 4)
|
|
||||||
# R1_ADDRESS_ERROR = const(1 << 5)
|
|
||||||
# R1_PARAMETER_ERROR = const(1 << 6)
|
|
||||||
_TOKEN_CMD25 = const(0xFC)
|
|
||||||
_TOKEN_STOP_TRAN = const(0xFD)
|
|
||||||
_TOKEN_DATA = const(0xFE)
|
|
||||||
|
|
||||||
|
|
||||||
class SDCard:
|
|
||||||
def __init__(self, spi, cs, baudrate=1320000):
|
|
||||||
self.spi = spi
|
|
||||||
self.cs = cs
|
|
||||||
|
|
||||||
self.cmdbuf = bytearray(6)
|
|
||||||
self.dummybuf = bytearray(512)
|
|
||||||
self.tokenbuf = bytearray(1)
|
|
||||||
for i in range(512):
|
|
||||||
self.dummybuf[i] = 0xFF
|
|
||||||
self.dummybuf_memoryview = memoryview(self.dummybuf)
|
|
||||||
|
|
||||||
# initialise the card
|
|
||||||
self.init_card(baudrate)
|
|
||||||
|
|
||||||
def init_spi(self, baudrate):
|
|
||||||
try:
|
|
||||||
master = self.spi.MASTER
|
|
||||||
except AttributeError:
|
|
||||||
# on ESP8266
|
|
||||||
self.spi.init(baudrate=baudrate, phase=0, polarity=0)
|
|
||||||
else:
|
|
||||||
# on pyboard
|
|
||||||
self.spi.init(master, baudrate=baudrate, phase=0, polarity=0)
|
|
||||||
|
|
||||||
def init_card(self, baudrate):
|
|
||||||
|
|
||||||
# init CS pin
|
|
||||||
self.cs.init(self.cs.OUT, value=1)
|
|
||||||
|
|
||||||
# init SPI bus; use low data rate for initialisation
|
|
||||||
self.init_spi(100000)
|
|
||||||
|
|
||||||
# clock card at least 100 cycles with cs high
|
|
||||||
for i in range(16):
|
|
||||||
self.spi.write(b"\xff")
|
|
||||||
|
|
||||||
# CMD0: init card; should return _R1_IDLE_STATE (allow 5 attempts)
|
|
||||||
for _ in range(5):
|
|
||||||
if self.cmd(0, 0, 0x95) == _R1_IDLE_STATE:
|
|
||||||
break
|
|
||||||
else:
|
|
||||||
raise OSError("no SD card")
|
|
||||||
|
|
||||||
# CMD8: determine card version
|
|
||||||
r = self.cmd(8, 0x01AA, 0x87, 4)
|
|
||||||
if r == _R1_IDLE_STATE:
|
|
||||||
self.init_card_v2()
|
|
||||||
elif r == (_R1_IDLE_STATE | _R1_ILLEGAL_COMMAND):
|
|
||||||
self.init_card_v1()
|
|
||||||
else:
|
|
||||||
raise OSError("couldn't determine SD card version")
|
|
||||||
|
|
||||||
# get the number of sectors
|
|
||||||
# CMD9: response R2 (R1 byte + 16-byte block read)
|
|
||||||
if self.cmd(9, 0, 0, 0, False) != 0:
|
|
||||||
raise OSError("no response from SD card")
|
|
||||||
csd = bytearray(16)
|
|
||||||
self.readinto(csd)
|
|
||||||
if csd[0] & 0xC0 == 0x40: # CSD version 2.0
|
|
||||||
self.sectors = ((csd[8] << 8 | csd[9]) + 1) * 1024
|
|
||||||
elif csd[0] & 0xC0 == 0x00: # CSD version 1.0 (old, <=2GB)
|
|
||||||
c_size = (csd[6] & 0b11) << 10 | csd[7] << 2 | csd[8] >> 6
|
|
||||||
c_size_mult = (csd[9] & 0b11) << 1 | csd[10] >> 7
|
|
||||||
read_bl_len = csd[5] & 0b1111
|
|
||||||
capacity = (c_size + 1) * (2 ** (c_size_mult + 2)) * (2**read_bl_len)
|
|
||||||
self.sectors = capacity // 512
|
|
||||||
else:
|
|
||||||
raise OSError("SD card CSD format not supported")
|
|
||||||
# print('sectors', self.sectors)
|
|
||||||
|
|
||||||
# CMD16: set block length to 512 bytes
|
|
||||||
if self.cmd(16, 512, 0) != 0:
|
|
||||||
raise OSError("can't set 512 block size")
|
|
||||||
|
|
||||||
# set to high data rate now that it's initialised
|
|
||||||
self.init_spi(baudrate)
|
|
||||||
|
|
||||||
def init_card_v1(self):
|
|
||||||
for i in range(_CMD_TIMEOUT):
|
|
||||||
time.sleep_ms(50)
|
|
||||||
self.cmd(55, 0, 0)
|
|
||||||
if self.cmd(41, 0, 0) == 0:
|
|
||||||
# SDSC card, uses byte addressing in read/write/erase commands
|
|
||||||
self.cdv = 512
|
|
||||||
# print("[SDCard] v1 card")
|
|
||||||
return
|
|
||||||
raise OSError("timeout waiting for v1 card")
|
|
||||||
|
|
||||||
def init_card_v2(self):
|
|
||||||
for i in range(_CMD_TIMEOUT):
|
|
||||||
time.sleep_ms(50)
|
|
||||||
self.cmd(58, 0, 0, 4)
|
|
||||||
self.cmd(55, 0, 0)
|
|
||||||
if self.cmd(41, 0x40000000, 0) == 0:
|
|
||||||
self.cmd(58, 0, 0, -4) # 4-byte response, negative means keep the first byte
|
|
||||||
ocr = self.tokenbuf[0] # get first byte of response, which is OCR
|
|
||||||
if not ocr & 0x40:
|
|
||||||
# SDSC card, uses byte addressing in read/write/erase commands
|
|
||||||
self.cdv = 512
|
|
||||||
else:
|
|
||||||
# SDHC/SDXC card, uses block addressing in read/write/erase commands
|
|
||||||
self.cdv = 1
|
|
||||||
# print("[SDCard] v2 card")
|
|
||||||
return
|
|
||||||
raise OSError("timeout waiting for v2 card")
|
|
||||||
|
|
||||||
def cmd(self, cmd, arg, crc, final=0, release=True, skip1=False):
|
|
||||||
self.cs(0)
|
|
||||||
|
|
||||||
# create and send the command
|
|
||||||
buf = self.cmdbuf
|
|
||||||
buf[0] = 0x40 | cmd
|
|
||||||
buf[1] = arg >> 24
|
|
||||||
buf[2] = arg >> 16
|
|
||||||
buf[3] = arg >> 8
|
|
||||||
buf[4] = arg
|
|
||||||
buf[5] = crc
|
|
||||||
self.spi.write(buf)
|
|
||||||
|
|
||||||
if skip1:
|
|
||||||
self.spi.readinto(self.tokenbuf, 0xFF)
|
|
||||||
|
|
||||||
# wait for the response (response[7] == 0)
|
|
||||||
for i in range(_CMD_TIMEOUT):
|
|
||||||
self.spi.readinto(self.tokenbuf, 0xFF)
|
|
||||||
response = self.tokenbuf[0]
|
|
||||||
if not (response & 0x80):
|
|
||||||
# this could be a big-endian integer that we are getting here
|
|
||||||
# if final<0 then store the first byte to tokenbuf and discard the rest
|
|
||||||
if final < 0:
|
|
||||||
self.spi.readinto(self.tokenbuf, 0xFF)
|
|
||||||
final = -1 - final
|
|
||||||
for j in range(final):
|
|
||||||
self.spi.write(b"\xff")
|
|
||||||
if release:
|
|
||||||
self.cs(1)
|
|
||||||
self.spi.write(b"\xff")
|
|
||||||
return response
|
|
||||||
|
|
||||||
# timeout
|
|
||||||
self.cs(1)
|
|
||||||
self.spi.write(b"\xff")
|
|
||||||
return -1
|
|
||||||
|
|
||||||
def readinto(self, buf):
|
|
||||||
self.cs(0)
|
|
||||||
|
|
||||||
# read until start byte (0xff)
|
|
||||||
for i in range(_CMD_TIMEOUT):
|
|
||||||
self.spi.readinto(self.tokenbuf, 0xFF)
|
|
||||||
if self.tokenbuf[0] == _TOKEN_DATA:
|
|
||||||
break
|
|
||||||
time.sleep_ms(1)
|
|
||||||
else:
|
|
||||||
self.cs(1)
|
|
||||||
raise OSError("timeout waiting for response")
|
|
||||||
|
|
||||||
# read data
|
|
||||||
mv = self.dummybuf_memoryview
|
|
||||||
if len(buf) != len(mv):
|
|
||||||
mv = mv[: len(buf)]
|
|
||||||
self.spi.write_readinto(mv, buf)
|
|
||||||
|
|
||||||
# read checksum
|
|
||||||
self.spi.write(b"\xff")
|
|
||||||
self.spi.write(b"\xff")
|
|
||||||
|
|
||||||
self.cs(1)
|
|
||||||
self.spi.write(b"\xff")
|
|
||||||
|
|
||||||
def write(self, token, buf):
|
|
||||||
self.cs(0)
|
|
||||||
|
|
||||||
# send: start of block, data, checksum
|
|
||||||
self.spi.read(1, token)
|
|
||||||
self.spi.write(buf)
|
|
||||||
self.spi.write(b"\xff")
|
|
||||||
self.spi.write(b"\xff")
|
|
||||||
|
|
||||||
# check the response
|
|
||||||
if (self.spi.read(1, 0xFF)[0] & 0x1F) != 0x05:
|
|
||||||
self.cs(1)
|
|
||||||
self.spi.write(b"\xff")
|
|
||||||
return
|
|
||||||
|
|
||||||
# wait for write to finish
|
|
||||||
while self.spi.read(1, 0xFF)[0] == 0:
|
|
||||||
pass
|
|
||||||
|
|
||||||
self.cs(1)
|
|
||||||
self.spi.write(b"\xff")
|
|
||||||
|
|
||||||
def write_token(self, token):
|
|
||||||
self.cs(0)
|
|
||||||
self.spi.read(1, token)
|
|
||||||
self.spi.write(b"\xff")
|
|
||||||
# wait for write to finish
|
|
||||||
while self.spi.read(1, 0xFF)[0] == 0x00:
|
|
||||||
pass
|
|
||||||
|
|
||||||
self.cs(1)
|
|
||||||
self.spi.write(b"\xff")
|
|
||||||
|
|
||||||
def readblocks(self, block_num, buf):
|
|
||||||
nblocks = len(buf) // 512
|
|
||||||
assert nblocks and not len(buf) % 512, "Buffer length is invalid"
|
|
||||||
if nblocks == 1:
|
|
||||||
# CMD17: set read address for single block
|
|
||||||
if self.cmd(17, block_num * self.cdv, 0, release=False) != 0:
|
|
||||||
# release the card
|
|
||||||
self.cs(1)
|
|
||||||
raise OSError(5) # EIO
|
|
||||||
# receive the data and release card
|
|
||||||
self.readinto(buf)
|
|
||||||
else:
|
|
||||||
# CMD18: set read address for multiple blocks
|
|
||||||
if self.cmd(18, block_num * self.cdv, 0, release=False) != 0:
|
|
||||||
# release the card
|
|
||||||
self.cs(1)
|
|
||||||
raise OSError(5) # EIO
|
|
||||||
offset = 0
|
|
||||||
mv = memoryview(buf)
|
|
||||||
while nblocks:
|
|
||||||
# receive the data and release card
|
|
||||||
self.readinto(mv[offset : offset + 512])
|
|
||||||
offset += 512
|
|
||||||
nblocks -= 1
|
|
||||||
if self.cmd(12, 0, 0xFF, skip1=True):
|
|
||||||
raise OSError(5) # EIO
|
|
||||||
|
|
||||||
def writeblocks(self, block_num, buf):
|
|
||||||
nblocks, err = divmod(len(buf), 512)
|
|
||||||
assert nblocks and not err, "Buffer length is invalid"
|
|
||||||
if nblocks == 1:
|
|
||||||
# CMD24: set write address for single block
|
|
||||||
if self.cmd(24, block_num * self.cdv, 0) != 0:
|
|
||||||
raise OSError(5) # EIO
|
|
||||||
|
|
||||||
# send the data
|
|
||||||
self.write(_TOKEN_DATA, buf)
|
|
||||||
else:
|
|
||||||
# CMD25: set write address for first block
|
|
||||||
if self.cmd(25, block_num * self.cdv, 0) != 0:
|
|
||||||
raise OSError(5) # EIO
|
|
||||||
# send the data
|
|
||||||
offset = 0
|
|
||||||
mv = memoryview(buf)
|
|
||||||
while nblocks:
|
|
||||||
self.write(_TOKEN_CMD25, mv[offset : offset + 512])
|
|
||||||
offset += 512
|
|
||||||
nblocks -= 1
|
|
||||||
self.write_token(_TOKEN_STOP_TRAN)
|
|
||||||
|
|
||||||
def ioctl(self, op, arg):
|
|
||||||
if op == 4: # get number of blocks
|
|
||||||
return self.sectors
|
|
||||||
if op == 5: # get block size in bytes
|
|
||||||
return 512
|
|
||||||
@ -1,61 +0,0 @@
|
|||||||
# Test for sdcard block protocol
|
|
||||||
# Peter hinch 30th Jan 2016
|
|
||||||
import os, sdcard, machine
|
|
||||||
|
|
||||||
|
|
||||||
def sdtest():
|
|
||||||
spi = machine.SPI(1)
|
|
||||||
spi.init() # Ensure right baudrate
|
|
||||||
sd = sdcard.SDCard(spi, machine.Pin.board.X21) # Compatible with PCB
|
|
||||||
vfs = os.VfsFat(sd)
|
|
||||||
os.mount(vfs, "/fc")
|
|
||||||
print("Filesystem check")
|
|
||||||
print(os.listdir("/fc"))
|
|
||||||
|
|
||||||
line = "abcdefghijklmnopqrstuvwxyz\n"
|
|
||||||
lines = line * 200 # 5400 chars
|
|
||||||
short = "1234567890\n"
|
|
||||||
|
|
||||||
fn = "/fc/rats.txt"
|
|
||||||
print()
|
|
||||||
print("Multiple block read/write")
|
|
||||||
with open(fn, "w") as f:
|
|
||||||
n = f.write(lines)
|
|
||||||
print(n, "bytes written")
|
|
||||||
n = f.write(short)
|
|
||||||
print(n, "bytes written")
|
|
||||||
n = f.write(lines)
|
|
||||||
print(n, "bytes written")
|
|
||||||
|
|
||||||
with open(fn, "r") as f:
|
|
||||||
result1 = f.read()
|
|
||||||
print(len(result1), "bytes read")
|
|
||||||
|
|
||||||
fn = "/fc/rats1.txt"
|
|
||||||
print()
|
|
||||||
print("Single block read/write")
|
|
||||||
with open(fn, "w") as f:
|
|
||||||
n = f.write(short) # one block
|
|
||||||
print(n, "bytes written")
|
|
||||||
|
|
||||||
with open(fn, "r") as f:
|
|
||||||
result2 = f.read()
|
|
||||||
print(len(result2), "bytes read")
|
|
||||||
|
|
||||||
os.umount("/fc")
|
|
||||||
|
|
||||||
print()
|
|
||||||
print("Verifying data read back")
|
|
||||||
success = True
|
|
||||||
if result1 == "".join((lines, short, lines)):
|
|
||||||
print("Large file Pass")
|
|
||||||
else:
|
|
||||||
print("Large file Fail")
|
|
||||||
success = False
|
|
||||||
if result2 == short:
|
|
||||||
print("Small file Pass")
|
|
||||||
else:
|
|
||||||
print("Small file Fail")
|
|
||||||
success = False
|
|
||||||
print()
|
|
||||||
print("Tests", "passed" if success else "failed")
|
|
||||||
@ -1,48 +0,0 @@
|
|||||||
import utime
|
|
||||||
|
|
||||||
try:
|
|
||||||
import usocket as socket
|
|
||||||
except:
|
|
||||||
import socket
|
|
||||||
try:
|
|
||||||
import ustruct as struct
|
|
||||||
except:
|
|
||||||
import struct
|
|
||||||
|
|
||||||
# The NTP host can be configured at runtime by doing: ntptime.host = 'myhost.org'
|
|
||||||
host = "pool.ntp.org"
|
|
||||||
|
|
||||||
|
|
||||||
def time():
|
|
||||||
NTP_QUERY = bytearray(48)
|
|
||||||
NTP_QUERY[0] = 0x1B
|
|
||||||
addr = socket.getaddrinfo(host, 123)[0][-1]
|
|
||||||
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
|
|
||||||
try:
|
|
||||||
s.settimeout(1)
|
|
||||||
res = s.sendto(NTP_QUERY, addr)
|
|
||||||
msg = s.recv(48)
|
|
||||||
finally:
|
|
||||||
s.close()
|
|
||||||
val = struct.unpack("!I", msg[40:44])[0]
|
|
||||||
|
|
||||||
EPOCH_YEAR = utime.gmtime(0)[0]
|
|
||||||
if EPOCH_YEAR == 2000:
|
|
||||||
# (date(2000, 1, 1) - date(1900, 1, 1)).days * 24*60*60
|
|
||||||
NTP_DELTA = 3155673600
|
|
||||||
elif EPOCH_YEAR == 1970:
|
|
||||||
# (date(1970, 1, 1) - date(1900, 1, 1)).days * 24*60*60
|
|
||||||
NTP_DELTA = 2208988800
|
|
||||||
else:
|
|
||||||
raise Exception("Unsupported epoch: {}".format(EPOCH_YEAR))
|
|
||||||
|
|
||||||
return val - NTP_DELTA
|
|
||||||
|
|
||||||
|
|
||||||
# There's currently no timezone support in MicroPython, and the RTC is set in UTC time.
|
|
||||||
def settime():
|
|
||||||
t = time()
|
|
||||||
import machine
|
|
||||||
|
|
||||||
tm = utime.gmtime(t)
|
|
||||||
machine.RTC().datetime((tm[0], tm[1], tm[2], tm[6] + 1, tm[3], tm[4], tm[5], 0))
|
|
||||||
@ -1,2 +0,0 @@
|
|||||||
module("webrepl.py", opt=3)
|
|
||||||
module("webrepl_setup.py", opt=3)
|
|
||||||
@ -1,177 +0,0 @@
|
|||||||
# This module should be imported from REPL, not run from command line.
|
|
||||||
import binascii
|
|
||||||
import hashlib
|
|
||||||
import network
|
|
||||||
import os
|
|
||||||
import socket
|
|
||||||
import sys
|
|
||||||
import websocket
|
|
||||||
import _webrepl
|
|
||||||
|
|
||||||
listen_s = None
|
|
||||||
client_s = None
|
|
||||||
|
|
||||||
DEBUG = 0
|
|
||||||
|
|
||||||
_DEFAULT_STATIC_HOST = const("https://micropython.org/webrepl/")
|
|
||||||
static_host = _DEFAULT_STATIC_HOST
|
|
||||||
|
|
||||||
|
|
||||||
def server_handshake(cl):
|
|
||||||
req = cl.makefile("rwb", 0)
|
|
||||||
# Skip HTTP GET line.
|
|
||||||
l = req.readline()
|
|
||||||
if DEBUG:
|
|
||||||
sys.stdout.write(repr(l))
|
|
||||||
|
|
||||||
webkey = None
|
|
||||||
upgrade = False
|
|
||||||
websocket = False
|
|
||||||
|
|
||||||
while True:
|
|
||||||
l = req.readline()
|
|
||||||
if not l:
|
|
||||||
# EOF in headers.
|
|
||||||
return False
|
|
||||||
if l == b"\r\n":
|
|
||||||
break
|
|
||||||
if DEBUG:
|
|
||||||
sys.stdout.write(l)
|
|
||||||
h, v = [x.strip() for x in l.split(b":", 1)]
|
|
||||||
if DEBUG:
|
|
||||||
print((h, v))
|
|
||||||
if h == b"Sec-WebSocket-Key":
|
|
||||||
webkey = v
|
|
||||||
elif h == b"Connection" and b"Upgrade" in v:
|
|
||||||
upgrade = True
|
|
||||||
elif h == b"Upgrade" and v == b"websocket":
|
|
||||||
websocket = True
|
|
||||||
|
|
||||||
if not (upgrade and websocket and webkey):
|
|
||||||
return False
|
|
||||||
|
|
||||||
if DEBUG:
|
|
||||||
print("Sec-WebSocket-Key:", webkey, len(webkey))
|
|
||||||
|
|
||||||
d = hashlib.sha1(webkey)
|
|
||||||
d.update(b"258EAFA5-E914-47DA-95CA-C5AB0DC85B11")
|
|
||||||
respkey = d.digest()
|
|
||||||
respkey = binascii.b2a_base64(respkey)[:-1]
|
|
||||||
if DEBUG:
|
|
||||||
print("respkey:", respkey)
|
|
||||||
|
|
||||||
cl.send(
|
|
||||||
b"""\
|
|
||||||
HTTP/1.1 101 Switching Protocols\r
|
|
||||||
Upgrade: websocket\r
|
|
||||||
Connection: Upgrade\r
|
|
||||||
Sec-WebSocket-Accept: """
|
|
||||||
)
|
|
||||||
cl.send(respkey)
|
|
||||||
cl.send("\r\n\r\n")
|
|
||||||
|
|
||||||
return True
|
|
||||||
|
|
||||||
|
|
||||||
def send_html(cl):
|
|
||||||
cl.send(
|
|
||||||
b"""\
|
|
||||||
HTTP/1.0 200 OK\r
|
|
||||||
\r
|
|
||||||
<base href=\""""
|
|
||||||
)
|
|
||||||
cl.send(static_host)
|
|
||||||
cl.send(
|
|
||||||
b"""\"></base>\r
|
|
||||||
<script src="webrepl_content.js"></script>\r
|
|
||||||
"""
|
|
||||||
)
|
|
||||||
cl.close()
|
|
||||||
|
|
||||||
|
|
||||||
def setup_conn(port, accept_handler):
|
|
||||||
global listen_s
|
|
||||||
listen_s = socket.socket()
|
|
||||||
listen_s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
|
|
||||||
|
|
||||||
ai = socket.getaddrinfo("0.0.0.0", port)
|
|
||||||
addr = ai[0][4]
|
|
||||||
|
|
||||||
listen_s.bind(addr)
|
|
||||||
listen_s.listen(1)
|
|
||||||
if accept_handler:
|
|
||||||
listen_s.setsockopt(socket.SOL_SOCKET, 20, accept_handler)
|
|
||||||
for i in (network.AP_IF, network.STA_IF):
|
|
||||||
iface = network.WLAN(i)
|
|
||||||
if iface.active():
|
|
||||||
print("WebREPL server started on http://%s:%d/" % (iface.ifconfig()[0], port))
|
|
||||||
return listen_s
|
|
||||||
|
|
||||||
|
|
||||||
def accept_conn(listen_sock):
|
|
||||||
global client_s
|
|
||||||
cl, remote_addr = listen_sock.accept()
|
|
||||||
|
|
||||||
if not server_handshake(cl):
|
|
||||||
send_html(cl)
|
|
||||||
return False
|
|
||||||
|
|
||||||
prev = os.dupterm(None)
|
|
||||||
os.dupterm(prev)
|
|
||||||
if prev:
|
|
||||||
print("\nConcurrent WebREPL connection from", remote_addr, "rejected")
|
|
||||||
cl.close()
|
|
||||||
return False
|
|
||||||
print("\nWebREPL connection from:", remote_addr)
|
|
||||||
client_s = cl
|
|
||||||
|
|
||||||
ws = websocket.websocket(cl, True)
|
|
||||||
ws = _webrepl._webrepl(ws)
|
|
||||||
cl.setblocking(False)
|
|
||||||
# notify REPL on socket incoming data (ESP32/ESP8266-only)
|
|
||||||
if hasattr(os, "dupterm_notify"):
|
|
||||||
cl.setsockopt(socket.SOL_SOCKET, 20, os.dupterm_notify)
|
|
||||||
os.dupterm(ws)
|
|
||||||
|
|
||||||
return True
|
|
||||||
|
|
||||||
|
|
||||||
def stop():
|
|
||||||
global listen_s, client_s
|
|
||||||
os.dupterm(None)
|
|
||||||
if client_s:
|
|
||||||
client_s.close()
|
|
||||||
if listen_s:
|
|
||||||
listen_s.close()
|
|
||||||
|
|
||||||
|
|
||||||
def start(port=8266, password=None, accept_handler=accept_conn):
|
|
||||||
global static_host
|
|
||||||
stop()
|
|
||||||
webrepl_pass = password
|
|
||||||
if webrepl_pass is None:
|
|
||||||
try:
|
|
||||||
import webrepl_cfg
|
|
||||||
|
|
||||||
webrepl_pass = webrepl_cfg.PASS
|
|
||||||
if hasattr(webrepl_cfg, "BASE"):
|
|
||||||
static_host = webrepl_cfg.BASE
|
|
||||||
except:
|
|
||||||
print("WebREPL is not configured, run 'import webrepl_setup'")
|
|
||||||
|
|
||||||
_webrepl.password(webrepl_pass)
|
|
||||||
s = setup_conn(port, accept_handler)
|
|
||||||
|
|
||||||
if accept_handler is None:
|
|
||||||
print("Starting webrepl in foreground mode")
|
|
||||||
# Run accept_conn to serve HTML until we get a websocket connection.
|
|
||||||
while not accept_conn(s):
|
|
||||||
pass
|
|
||||||
elif password is None:
|
|
||||||
print("Started webrepl in normal mode")
|
|
||||||
else:
|
|
||||||
print("Started webrepl in manual override mode")
|
|
||||||
|
|
||||||
|
|
||||||
def start_foreground(port=8266, password=None):
|
|
||||||
start(port, password, None)
|
|
||||||
@ -1,107 +0,0 @@
|
|||||||
import sys
|
|
||||||
|
|
||||||
import os
|
|
||||||
import machine
|
|
||||||
|
|
||||||
RC = "./boot.py"
|
|
||||||
CONFIG = "./webrepl_cfg.py"
|
|
||||||
|
|
||||||
|
|
||||||
def input_choice(prompt, choices):
|
|
||||||
while 1:
|
|
||||||
resp = input(prompt)
|
|
||||||
if resp in choices:
|
|
||||||
return resp
|
|
||||||
|
|
||||||
|
|
||||||
def getpass(prompt):
|
|
||||||
return input(prompt)
|
|
||||||
|
|
||||||
|
|
||||||
def input_pass():
|
|
||||||
while 1:
|
|
||||||
passwd1 = getpass("New password (4-9 chars): ")
|
|
||||||
if len(passwd1) < 4 or len(passwd1) > 9:
|
|
||||||
print("Invalid password length")
|
|
||||||
continue
|
|
||||||
passwd2 = getpass("Confirm password: ")
|
|
||||||
if passwd1 == passwd2:
|
|
||||||
return passwd1
|
|
||||||
print("Passwords do not match")
|
|
||||||
|
|
||||||
|
|
||||||
def exists(fname):
|
|
||||||
try:
|
|
||||||
with open(fname):
|
|
||||||
pass
|
|
||||||
return True
|
|
||||||
except OSError:
|
|
||||||
return False
|
|
||||||
|
|
||||||
|
|
||||||
def get_daemon_status():
|
|
||||||
with open(RC) as f:
|
|
||||||
for l in f:
|
|
||||||
if "webrepl" in l:
|
|
||||||
if l.startswith("#"):
|
|
||||||
return False
|
|
||||||
return True
|
|
||||||
return None
|
|
||||||
|
|
||||||
|
|
||||||
def change_daemon(action):
|
|
||||||
LINES = ("import webrepl", "webrepl.start()")
|
|
||||||
with open(RC) as old_f, open(RC + ".tmp", "w") as new_f:
|
|
||||||
found = False
|
|
||||||
for l in old_f:
|
|
||||||
for patt in LINES:
|
|
||||||
if patt in l:
|
|
||||||
found = True
|
|
||||||
if action and l.startswith("#"):
|
|
||||||
l = l[1:]
|
|
||||||
elif not action and not l.startswith("#"):
|
|
||||||
l = "#" + l
|
|
||||||
new_f.write(l)
|
|
||||||
if not found:
|
|
||||||
new_f.write("import webrepl\nwebrepl.start()\n")
|
|
||||||
# FatFs rename() is not POSIX compliant, will raise OSError if
|
|
||||||
# dest file exists.
|
|
||||||
os.remove(RC)
|
|
||||||
os.rename(RC + ".tmp", RC)
|
|
||||||
|
|
||||||
|
|
||||||
def main():
|
|
||||||
status = get_daemon_status()
|
|
||||||
|
|
||||||
print("WebREPL daemon auto-start status:", "enabled" if status else "disabled")
|
|
||||||
print("\nWould you like to (E)nable or (D)isable it running on boot?")
|
|
||||||
print("(Empty line to quit)")
|
|
||||||
resp = input("> ").upper()
|
|
||||||
|
|
||||||
if resp == "E":
|
|
||||||
if exists(CONFIG):
|
|
||||||
resp2 = input_choice(
|
|
||||||
"Would you like to change WebREPL password? (y/n) ", ("y", "n", "")
|
|
||||||
)
|
|
||||||
else:
|
|
||||||
print("To enable WebREPL, you must set password for it")
|
|
||||||
resp2 = "y"
|
|
||||||
|
|
||||||
if resp2 == "y":
|
|
||||||
passwd = input_pass()
|
|
||||||
with open(CONFIG, "w") as f:
|
|
||||||
f.write("PASS = %r\n" % passwd)
|
|
||||||
|
|
||||||
if resp not in ("D", "E") or (resp == "D" and not status) or (resp == "E" and status):
|
|
||||||
print("No further action required")
|
|
||||||
sys.exit()
|
|
||||||
|
|
||||||
change_daemon(resp == "E")
|
|
||||||
|
|
||||||
print("Changes will be activated after reboot")
|
|
||||||
resp = input_choice("Would you like to reboot now? (y/n) ", ("y", "n", ""))
|
|
||||||
if resp == "y":
|
|
||||||
machine.reset()
|
|
||||||
|
|
||||||
|
|
||||||
main()
|
|
||||||
Loading…
x
Reference in New Issue
Block a user