MicroPython
Adding CMSIS DSP functions #16130
Unanswered
jgpeiro
asked this question in
STM32 / Pyboard
Adding CMSIS DSP functions
#16130
Replies: 3 comments
-
|
I found a temporary solution, move the linker script commands from cexample/micropython.mk to ports/stm32/Makefile to make sure they appear at the end of the gcc command. I dont know why this is neccesary, but it allows to find the required funcions in the .a library. /micropython/examples/usercmodule/cexample/examplemodule.c: #include "arm_math.h"
// This is the function which will be called from Python as cexample.add_ints(a, b).
static mp_obj_t example_add_ints(mp_obj_t a_obj, mp_obj_t b_obj) {
// Extract the ints from the micropython input objects.
int a = mp_obj_get_int(a_obj);
int b = mp_obj_get_int(b_obj);
float fa[4] = {a,a,a,a};
float fb[4] = {b,b,b,b};
float fc[4] = {0,0,0,0};
arm_conv_f32( fa, 4, fb, 4, fc );
// Calculate the addition and convert to MicroPython object.
return mp_obj_new_int(a + b + (int)fc[0]);
}
// Define a Python reference to the function above.
static MP_DEFINE_CONST_FUN_OBJ_2(example_add_ints_obj, example_add_ints);/micropython/examples/usercmodule/cexample/micropython.mk: CEXAMPLE_MOD_DIR := $(USERMOD_DIR)
# Add all C files to SRC_USERMOD.
SRC_USERMOD += $(CEXAMPLE_MOD_DIR)/examplemodule.c
# We can add our module folder to include paths if needed
# This is not actually needed in this example.
CFLAGS_USERMOD += -I$(CEXAMPLE_MOD_DIR)
CFLAGS_USERMOD += -DARM_MATH_CM4
CFLAGS_USERMOD += -I$(TOP)/examples/usercmodule/cexample/CMSIS/DSP/Include
# Link CMSIS DSP library
#LDFLAGS_USERMOD += -L$(TOP)/examples/usercmodule/cexample/CMSIS/Lib/GCC
#LDFLAGS_USERMOD += -larm_cortexM4lf_math/micropython/ports/stm32/Makefile: define GENERATE_ELF
$(ECHO) "LINK $(1)"
$(Q)$(CC) $(LDFLAGS) -o $(1) $(2) $(LDFLAGS_MOD) $(LIBS) -L../../examples/usercmodule/cexample/CMSIS/Lib/GCC -larm_cortexM4lf_math
$(Q)$(SIZE) $(1)
$(if $(filter-out $(TEXT0_ADDR),0x08000000), \
$(ECHO) "INFO: this build requires mboot to be installed first")
$(if $(filter $(TEXT1_ADDR),0x90000000), \
$(ECHO) "INFO: this build places firmware in external QSPI flash")
endef |
Beta Was this translation helpful? Give feedback.
0 replies
-
|
Here is the CMSIS module, currently with 70 of 300 functions implemented. static mp_obj_t cmsis_dsp_arm_conv_f32(size_t n_args, const mp_obj_t *args)
{
// Get input parameters
mp_buffer_info_t pSrcA_bufinfo, pSrcB_bufinfo;
mp_get_buffer_raise(args[0], &pSrcA_bufinfo, MP_BUFFER_READ);
mp_get_buffer_raise(args[1], &pSrcB_bufinfo, MP_BUFFER_READ);
uint32_t srcALen = mp_obj_get_int(args[2]);
uint32_t srcBLen = mp_obj_get_int(args[3]);
// Get pointers to output parameters
mp_buffer_info_t pDst_bufinfo;
mp_get_buffer_raise(args[4], &pDst_bufinfo, MP_BUFFER_WRITE);
// Check buffer types
if (pSrcA_bufinfo.typecode != 'f' || pSrcB_bufinfo.typecode != 'f' || pDst_bufinfo.typecode != 'f') {
mp_raise_ValueError(MP_ERROR_TEXT("Buffers must contain float data"));
}
// Check buffer sizes
if (pSrcA_bufinfo.len < srcALen * sizeof(float32_t) || pSrcB_bufinfo.len < srcBLen * sizeof(float32_t) || pDst_bufinfo.len < (srcALen + srcBLen - 1) * sizeof(float32_t)) {
mp_raise_ValueError(MP_ERROR_TEXT("Buffer sizes must match"));
}
// Process convolution
arm_conv_f32(
(float32_t *)pSrcA_bufinfo.buf,
srcALen,
(float32_t *)pSrcB_bufinfo.buf,
srcBLen,
(float32_t *)pDst_bufinfo.buf
);
return mp_const_none;
}
|
Beta Was this translation helpful? Give feedback.
0 replies
-
|
Hare is the full CMSIS API ported, with all functions for matrix, filters, ffts, pids... The wrapper is automatically generated, and the structures are not handled, so they should be created on python side via uctypes module. A wrapped function looks like these: static mp_obj_t cmsis_dsp_arm_abs_f32(mp_obj_t pSrc_obj, mp_obj_t pDst_obj, mp_obj_t blockSize_obj)
{
// Get input parameters
mp_buffer_info_t pSrc_bufinfo;
mp_get_buffer_raise( pSrc_obj, &pSrc_bufinfo, MP_BUFFER_READ | MP_BUFFER_WRITE );
mp_buffer_info_t pDst_bufinfo;
mp_get_buffer_raise( pDst_obj, &pDst_bufinfo, MP_BUFFER_READ | MP_BUFFER_WRITE );
uint32_t _blockSize = (uint32_t)mp_obj_get_int( blockSize_obj );
// Call function
arm_abs_f32(
( float32_t * )pSrc_bufinfo.buf,
( float32_t * )pDst_bufinfo.buf,
_blockSize
);
// Return
return mp_const_none;
}
static mp_obj_t cmsis_dsp_arm_mat_add_f32(mp_obj_t pSrcA_obj, mp_obj_t pSrcB_obj, mp_obj_t pDst_obj)
{
// Get input parameters
arm_matrix_instance_f32 * _pSrcA = (arm_matrix_instance_f32 *)((mp_obj_uctypes_struct_t *)MP_OBJ_TO_PTR( pSrcA_obj ))->addr;
arm_matrix_instance_f32 * _pSrcB = (arm_matrix_instance_f32 *)((mp_obj_uctypes_struct_t *)MP_OBJ_TO_PTR( pSrcB_obj ))->addr;
arm_matrix_instance_f32 * _pDst = (arm_matrix_instance_f32 *)((mp_obj_uctypes_struct_t *)MP_OBJ_TO_PTR( pDst_obj ))->addr;
// Call function
arm_status result = arm_mat_add_f32(
_pSrcA,
_pSrcB,
_pDst
);
// Return
return mp_obj_new_int( result );
}The project should contain the CMSIS sources shown here: Here is an usage example: import time
import cmsis_dsp
import array
import uctypes
print("Matrix Operations Example with uctypes")
# Define matrix structure layout
MATRIX_LAYOUT = {
"numRows": 0 | uctypes.UINT16,
"numCols": 2 | uctypes.UINT16,
"pData": 4 | uctypes.PTR
}
# Create data arrays
matA_data = array.array("f", [1, 2, 3, 4]) # 2x2 matrix
matB_data = array.array("f", [5, 6, 7, 8]) # 2x2 matrix
result_data = array.array("f", [0] * 4)
# Allocate memory for matrix structures
matA_struct = bytearray(uctypes.sizeof(MATRIX_LAYOUT))
matB_struct = bytearray(uctypes.sizeof(MATRIX_LAYOUT))
result_struct = bytearray(uctypes.sizeof(MATRIX_LAYOUT))
# Create matrix instances
matA = uctypes.struct(uctypes.addressof(matA_struct), MATRIX_LAYOUT, uctypes.NATIVE)
matB = uctypes.struct(uctypes.addressof(matB_struct), MATRIX_LAYOUT, uctypes.NATIVE)
result = uctypes.struct(uctypes.addressof(result_struct), MATRIX_LAYOUT, uctypes.NATIVE)
# Initialize matrix properties
matA.numRows = matA.numCols = 2
matB.numRows = matB.numCols = 2
result.numRows = result.numCols = 2
matA.pData = uctypes.addressof(matA_data)
matB.pData = uctypes.addressof(matB_data)
result.pData = uctypes.addressof(result_data)
t0 = time.ticks_us()
status = cmsis_dsp.arm_mat_mult_f32(matA, matB, result)
t1 = time.ticks_us()
print(f"Processing time: {t1-t0} us")
print("Matrix A:", matA_data)
print("Matrix B:", matB_data)
print("Result:", result_data)
import time
import cmsis_dsp
import array
import uctypes
print("PID Controller Example with uctypes")
# Define PID structure layout according to arm_pid_instance_f32
PID_LAYOUT = {
"A0": 0 | uctypes.FLOAT32,
"A1": 4 | uctypes.FLOAT32,
"A2": 8 | uctypes.FLOAT32,
"state": (12 | uctypes.ARRAY, 3 | uctypes.FLOAT32),
"Kp": 24 | uctypes.FLOAT32,
"Ki": 28 | uctypes.FLOAT32,
"Kd": 32 | uctypes.FLOAT32
}
# Allocate memory for PID structure
pid_struct = bytearray(uctypes.sizeof(PID_LAYOUT))
pid = uctypes.struct(uctypes.addressof(pid_struct), PID_LAYOUT, uctypes.NATIVE)
# Initialize PID parameters
pid.Kp = 2.0
pid.Ki = 0.5
pid.Kd = 0.1
pid.A0 = pid.Kp + pid.Ki + pid.Kd
pid.A1 = -pid.Kp - 2 * pid.Kd
pid.A2 = pid.Kd
pid.state[0] = 0.0
pid.state[1] = 0.0
pid.state[2] = 0.0
# Test PID controller
setpoint = 100.0
current_value = 0.0
iterations = 10
print("Setpoint:", setpoint)
for i in range(iterations):
error = setpoint - current_value
t0 = time.ticks_us()
output = cmsis_dsp.arm_pid_f32(pid, error)
t1 = time.ticks_us()
current_value += output
print(f"Iteration {i}: Output={output:.2f}, Current={current_value:.2f}, Time={t1-t0}us")
import time
import cmsis_dsp
import array
import uctypes
import math
print("FFT Analysis Example with uctypes")
# Define FFT structure layout according to arm_cfft_instance_f32
CFFT_LAYOUT = {
"fftLen": 0 | uctypes.UINT16,
"pTwiddle": 4 | uctypes.PTR,
"pBitRevTable": 8 | uctypes.PTR,
"bitRevLength": 12 | uctypes.UINT16
}
# Create data arrays
N = 1024
signal = array.array("f", [0] * (2*N)) # Complex array
twiddle_factors = array.array("f", [0] * (2*N)) # Twiddle factors
bit_rev_table = array.array("H", [0] * N) # Bit reverse table (uint16_t)
# Initialize signal
for i in range(N):
signal[2*i] = math.sin(2 * math.pi * 10 * i / N) # Real part
signal[2*i+1] = 0.0 # Imaginary part
# Allocate memory for FFT structure
fft_struct = bytearray(uctypes.sizeof(CFFT_LAYOUT))
fft = uctypes.struct(uctypes.addressof(fft_struct), CFFT_LAYOUT, uctypes.NATIVE)
# Initialize FFT structure
fft.fftLen = N
fft.pTwiddle = uctypes.addressof(twiddle_factors)
fft.pBitRevTable = uctypes.addressof(bit_rev_table)
fft.bitRevLength = N
# Initialize FFT
#cmsis_dsp.arm_cfft_init_f32(fft)
t0 = time.ticks_us()
cmsis_dsp.arm_cfft_f32(fft, signal, 0, 1)
t1 = time.ticks_us()
print(f"Processing time: {t1-t0} us")
print("First 5 FFT bins magnitude:")
for i in range(5):
mag = math.sqrt(signal[2*i]**2 + signal[2*i+1]**2)
print(f"Bin {i}: {mag:.2f}")
import time
import cmsis_dsp
import array
import uctypes
print("IIR Filter Example with uctypes")
# Define IIR filter structure layout according to arm_biquad_casd_df1_inst_f32
BIQUAD_LAYOUT = {
"numStages": 0 | uctypes.UINT32,
"pState": 4 | uctypes.PTR,
"pCoeffs": 8 | uctypes.PTR
}
# Create data arrays
input_signal = array.array("f", [1.0] * 100)
output_signal = array.array("f", [0.0] * 100)
# For single stage biquad filter
num_stages = 1
state = array.array("f", [0.0] * (4 * num_stages)) # 4 state variables per stage
coeffs = array.array("f", [0.2, 0.4, 0.2, -0.6, 0.1] * num_stages) # 5 coeffs per stage
# Allocate memory for IIR structure
iir_struct = bytearray(uctypes.sizeof(BIQUAD_LAYOUT))
iir = uctypes.struct(uctypes.addressof(iir_struct), BIQUAD_LAYOUT, uctypes.NATIVE)
# Initialize IIR structure
iir.numStages = num_stages
iir.pState = uctypes.addressof(state)
iir.pCoeffs = uctypes.addressof(coeffs)
t0 = time.ticks_us()
cmsis_dsp.arm_biquad_cascade_df1_f32(iir, input_signal, output_signal, len(input_signal))
t1 = time.ticks_us()
print(f"Processing time: {t1-t0} us")
print("First 10 samples:", [round(x, 3) for x in output_signal[:10]]) |
Beta Was this translation helpful? Give feedback.
0 replies
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
-
I want to add this module to micropython to use convolution operations available at CMSIS DSP library, but I dont know how to include the /workspace/micropython/examples/usercmodule/conv/CMSIS/Lib/GCC/libarm_cortexM4l_math.a in the build, so the linker is always compliying about missing arm_conv_X functions.
How should I do it?
I added this into the makefile, but it dosnt help:
CFLAGS_USERMOD += -DARM_MATH_CM
-I/workspace/micropython/examples/usercmodule/conv/CMSIS/DSP/Include
LDFLAGS_USERMOD += -L/workspace/micropython/examples/usercmodule/conv/CMSIS/Lib/GCC
LDFLAGS_USERMOD += -larm_cortexM4l_math
Beta Was this translation helpful? Give feedback.
All reactions