【Follow me 第二季第4期】任务三：学习PDM麦克风技术知识，调试PDM麦克风，通过串...

ICS · 发表于2024-12-28 16:08

【Follow me 第二季第4期】任务三：学习PDM麦克风技术知识，调试PDM麦克风，通过串... [复制链接]

---

Arduino® Nano RP2040 Connect 上的麦克风型号为：`ST MP34DT06JTR`，在网上只找到了`MP34DT05`的驱动，不过同样可以使用

```python
# https://github.com/PinkInk/mp34dt05-a-micropython-driver/blob/main/st34dt05a.py
import rp2
import array
from uctypes import addressof
import micropython

bit_sample_freq = 3_072_000 # PDM clock frequency Hz
__steps = 8 # PIO clock steps per PDM clock cycle

# 8 word raw sample buffer matching size joined RX FIFO
__raw_sample_buf = array.array('I', [0 for _ in range(8)])

# sample buffers
buf_len = 1024

# initialise buffers
__buf0 = array.array('B', [0 for _ in range(buf_len)])
__buf1 = array.array('B', [0 for _ in range(buf_len)])

# sample buffer wrapper                     [byte offset]
#   __data[0] = buffer length                 [0]
#   __data[1] = active buffer (0 or 1)        [4]
#   __data[2] = index of current sample       [8]
#   __data[3] = address of start of buffer 0  [12]
#   __data[4] = address of start of buffer 1  [16]
__data = array.array('I', [buf_len, 0, 0, addressof(__buf0), addressof(__buf1)])

__active_buf = 0

# return buffer
def get_buffer(b):
    return eval(f'__buf{b}')

# placeholder for user provided buffer handler fn
buffer_handler = None

# sample PDM microphone
@rp2.asm_pio(set_init=rp2.PIO.OUT_LOW, out_init=rp2.PIO.IN_LOW, fifo_join=rp2.PIO.JOIN_RX)
def sample() -> uint:
    set(y, 8)                   # no. of word length samples

label("WORDSTART")
    set(x, 30)                  # 32 bits per sample (- 2)
    
    label("SAMPLE")
    set(pins, 1)            [2] # set clock pin high
    wrap_target()
    in_(pins, 1)                # sample data pin into ISR 
                                # (>105ns after rising clock edge)
    set(pins, 0)            [2] # set clock pin low
    jmp(x_dec, "SAMPLE")        # loop
    
    # last bit sample 3 steps shorter accomodating
    # push, jmp and (re-)set x loop counter
    set(pins, 1)            [2]
    in_(pins, 1)
    set(pins, 0)
    push(noblock)               # push ISR to to RX FIFO

jmp(y_dec, "WORDSTART")
    irq(rel(0))                 # raise irq - consume RX FIFO in main

# reset counters and loop back, whilst maintaining timing
    set(pins, 1)
    set(y, 8)
    set(x, 30)
    # implicit wrap (no clock cycle)

# count bits in 8 word sample and store into active buffer
#   r0 = __raw_sample_buf (8 word array)
#   r1 = __data array
@micropython.asm_thumb
def store_pcm_sample(r0, r1) -> uint:
    # r2 = overloaded scratch variable

# init
    ldr(r4, [r1, 12])           # r4 = address of start of buffer 0 (__data[3])
    ldr(r2, [r1, 4])            # r2 = get active buffer (__data[1])
    cmp(r2, 0)                  # if __buf0 active
    beq(BUF0)                   #   skip
    ldr(r4, [r1, 16])           #   else: r4 = address of start of buffer 1 (__data[4])
    label(BUF0)
    ldr(r3, [r1, 8])            # r3 = get index (__data[2])
    add(r4, r4, r3)             # add buf index

# sample buffer loop (SBL)
    mov(r5, 0)                  # r5 = current sample running set-bit count
    mov(r6, 0)                  # r6 = init index into 8 word __raw_sample_buf
    label(SBL_START)            # __raw_sample_buf loop START
    cmp(r6, 32)                 # 8 * 4 byte words = 32 bits
    beq(SBL_END)                # end of buffer? GOTO: __raw_sample_buf loop END

# sample loop
    mov(r2, r0)                 # r2 = address of __raw_sample_buf
    add(r2, r2, r6)             # add __raw_sample_buf index
    ldr(r7, [r2, 0])            # r7 = current sample
    
    # Brian Kernighan method
    # https://developer.arm.com/documentation/ka002486/latest 
    label(SL_START)             # sample loop START
    cmp(r7, 0)                  # if sample decremented to zero
    beq(SL_END)                 # GOTO: Sample Loop END
    add(r5, 1)                  # increment sample set-bit count
    mov(r2, r7)                 # r2 = temp copy of sample
    sub(r2, 1)                  # subtract 1 (reverses LSB)
    and_(r7, r2)                # remove LSB from sample
    b(SL_START)                 # GOTO: Sample Loop START

label(SL_END)               # sample loop END
    add(r6, 4)                  # increment sample counter one word
    b(SBL_START)                # GOTO: __raw_sample_buf loop STARTs

label(SBL_END)              # sample buffer loop END

# store sample set-bit count into active buf[index]
    strb(r5, [r4, 0])           # buf is a Byte array

# increment and store buf index 
    ldr(r2, [r1, 0])            # r2 = buf_len
    add(r3, 1)                  # increment     
    cmp(r3, r2)                 # if index = buf_len?
    bne(SKIP_RESET)             #   GOTO: SKIP_RESET
    mov(r3, 0)                  # re-init index = 0

# swap buffers
    ldr(r2, [r1, 4])            # r2 = get active buffer (to invert)
    cmp(r2, 0)
    beq(BUF1)                   # if buffer 0 is not active
    mov(r2, 0)                  #   make buffer 0 active
    b(UPD_BUF)
    label(BUF1)
    mov(r2, 1)                  #   else: make buffer 1 active
    label(UPD_BUF)
    str(r2, [r1, 4])            # store active buffer

label(SKIP_RESET)
    str(r3, [r1, 8])            # store buf index back to __data

# irq handler
#   get samples and store in buffer
#   p = irq (passed by StateMachine.irq)
def irq_handler(p):
    global __raw_sample_buf, __data, __active_buf, buffer_handler

sm.get(__raw_sample_buf)

store_pcm_sample(__raw_sample_buf, __data)

if __active_buf != __data[1]:
        if buffer_handler:
            # handle now inactive buffer
            micropython.schedule(buffer_handler, __active_buf)
        __active_buf = __data[1]

# init StateMachine
#   pdm_clk = pdm clock pin (23 on arduino nano rp2040 connect)
#   pdm_data = pdm data pin (22 on arduino nano rp2040 connect)
#   handler = function to handle inactive buffer
def init(pdm_clk, pdm_data, handler=None):
    global buffer_handler, sample, irq_handler, sm, bit_sample_freq, __steps

buffer_handler = handler

sm = rp2.StateMachine(0, sample, freq=bit_sample_freq*__steps, set_base=pdm_clk, in_base=pdm_data)

# hard interupt flag causes lockup?
    sm.irq(handler=irq_handler) #, hard=True)

def start():
    sm.active(True)

def stop():
    sm.active(False)
```

