Cannot use audio board after 1.8 update

[jonpedros]

Hello everyone,

After updating to the 1.8 version, there seems to be some conflict in our setup between the rotary encoder on behavior port 1 and the audio board on behavior port 4. The state coded yellow on the state plots has audio output concurrent to the speed recording. Audio is not working.

I'd be grateful if someone could point out a possible oversight that could be causing this after the update.

[alustig3]

Hi,

After the upgrade, it is a good idea to reupload the framework to the pyboard as well as retransfer the hardware definition if you are using one. This is especially relevant if you are upgrading from a pyControl version previous to 1.7. Do you recall what version of pyControl you were previously using?

If the framework and hardware definition reuploading does not fix things, can we further isolate the problem? Can you confirm that the audio board alone is working by running a simplified task? Try running the following task or something similar to confirm the audio is working.

from pyControl.utility import *
from devices import *

blue_LED = Digital_output('B4')
states = ['LED_on', 'LED_off']
events = []
initial_state = 'LED_off'
speaker = Audio_board(board.port_4) # Instantiate audio board.

def LED_on(event):
    if event == 'entry':
        timed_goto_state('LED_off', 0.5 * second)
        blue_LED.on()
        speaker.sine(5000) # Play a 5KHz sine wave.
    elif event == 'exit':
        blue_LED.off()
        speaker.off()

def LED_off(event):
    if event == 'entry':
        timed_goto_state('LED_on', 0.5 * second)

def run_end():  # Turn off hardware at end of run.
    blue_LED.off()
    speaker.off()

[jonpedros]

Thank you for the support.

I made sure to transfer the framework and hardware definitions before any attempts when changing GUI versions.

Running the code you provided worked fine on version 1.7, but on version 1.8 my speaker only seem to produce a very very dim/faint "clicking" sound. The sound on version 1.7 is as expected. I also tried disconnecting all devices except the audio board before running the task.

I'm not sure it could be relevant but the board I'm using currently has some defective DAC and BNC ports due to accidental input over-voltage. These ports emit a constant voltage when output is measured with an oscilloscope, no matter what task/hardware definitions are used on the board.

To correct my post above: audio board is connected on port 4 and encoder on port 1.

[alustig3]

ok, I think I found the problem. In b878a1c audio output was hardcoded to use timer2. The rotary encoder device file also uses timer2 on line 16 .

try replacing the contents of your devices/rotary_encoder.py file with the following:

import pyb
from pyControl.hardware import Analog_input, available_timers

class Rotary_encoder(Analog_input):
    # Quadrature output rotary encoder.
    def __init__(self, name, sampling_rate, output='velocity', threshold=None, 
                 rising_event=None, falling_event=None, bytes_per_sample=2, reverse=False):
        assert output in ('velocity', 'position'), 'ouput argument must be \'velocity\' or \'position\'.'
        assert bytes_per_sample in (2,4), 'bytes_per_sample must be 2 or 4'
        self.output_velocity = output == 'velocity'
        self.reverse = reverse
        self.pin_a = pyb.Pin('X1', pyb.Pin.AF_PP, pull=pyb.Pin.PULL_NONE, af=pyb.Pin.AF1_TIM2)
        self.pin_b = pyb.Pin('X2', pyb.Pin.AF_PP, pull=pyb.Pin.PULL_NONE, af=pyb.Pin.AF1_TIM2)
        self.counter_max_value = 0xffff
        self.counter_half_max_value = self.counter_max_value // 2
        self.enc_timer = pyb.Timer(available_timers.pop(), prescaler=1, period=self.counter_max_value)
        self.enc_channel = self.enc_timer.channel(1, pyb.Timer.ENC_AB)
        self.position = 0
        self.velocity = 0
        self.sampling_rate = sampling_rate
        Analog_input.__init__(self, None, name, int(sampling_rate), threshold, rising_event,
                              falling_event, data_type={2:'h',4:'l'}[bytes_per_sample])

    def read_sample(self):
        # Read value of encoder counter, correct for rollover, return position or velocity.
        new_counter_value = self.enc_timer.counter()
        counter_change = new_counter_value - self.counter_value
        self.counter_value = new_counter_value
        if counter_change > self.counter_half_max_value:    # Backward counter rollover.
            counter_change = counter_change - self.counter_max_value
        elif counter_change < -self.counter_half_max_value: # Forward counter rollover.
            counter_change = counter_change & self.counter_max_value
        if self.reverse: 
            counter_change = -counter_change
        self.position += counter_change
        self.velocity = counter_change * self.sampling_rate
        if self.output_velocity:
            return self.velocity
        else:
            return self.position

    def _run_start(self):
        # Start sampling analog input values.
        self.counter_value = self.enc_timer.counter()
        Analog_input._run_start(self)

