Hello, and welcome to this video on controlling HiQnet devices with your MUSE controller using Python programming.   This is the second video in the HiQnet control series.   If you haven’t watched the first video on connecting to and configuring HiQnet communication, please pause this video, click on the link in the description, and watch that one first.
In this video we will be showing examples on how to control a gain with a bump up and bump down button, how to mute that gain, and how to switch an input on a selector.   In addition to all of those control functions, we will also show how to get real-time feedback from the HiQnet device and show that on our touch panel.
To begin with, let’s take a quick look at our touch panel page.   As you can see, this panel file contains one bar graph to show the current level of the gain object, a volume up, volume down, and mute button for the gain object, and three buttons at the bottom to select an input for our switcher object.
Next, let’s look at our starting code for this video.   To save a bit of time, we’ve created device definitions for our touch panel and BLU-806, as well as watches and callback functions for our 6 buttons.

 
Let’s start programming with our bump buttons and temporarily comment out the rest of our code.   We want these button events to occur when the button is pressed, so let’s add in an if statement to check for the True value of the button press.  
***
If(event.value):
***
In addition, let’s put in a comparator that checks if button 1 or button 2 is pressed based upon the event.id value.
***
If(event.id == “1”):
Elif(event.id ==”2”):
***
If we look at the descriptor file for our BLU, we can see that the Bump Up and Bump Down parameters are attached to the GAIN-EXAMPLE object.   The parameter is an enumerated value that can be set to On or Off.   
In most instances, programming for this parameter is fairly straightforward, we would type in the object using the dot notation and set the value of the parameter to On.   

***
dvBLU.Audio.GAIN-EXAMPLE.Bump Up.value = "On"
***
Notice that there are two different issues that VSCode reports with that line.   Both problems relate to the naming rules for objects in Python.   Dashes and spaces cannot be used in the names of objects, this  means GAIN-EXAMPLE and Bump Up are invalid.   How do we get around these two issues?
In Python you have two concepts when it comes to accessing things in an object.   You have attribute access which you see when you type in things like object.attribute, and then you have item access where you type in object[key].   Both let you walk a tree of objects, but the item access allows you to do this when attributes do not conform to Python naming rules.   As a side note, item access works better with the auto-complete function of VSCode when it comes to programming in Python.

 
Let’s change our code using the item access methodology, now setting the Bump Up value to On will look like:
***
dvBLU.Audio[“GAIN-EXAMPLE”][“Bump Up”] = “On”
***
Add this same line to the else if statement for the down button:
***
dvBLU.Audio[“GAIN-EXAMPLE”][“Bump Down”] = “On”
***
Save and load your code to the MUSE controller.   If you connect to the BLU using Audio Architect, you should see the gain object slider move up and down based on the button you press.
Now that we are done with the bump buttons, let’s move on to the mute toggle.   Just as we did for our other buttons, let’s add in the if statement to check for our button press.   Since this is a toggle button, the first thing we need to do is evaluate the state of the Mute parameter.   If we check the descriptor for the Mute parameter, we can see it is an enumerated value that can be set to Muted or Unmuted.   That means we can create a comparator for those values and set the parameter to the opposite value.
***
        if(dvBLU.Audio["GAIN-EXAMPLE"]["Mute"].value == "Muted"):
            dvBLU.Audio["GAIN-EXAMPLE"]["Mute"].value = "Unmuted"
        
        elif(dvBLU.Audio["GAIN-EXAMPLE"]["Mute"].value == "Unmuted"):
            dvBLU.Audio["GAIN-EXAMPLE"]["Mute"].value = "Muted"
***
From here, you should be able to save and upload your code to test your mute button.   You should see it mute and unmute if you are connected to the BLU using Audio Architect.
The last buttons we will program for are the switcher select buttons.   If you look at the Descriptor file, you will see there is an object named SELECTOR EXAMPLE that contains a parameter named Input Number.   To program for this, let’s start by adding in our push check.

 
***
If(event.value):
***
For these three buttons, we setup the buttons on port 2 and had their channel numbers correspond to the input numbers on the switcher.   We will use this when setting our Input Number value.   
Under our push event we can set the value of Input Number to the id of the button push.   We can do this by typing in:
***
dvBLU.Audio[“SELECTOR EXAMPLE”][“Input Number”].value = event.id
***
You should be able to save and send your program and see it working in Audio Architect.
Now that all of our control has been taken care of, the next step is to get feedback on all our various buttons and bar graphs.   Since all these various states are controlled by parameters, that means we will be creating watches for those parameters, and our callback functions will update various states on our panel.   Let’s start with the bargraph.
Checking our descriptor file, we can see a parameter called Gain under our GAIN-EXAMPLE.   The event received by the changing of the parameter contains the value of the gain, but it is important to note that the touch panel can only utilize an integer value for the bar graph.   That means we must change the type of the value before we send it.
Create a watch for the gain by typing in: 
***
dvBLU.Audio["GAIN-EXAMPLE"]["Gain"].watch(gainFeedback)
***
Now we will define our callback function named gainFeedback.
***
Def gainFeedback(event):
***
Inside our function, set the value of the bar graph to the integer of event.value.
***
dvTP.port[1].level[1].value = int(event.value)
***
Next, we can move on to the mute toggle button.   According to the return value in the Descriptor file, Mute will either be Muted or Unmuted.   That means we can create a conditional in our code to turn the button on or off based on the Mute.  First, create your watch for the Mute parameter using:
***
dvBLU.Audio["GAIN-EXAMPLE"]["Mute"].watch(muteFeedback)
***
Now define the callback function and create the conditional to set the value of your mute button on or off based on the event value.   Remember, you must use the channel object to change the state of a button.
***
def muteFeedback(event):
    if(event.value == "Muted"):
        dvTP.port[1].channel[3].value = True
    
    elif(event.value == "Unmuted"):
        dvTP.port[1].channel[3].value = False
***
For our last piece of feedback, we need to show the current input selection on our source selector.   First, you will need to create the watch for the Input Number parameter.
***
dvBLU.Audio["SELECTOR EXAMPLE"]["Input Number"].watch(selectorFeedback)
***
Once your watch has been created, define your callback function.   Since we are creating a mutually exclusive group we’ll approach this feedback a bit differently.   Whenever this function is triggered, we will turn off the feedback for all of the buttons first by using a simple for loop.
***
    for i in range (1,4):
        dvTP.port[1].channel[i].value = False
***
Then we will turn on the feedback for the proper button using converting event.value to an integer and turning on that button’s channel.
***
    dvTP.port[2].channel[int(event.value)].value = True
***
Now you should be able to save and load the program to the MUSE controller to test out all your feedback.