驱动利用可编程IO将脉冲密度信号转换为 PDM 格式（脉冲计数）。

> PDM（Pulse Density Modulation，脉冲密度调制）麦克风是一种广泛应用于消费电子、物联网设备和嵌入式系统中的数字麦克风技术。相较于传统的模拟麦克风，PDM麦克风以其低功耗、紧凑的封装和高信噪比等优点，成为当下音频采集领域的重要技术。
>
> PDM通过脉冲的“密度”来表示信号的幅值：
>
> - 当输入信号幅值较高时，输出的数字脉冲密度较大（更多的“1”）。
> - 当输入信号幅值较低时，输出的数字脉冲密度较小（更多的“0”）。

我们可以通过将 PDM 数据滤波降采样后转换为 PCM 数据

```python
from time import sleep
import random
from wavsimple import wav
from machine import Pin
import mp34 as pdm

pcm_rate = 4_000 # Hz - default is 12kHz i.e. 3.072MHz bit-sample rate
pdm.bit_sample_freq = pcm_rate * 256

pdm_clk = Pin(23)
pdm_data = Pin(22)

# 滤波函数
def low_pass_filter(pdm_data, window_size=8):
    filtered_data = []
    for i in range(len(pdm_data) - window_size):
        avg = sum(pdm_data[i:i + window_size]) // window_size
        filtered_data.append(avg)
    return filtered_data

# 降采样函数
def downsample(data, factor=4):
    return data[::factor]

def buffer_handler(inactive_buf):
    pdm_data = list(pdm.get_buffer(inactive_buf))
    filtered_data = low_pass_filter(pdm_data)
    pcm_data = downsample(filtered_data)
    for i in pcm_data:
        print(i)

pdm.init(pdm_clk, pdm_data, handler=buffer_handler)
pdm.start()
```

<ignore_js_op>

<div class="tip tip_4 aimg_tip" id="aimg_875555_menu" style="position: absolute; display: none" disautofocus="true">
<div class="xs0">
<p><strong>image-20241228155044892.png</strong> <em class="xg1">(104.66 KB, 下载次数: 0)</em></p>
<p>
<a href="javascript:;" class="loginf" >下载附件</a>

<a href="javascript:;" onclick="showWindow(this.id, this.getAttribute('url'), 'get', 0);" id="savephoto_875555" url="home.php?mod=spacecp&ac=album&op=saveforumphoto&aid=875555&handlekey=savephoto_875555">保存到相册</a>

</p>

</div>
<div class="tip_horn"></div>
</div>

</ignore_js_op>

秦天qintian0303 · 发表于2024-12-29 12:34

arduinoIDE的库里面就直接可以搜到啊

【Follow me 第二季第4期】任务三：学习PDM麦克风技术知识，调试PDM麦克风，通过串... [复制链接]

最新回复