I2s chnaged between 1.22 ans 1.23 ?

[sophiedegran]

I don't understand why this example don't work under 1.23
The wav file is generated and have the same size (441ko)
Mediainfo and Audacity recognize and open it with sucess
But there is no sound!

Under 1.22 I have the sound produce by the buzzer..

If you have any idea..

# Playing notes via passive buzzer and recording via I2s microphone to a wav file
# Board used ESP32S3 (N32R8 from espressif)
# Using async (Tks. Peter) 

# --> original code from 'record_mic_to_sdcard_uasyncio.py'
# The MIT License (MIT)
# Copyright (c) 2022 Mike Teachman
# https://opensource.org/licenses/MIT
# https://github.com/miketeachman/micropython-i2s-examples/examples 

'''
- add passive buzzer playing notes during recording
- wave file name based on date-time
- record 5sec on local (no sd card)
 --> launch with execfile("mic_buzz.py") (this code) after boot.py and main.py
 (in boot launch Wifi in AP mode and main is empty)
'''

import sys

# mic to wav
import os
import time
import asyncio
from machine import I2S
from machine import Pin

# buzzer
from machine import PWM
# init buzzer
pwm = PWM(Pin(6))

# microphone I2S MSM261S4030H0
# ======= I2S CONFIGURATION =======
# V = 3V3
# G = GND
# I2S word select io number - WS
WS_PIN = 16 # 4 # 25 
# LR = 3V3 for MONO USED # (GND for STEREO) 
# I2S bit clock io number - SCK
SCK_PIN = 17 # 5 #32 
# I2S data in io number - DA
SD_PIN = 18 # 6 # 33 

I2S_ID = 0
BUFFER_LENGTH_IN_BYTES = 40000

# ======= AUDIO CONFIGURATION =======
RECORD_TIME_IN_SECONDS = 5
WAV_SAMPLE_SIZE_IN_BITS = 16
FORMAT = I2S.MONO
#FORMAT = I2S.STEREO
#SAMPLE_RATE_IN_HZ = 22050
SAMPLE_RATE_IN_HZ = 44100


format_to_channels = {I2S.MONO: 1, I2S.STEREO: 2}
NUM_CHANNELS = format_to_channels[FORMAT]
WAV_SAMPLE_SIZE_IN_BYTES = WAV_SAMPLE_SIZE_IN_BITS // 8 
RECORDING_SIZE_IN_BYTES = (RECORD_TIME_IN_SECONDS * SAMPLE_RATE_IN_HZ * WAV_SAMPLE_SIZE_IN_BYTES * NUM_CHANNELS)

# for wave file name
# return '_DD-MM-YYYY-HH:MM:SS' as string (add 0 if need) 
def check_date_time():
    micro_python = True
    x = time.localtime()
    if not micro_python:
        return time.strftime('_%d-%m-%Y-%H:%M:%S', x)
    else:
        t = []
        for i in range(0, (len(x)-2)):
            if len(str(x[i])) == 1:
                t.append("0" + str(x[i]))
            else:
                t.append(str(x[i]))
        t = "_" + t[2] + "-" + t[1] + "-" + t[0] + "-" + t[3] + ":" + t[4] + ":" + t[5]
        return t

# ======= WAV FILE NAME 'mic_DD-MM-YYYY-HH:MM:SS.wav' =======
WAV_FILE = "mic" + check_date_time() + ".wav"