after changing the file, reload/retransfer the framework and hardware definition and give it a try.

[jonpedros]

While the audio test script now works, loading a task that instantiates an encoder throws the following:

Error: Unable to setup state machine.

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "task_file.py", line 9, in <module>
  File "hardware_definition.py", line 24, in <module>
  File "devices/rotary_encoder.py", line 17, in __init__
ValueError: encoder not supported on timer 14

[alustig3]

Good that we saw some change, I think we're on the right track.
I don't have a audio board or rotary encoder to debug with, so it's tough for me to provide further advice.

@ThomasAkam wrote and knows more about the hardware.py and rotary_encoder.py code and I suspect will be able to provide a fix 😃

[ThomasAkam]

Hi,

Are you using the standard six port breakout board (Breakout_1_2)? I think the rotary encoder is only supported on port 1 on that board and usually uses both DIO_A and DIO_B lines for the quadrature signal. Could you post your hardware definition file to help us understand the setup?

best,

Thomas

[jonpedros]

Thank you for your support.

Indeed, I mistyped the port info. Encoder is on port 1 and speaker on port 4. I'm using Breakout_1_2

Here's my hardware definition.

import pyControl.utility as ut
import devices as dv

ut.v.vel_thresh = 100
ut.v.sync_int = 1000

board = dv.Breakout_1_2()

running_wheel = dv.Rotary_encoder(name='running_wheel', 
                                  sampling_rate=100, 
                                  output='velocity', 
                                  threshold=ut.v.vel_thresh,
                                  rising_event='started_running', 
                                  falling_event='stopped_running', 
                                  bytes_per_sample=2, 
                                  reverse=True)
speaker = dv.Audio_board(board.port_4)
sync_pulse_output = dv.Rsync(pin=board.port_3.DIO_A, event_name='sync_pulse', mean_IPI=ut.v.sync_int)
lickometer = dv.Digital_input(pin=board.port_6.DIO_A, rising_event='lick', falling_event='lick_off', debounce=False)

reward_delivery = dv.Digital_output(pin=board.DAC_1)
button = dv.Digital_input('X17', rising_event='stim_start', pull='up')

Also, I'm not sure it could be relevant but the board I'm using currently has some defective DAC and BNC ports due to accidental input over-voltage. These ports emit a constant voltage when output is measured with an oscilloscope, no matter what task/hardware definitions are used on the board.

[ThomasAkam]

Well spotted @alustig3, it is the change to using hardware timer 2 in the Audio_output class defined in pyControl/audio.py that is causing the problem because this timer is also used by the rotary encoder class. We can't change the hardware timer used by the rotary encoder because the timer channels for this specific hardware timer are linked to the X1 and X2 pins used by the rotary encoder (see the pyboard quick ref). We could in principle use different pins for the rotary encoder that are associated with a different hardware timer, but I think the simpler fix is to modify pyControl/audio.py to use a different hardware timer for the audio output. @jonpedros could you try replacing the contents of pyControl/audio.py with the code below and reloadling the framework (also revert to using the original rotary encoder driver code), and let us know if this fixes the problem.

import pyb
import math
from . import hardware as hw

_sine_len = 100 # Number of points in sine wave.
_sine_buf = bytearray([128+int(127*math.sin(2*math.pi*i/_sine_len)) for i in range(_sine_len)])
_sqr_buf = bytearray([255,0])
_click_buf = bytearray([255,0,255,255,0,0]+4*[255]+4*[0]+8*[255]+8*[0]
                       +16*[255]+16*[0]+32*[255]+32*[0]+[128])