# wav header
def create_wav_header(sampleRate, bitsPerSample, num_channels, num_samples):
    print("Num. channel(s): {} ".format(num_channels))
    datasize = num_samples * num_channels * bitsPerSample // 8
    o = bytes("RIFF", "ascii")  # (4byte) Marks file as RIFF
    o += (datasize + 36).to_bytes(
        4, "little"
    )  # (4byte) File size in bytes excluding this and RIFF marker
    o += bytes("WAVE", "ascii")  # (4byte) File type
    o += bytes("fmt ", "ascii")  # (4byte) Format Chunk Marker
    o += (16).to_bytes(4, "little")  # (4byte) Length of above format data
    o += (1).to_bytes(2, "little")  # (2byte) Format type (1 - PCM)
    o += (num_channels).to_bytes(2, "little")  # (2byte)
    o += (sampleRate).to_bytes(4, "little")  # (4byte)
    o += (sampleRate * num_channels * bitsPerSample // 8).to_bytes(4, "little")  # (4byte)
    o += (num_channels * bitsPerSample // 8).to_bytes(2, "little")  # (2byte)
    o += (bitsPerSample).to_bytes(2, "little")  # (2byte)
    o += bytes("data", "ascii")  # (4byte) Data Chunk Marker
    o += (datasize).to_bytes(4, "little")  # (4byte) Data size in bytes
    return o


async def record_wav(audio_in, wav):


    sreader = asyncio.StreamReader(audio_in)

    # create header for WAV file and write local
    wav_header = create_wav_header(
        SAMPLE_RATE_IN_HZ,
        WAV_SAMPLE_SIZE_IN_BITS,
        NUM_CHANNELS,
        SAMPLE_RATE_IN_HZ * RECORD_TIME_IN_SECONDS,
    )
    num_bytes_written = wav.write(wav_header)

    # allocate sample array
    # memoryview used to reduce heap allocation
    mic_samples = bytearray(10000)
    mic_samples_mv = memoryview(mic_samples)

    num_sample_bytes_written_to_wav = 0

    # continuously read audio samples from I2S hardware
    # and write them to a WAV file stored on a SD card
    print("Recording size: {} bytes".format(RECORDING_SIZE_IN_BYTES))
    print("==========  START RECORDING ==========")
    while num_sample_bytes_written_to_wav < RECORDING_SIZE_IN_BYTES:
        # read samples from the I2S peripheral
        num_bytes_read_from_mic = await sreader.readinto(mic_samples_mv)
        # write samples to WAV file
        if num_bytes_read_from_mic > 0:
            num_bytes_to_write = min(
                num_bytes_read_from_mic, RECORDING_SIZE_IN_BYTES - num_sample_bytes_written_to_wav
            )
            num_bytes_written = wav.write(mic_samples_mv[:num_bytes_to_write])
            num_sample_bytes_written_to_wav += num_bytes_written

    print("==========  DONE RECORDING ==========")
    # close file
    wav.close()
    # deinit I2s
    audio_in.deinit()
    # quiet buzzer and deinit pwm
    pwm.duty_u16(0) 
    pwm.deinit()

	# quit from execfile
    print('bye!')
    sys.exit()


# task buzzer - machine.PWM(Pin(6))
# note 10 à 12000
# starting playing note 'la' (440)
async def buzz():
    note = 440 
    while (note <= 5000):
        pwm.freq(note)
        #pwm.duty_u16(32767) # volume 50%
        pwm.duty_u16(1000) 
        await asyncio.sleep(1)
        note += 220 
    pwm.duty_u16(0) # quiet for cats!
    await asyncio.sleep(1)

async def main(audio_in, wav):
    record = asyncio.create_task(record_wav(audio_in, wav))
    buzzer =  asyncio.create_task(buzz())

    await asyncio.gather(record, buzzer)


try:
    audio_in = I2S(
        I2S_ID,
        sck=Pin(SCK_PIN),
        ws=Pin(WS_PIN),
        sd=Pin(SD_PIN),
        mode=I2S.RX,
        bits=WAV_SAMPLE_SIZE_IN_BITS,
        format=FORMAT,
        rate=SAMPLE_RATE_IN_HZ,
        ibuf=BUFFER_LENGTH_IN_BYTES,
    )

    wav = open(WAV_FILE, "wb")

    # Launch
    asyncio.run(main(audio_in, wav))


except (KeyboardInterrupt, Exception) as e:
    print("Exception {} {}\n".format(type(e).__name__, e))
finally:
    # cleanup
    wav.close()
    audio_in.deinit()
    pwm.deinit()
    ret = asyncio.new_event_loop()  # Clear retained asyncio state

[glenn20]

Use triple backtick characters ``` around your blocks of code instead of """. That will make it much easier for readers to understand and answer your question. Even better, start your python code blocks with ```py and your code will be shown with colour syntax highlighting.

[ricksorensen]

It looks like your program wants to run two tasks

• read (via I2S) and write (append) to a wav file until enough is read.
• drive the buzzer (via PWM) with an ascending tonal scale (1s tones) until limit is reached (25 notes or so)

The title indicates an I2S question, but since you are getting the correct file written but no tones, maybe this is a PWM question? There have been some modifications in PWM initialization for consistency in behavior and across boards, but it looks like you are activating the tones correctly.

[sophiedegran]

Thanks ricks for having look..
The buzzer is playing, I2s is recording and the file is generated
In 1.22.2 I've got the sound produce by the buzzer in the wav file
In 1.23 I've got no sound in the wav file
It seem I2s data won't work internaly ..
Trying to change Gpio with no success
I've got not error at the build
I continue to investigate!