_off_buf = bytearray([128])

# Audio output ----------------------------------------------------------------

class Audio_output(hw.IO_object):
    def __init__(self, channel=1):
        assert channel in [1,2], '! Channel number invalid, must be 1 or 2.'
        self._DAC = pyb.DAC(channel)
        self._timer = pyb.Timer(hw.available_timers.pop())
        self._func = None # Function currently being used for sweeped sound (sine, square or noise)
        self._freq = 0
        self._freq_ind = 0
        self.off()
        hw.assign_ID(self)

    # User functions

    def off(self):
        self._DAC.write_timed(_off_buf, pyb.Timer(3, freq=10000), mode=pyb.DAC.NORMAL)
        self._timer.deinit()
        self._playing = False

    def sine(self, freq):  # Play a sine wave tone at the specified frequency.
        self._DAC.write_timed(_sine_buf, pyb.Timer(3, freq=freq*_sine_len), mode=pyb.DAC.CIRCULAR)

    def square(self, freq): # Play a square wave tone at the specified frequency.
        self._DAC.write_timed(_sqr_buf, pyb.Timer(3, freq=freq*2), mode=pyb.DAC.CIRCULAR)

    def noise(self, freq=10000): # Play white noise with specified maximum frequency.
        self._DAC.noise(freq*2)

    def click(self, timer=None): # Play a single click.
        self._DAC.write_timed(_click_buf, pyb.Timer(3, freq=40000), mode=pyb.DAC.NORMAL)

    def clicks(self, rate): # Play clicks at specified rate.
        self._timer.init(freq=rate)
        self._timer.callback(self.click)

    def pulsed_sine(self, freq, pulse_rate): # Play a sine wave pulsed at the specified rate.
        self._pulsed_sound(freq, pulse_rate, self.sine)

    def pulsed_square(self, freq, pulse_rate): # Play a square wave pulsed at the specified rate.
        self._pulsed_sound(freq, pulse_rate, self.square)

    def pulsed_noise(self, freq, pulse_rate):
        self._pulsed_sound(freq, pulse_rate, self.noise)

    def stepped_sine(self, start_freq, end_freq, n_steps, step_rate):
        self._sound_step(start_freq, end_freq, n_steps, step_rate, self.sine)

    def stepped_square(self, start_freq, end_freq, n_steps, step_rate):
        self._sound_step(start_freq, end_freq, n_steps, step_rate, self.square)

    # Support functions

    def _pulsed_sound(self, freq, pulse_rate, func):
        self._freq = freq
        self._func = func
        self._timer.init(freq=2*pulse_rate)
        self._timer.callback(self._toggle_sound)

    def _toggle_sound(self, timer):
        if self._playing:
            self._DAC.write(127)
            self._playing = False
        else:
            self._func(self._freq)
            self._playing = True

    def _sound_step(self, start_freq, end_freq, n_steps, step_rate, func):
        freq_ratio = (end_freq/start_freq)**(1./(n_steps-1))
        self._freq = [int(start_freq * (freq_ratio**i)) for i in range(n_steps)]
        self._freq_ind = 0
        self._func = func
        self._timer.init(freq=step_rate)
        self._timer.callback(self._step_sound)

    def _step_sound(self, timer): # Timer callback to increment frequency during sweeped sounds.
        self._func(self._freq[self._freq_ind])
        self._freq_ind = (self._freq_ind+1) % len(self._freq)

[jonpedros]

I now get the following error from the framework:

Error importing hardware definition:

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "hardware_definition.py", line 27, in <module>
  File "devices/audio_board.py", line 11, in __init__
  File "pyControl/audio.py", line 22, in __init__
  File "pyControl/audio.py", line 28, in off
ValueError: Timer does not support DAC triggering

[ThomasAkam]

Ah, looking at the docs for the micropython DAC here it seems that not all timers can be used for triggering the DAC.write_timed (used for audio output) and Timer 3 which I specified in the previous code does not work. The version of pyControl.audio.py below uses timer 4 which should work. Please let me know if this fixes the problem.

import pyb
import math
from . import hardware as hw

_sine_len = 100 # Number of points in sine wave.
_sine_buf = bytearray([128+int(127*math.sin(2*math.pi*i/_sine_len)) for i in range(_sine_len)])
_sqr_buf = bytearray([255,0])
_click_buf = bytearray([255,0,255,255,0,0]+4*[255]+4*[0]+8*[255]+8*[0]
                       +16*[255]+16*[0]+32*[255]+32*[0]+[128])
_off_buf = bytearray([128])

# Audio output ----------------------------------------------------------------

class Audio_output(hw.IO_object):
    def __init__(self, channel=1):
        assert channel in [1,2], '! Channel number invalid, must be 1 or 2.'
        self._DAC = pyb.DAC(channel)
        self._timer = pyb.Timer(hw.available_timers.pop())
        self._func = None # Function currently being used for sweeped sound (sine, square or noise)
        self._freq = 0
        self._freq_ind = 0
        self.off()
        hw.assign_ID(self)

    # User functions

    def off(self):
        self._DAC.write_timed(_off_buf, pyb.Timer(4, freq=10000), mode=pyb.DAC.NORMAL)
        self._timer.deinit()
        self._playing = False

    def sine(self, freq):  # Play a sine wave tone at the specified frequency.
        self._DAC.write_timed(_sine_buf, pyb.Timer(4, freq=freq*_sine_len), mode=pyb.DAC.CIRCULAR)

    def square(self, freq): # Play a square wave tone at the specified frequency.
        self._DAC.write_timed(_sqr_buf, pyb.Timer(4, freq=freq*2), mode=pyb.DAC.CIRCULAR)

    def noise(self, freq=10000): # Play white noise with specified maximum frequency.
        self._DAC.noise(freq*2)

    def click(self, timer=None): # Play a single click.
        self._DAC.write_timed(_click_buf, pyb.Timer(4, freq=40000), mode=pyb.DAC.NORMAL)

    def clicks(self, rate): # Play clicks at specified rate.
        self._timer.init(freq=rate)
        self._timer.callback(self.click)

    def pulsed_sine(self, freq, pulse_rate): # Play a sine wave pulsed at the specified rate.
        self._pulsed_sound(freq, pulse_rate, self.sine)

    def pulsed_square(self, freq, pulse_rate): # Play a square wave pulsed at the specified rate.
        self._pulsed_sound(freq, pulse_rate, self.square)

    def pulsed_noise(self, freq, pulse_rate):
        self._pulsed_sound(freq, pulse_rate, self.noise)

    def stepped_sine(self, start_freq, end_freq, n_steps, step_rate):
        self._sound_step(start_freq, end_freq, n_steps, step_rate, self.sine)

    def stepped_square(self, start_freq, end_freq, n_steps, step_rate):
        self._sound_step(start_freq, end_freq, n_steps, step_rate, self.square)

    # Support functions

    def _pulsed_sound(self, freq, pulse_rate, func):
        self._freq = freq
        self._func = func
        self._timer.init(freq=2*pulse_rate)
        self._timer.callback(self._toggle_sound)

    def _toggle_sound(self, timer):
        if self._playing:
            self._DAC.write(127)
            self._playing = False
        else:
            self._func(self._freq)
            self._playing = True

    def _sound_step(self, start_freq, end_freq, n_steps, step_rate, func):
        freq_ratio = (end_freq/start_freq)**(1./(n_steps-1))
        self._freq = [int(start_freq * (freq_ratio**i)) for i in range(n_steps)]
        self._freq_ind = 0
        self._func = func
        self._timer.init(freq=step_rate)
        self._timer.callback(self._step_sound)

    def _step_sound(self, timer): # Timer callback to increment frequency during sweeped sounds.
        self._func(self._freq[self._freq_ind])
        self._freq_ind = (self._freq_ind+1) % len(self._freq)

[jonpedros]

This last change worked! Thanks to everyone for the quick replies.

[alustig3]

Great! Thank you for reporting the bug!

[ThomasAkam]

Great, I've done a new release, v1.8.1 in which the bug is fixed.