Python: move a fader in protools using Avid pro tools SDK

import pro_tools_sdk

# Connect to Pro Tools
session = pro_tools_sdk.Session()

# Get a reference to the fader you want to control
fader = session.get_fader("Fader 1")

# Set the fader's level to -12 dB
fader.set_level(-12)

# Close the Pro Tools session
session.close()

  • Pan: You can use the set_pan() method to control the pan position of a channel.
    Mute: You can use the set_mute() method to mute or unmute a channel.
    Solo: You can use the set_solo() method to solo or unsolo a channel.
    Input or output routing: You can use the set_input_routing() and set_output_routing() methods to control the input and output routing of a channel.
    Inserts: You can use the get_inserts() method to get a list of inserts on a channel, and then use the enable() and set_parameter() methods to control the settings of each insert.
    Automation: You can use the get_automation_parameters() method to get a list of automation parameters on a channel, and then use the enable() and set_value() methods to control the settings of each automation parameter.

  • Python: SNMP put into a Google Sheet:

    from pysnmp.hlapi import *
    import gspread
    from oauth2client.service_account import ServiceAccountCredentials

    # SNMP query function
    def snmp_query(ip, community, oid):
    errorIndication, errorStatus, errorIndex, varBinds = next(
    getCmd(SnmpEngine(),
    CommunityData(community),
    UdpTransportTarget((ip, 161)),
    ContextData(),
    ObjectType(ObjectIdentity(oid)))
    )

    if errorIndication:
    print(errorIndication)
    elif errorStatus:
    print('%s at %s' % (errorStatus.prettyPrint(),
    errorIndex and varBinds[int(errorIndex) - 1][0] or '?'))
    else:
    for varBind in varBinds:
    return varBind[1].prettyPrint()

    # Google Sheets API setup
    scope = ["https://spreadsheets.google.com/feeds",'https://www.googleapis.com/auth/spreadsheets',"https://www.googleapis.com/auth/drive.file","https://www.googleapis.com/auth/drive"]
    creds = ServiceAccountCredentials.from_json_keyfile_name("credentials.json", scope)
    client = gspread.authorize(creds)

    # Open the Google Sheet by title
    sheet = client.open("my_sheet").sheet1

    # SNMP query and insert data into Google Sheet
    ip = "192.168.1.1"
    community = "public"
    oid = "1.3.6.1.2.1.1.1.0" # example OID for system description
    data = snmp_query(ip, community, oid)
    sheet.append_row([data])

    print("Data inserted into Google Sheet.")

    python: maps Reaper DAW mixer volume and mute and solo to GPIO

    import pythoncom
    import reapy
    import RPi.GPIO as GPIO

    # Set up the GPIO pins
    GPIO.setmode(GPIO.BCM)
    GPIO.setup(17, GPIO.OUT) # Volume pin
    GPIO.setup(27, GPIO.OUT) # Mute pin
    GPIO.setup(22, GPIO.OUT) # Solo pin

    def set_track_volume(track, volume):
    track.volume = volume
    if volume > 0.5:
    GPIO.output(17, GPIO.HIGH)
    else:
    GPIO.output(17, GPIO.LOW)

    def set_track_mute(track, mute):
    track.mute = mute
    if mute:
    GPIO.output(27, GPIO.HIGH)
    else:
    GPIO.output(27, GPIO.LOW)

    def set_track_solo(track, solo):
    track.solo = solo
    if solo:
    GPIO.output(22, GPIO.HIGH)
    else:
    GPIO.output(22, GPIO.LOW)

    # Create a function to map Reaper tracks to GPIO pins
    def map_track(track):
    # Connect to Reaper
    reapy.connect()
    # Get the track from Reaper
    track = reapy.Track(track)
    # Set the track’s volume, mute, and solo status
    set_track_volume(track, track.volume)
    set_track_mute(track, track.mute)
    set_track_solo(track, track.solo)
    # Disconnect from Reaper
    reapy.disconnect()

    # Map Reaper track 1 to GPIO pins
    map_track(1)

    # Clean up the GPIO pins
    GPIO.cleanup()

    Python OSC device – Motarized fader for volume + mute switch and solo switch

    import reapy
    import OSC

    # Create an OSC client to send messages to Reaper
    client = OSC.OSCClient()
    client.connect(("127.0.0.1", 8000))

    # Create an OSC server to receive messages from the fader and switches
    server = OSC.OSCServer(("127.0.0.1", 9000))

    def handle_volume(path, tags, args, source):
    volume = args[0]
    # Set the volume of the track using the Reaper API
    reapy.connect()
    track = reapy.Track(1)
    track.volume = volume
    reapy.disconnect()

    # Add a callback for the volume fader
    server.addMsgHandler("/volume", handle_volume)

    def handle_mute(path, tags, args, source):
    mute = args[0]
    # Set the mute of the track using the Reaper API
    reapy.connect()
    track = reapy.Track(1)
    track.mute = mute
    reapy.disconnect()

    # Add a callback for the mute switch
    server.addMsgHandler("/mute", handle_mute)

    def handle_solo(path, tags, args, source):
    solo = args[0]
    # Set the solo of the track using the Reaper API
    reapy.connect()
    track = reapy.Track(1)
    track.solo = solo
    reapy.disconnect()

    # Add a callback for the solo switch
    server.addMsgHandler("/solo", handle_solo)

    # Run the OSC server
    st = threading.Thread(target=server.serve_forever)
    st.start()

    CSV with a time and label to the reaper time line markers

    python script that sends a CSV with a time (in seconds) and labels to the reaper API and converts them into timeline markers

    import csv
    from reaper_python import *

    # Open the CSV file
    with open('markers.csv', 'r') as csvfile:
    # Read the CSV file
    reader = csv.reader(csvfile)
    next(reader) # skip the header
    # Iterate through the rows
    for row in reader:
    time = float(row[0])
    label = row[1]
    # Convert the time to a Reaper time format
    reaper_time = int(time * 1000)
    # Create a new marker at the specified time
    RPR_AddProjectMarker2(0, False, reaper_time, 0, label, -1, 0)

    BESKAR2D2 – test board with RJ45

    #include <ReefwingSBUS.h>
    #define MIN_LEFT_ROLL    -255
    #define MAX_LEFT_ROLL     255
    #define MIN_LEFT_PITCH    -255
    #define MAX_LEFT_PITCH     255
    #define MIN_RIGHT_ROLL   -255
    #define MAX_RIGHT_ROLL    255
    #define MIN_RIGHT_PITCH   -255
    #define MAX_LEFT_PITCH    255
    #define MIN_SBUS          200
    #define MAX_SBUS          1800
    //#define SWITCH_ON         991
    SBUS RX_from_RADIOLINK(Serial3);
    uint16_t channels[16];
    uint16_t lostFrameCtr = 0;
    uint16_t sbusChannel6 = 0, sbusChannel7 = 0, sbusChannel8 = 0, sbusChannel5 = 0, rxMode = 0;
    int16_t sbusChannel1 = 0, sbusChannel2 = 0, sbusChannel3 = 0, sbusChannel4 = 0;
    bool failSafe;
    bool lostFrame;
    bool armed = false;
    void setup() {
      //  Start Serial and wait for connection from computer
      Serial.begin(115200);
      while (!Serial);
      RX_from_RADIOLINK.begin();
    //BLUE RJ45 WIRE A
      pinMode(26, OUTPUT);
      pinMode(27, OUTPUT);
      pinMode(28, OUTPUT);
      pinMode(29, OUTPUT);
    //wHITE WIRE  RJ45 WIRE b
      pinMode(30, OUTPUT);
      pinMode(31, OUTPUT);
      pinMode(32, OUTPUT);
      pinMode(33, OUTPUT);
    //BLUE RJ45 WIRE B
      pinMode(34, OUTPUT);
      pinMode(35, OUTPUT);
      pinMode(36, OUTPUT);
      pinMode(37, OUTPUT);
    //WHITE RJ45 WIRE B
      pinMode(38, OUTPUT);
      pinMode(39, OUTPUT);
      pinMode(40, OUTPUT);
      pinMode(41, OUTPUT);
    //GREY RJ45 WIRE A
      pinMode(45, OUTPUT);//this is capable of PWM//speed
      pinMode(49, OUTPUT);//direction
      pinMode(50, OUTPUT);//BRAKE
      pinMode(51, OUTPUT);//STOP
    //GREY RJ45 WIRE B
      pinMode(44, OUTPUT);//this is capable of PWM  //SPEED
      pinMode(48, OUTPUT);//DIRECTION
      pinMode(46, OUTPUT);//BRAKE
      pinMode(47, OUTPUT);//STOP
    }
    void loop() {
      // Check for a valid SBUS packet from the RX_from_RADIOLINK receiver
      if (RX_from_RADIOLINK.read(&channels[0], &failSafe, &lostFrame)) {
       //Scale the joysticks to the min and max
        sbusChannel1 = map(channels[0], MIN_SBUS, MAX_SBUS, MIN_LEFT_ROLL, MAX_LEFT_ROLL);
        sbusChannel2  = map(channels[1], MIN_SBUS, MAX_SBUS,  MAX_LEFT_PITCH,MIN_LEFT_PITCH);
        sbusChannel4 = map(channels[3], MIN_SBUS, MAX_SBUS, MIN_RIGHT_PITCH, MAX_LEFT_PITCH);
        sbusChannel3 = map(channels[2], MIN_SBUS, MAX_SBUS, MIN_RIGHT_ROLL, MAX_RIGHT_ROLL);
        //  AUX Channels
        sbusChannel5 = channels[4];
        sbusChannel6     = channels[5];
        sbusChannel7    = channels[6];
        sbusChannel8    = channels[7];
        rxMode   = channels[8];
        if (lostFrame) { lostFrameCtr++; }
      //LEFT SWITCH
      switch (sbusChannel7) {
        case 200:
          Serial.print(“LS”);Serial.print(“A”);Serial.print(“\t”);
                    digitalWrite(31, HIGH);
                      digitalWrite(32, LOW);
                      digitalWrite(33, LOW);
                break;
        case 1000:
          Serial.print(“LS”);Serial.print(“B”);Serial.print(“\t”);
                       digitalWrite(31, LOW);
                      digitalWrite(32,HIGH);
                      digitalWrite(33, LOW);
          break;
        case 1800:
          Serial.print(“LS”);Serial.print(“C”);Serial.print(“\t”);
          digitalWrite(31, LOW);
                      digitalWrite(32, LOW);
                      digitalWrite(33, HIGH);
          break;
        default:
         Serial.println(“Invalid value”);
      }
    /////////////////////////////// LEFT VOLUME
          Serial.print(“LV”);Serial.print(sbusChannel8); Serial.print(“\t”);
    ////LEFT X
            Serial.print(“LX”);Serial.print(sbusChannel4); Serial.print(“\t”);
          if (sbusChannel4 >= -255 && sbusChannel4 < -50) {
        // sbusChannel is within the range from -100 to -50
                      digitalWrite(38, HIGH);
                      digitalWrite(39, HIGH);
                      digitalWrite(40, LOW);
                      digitalWrite(41, LOW);
    } else if (sbusChannel4 >= -50 && sbusChannel4 < -10) {
        // sbusChannel is within the range from -50 to -10
                       digitalWrite(38, HIGH);
                      digitalWrite(39, LOW);
                      digitalWrite(40, LOW);
                      digitalWrite(41, LOW);
    } else if (sbusChannel4 >= -10 && sbusChannel4 < 10) {
        // sbusChannel is within the range from -10 to 10
                      digitalWrite(38, LOW);
                      digitalWrite(39, LOW);
                      digitalWrite(40, LOW);
                      digitalWrite(41, LOW);
    } else if (sbusChannel4 >= 10 && sbusChannel4 < 50) {
        // sbusChannel is within the range from 10 to 50
                      digitalWrite(38, LOW);
                      digitalWrite(39, LOW);
                      digitalWrite(40, LOW);
                      digitalWrite(41, HIGH);
    } else if (sbusChannel4 >= 50 && sbusChannel4 <= 255) {
        // sbusChannel is within the range from 50 to 100
                      digitalWrite(38, LOW);
                      digitalWrite(39, LOW);
                      digitalWrite(40, HIGH);
                      digitalWrite(41, HIGH);
    } else {
        // sbusChannel is outside of all of the specified ranges
    }
    //////////////////////LEFT Y AXIS
        Serial.print(“LY”);Serial.print(sbusChannel3); Serial.print(“\t”);
          if (sbusChannel3 >= -255 && sbusChannel3 < -50) {
        // sbusChannel is within the range from -100 to -50
                      analogWrite(45,fabs(sbusChannel3) );//speed
                      digitalWrite(49, LOW);//direction
                      digitalWrite(50, LOW);//BRAKE
                      digitalWrite(51, LOW);//STOP//
    Serial.print(“RF”);
    } else if (sbusChannel3 >= -50 && sbusChannel3 < -10) {
        // sbusChannel is within the range from -50 to -10
                      analogWrite(45,fabs(sbusChannel1) );//speed
                      digitalWrite(49, LOW);//direction
                      digitalWrite(50, HIGH);//BRAKE
                      digitalWrite(51, LOW);//STOP//
    Serial.print(“RS”);
    } else if (sbusChannel3 >= -10 && sbusChannel3 < 10) {
        // sbusChannel is within the range from -10 to 10
                       analogWrite(45,fabs(sbusChannel3) );//speed
                      digitalWrite(49, LOW);//direction
                      digitalWrite(50, HIGH);//BRAKE
                      digitalWrite(51, HIGH);//STOP//
    Serial.print(“SS”);
    } else if (sbusChannel3 >= 10 && sbusChannel3 < 50) {
        // sbusChannel is within the range from 10 to 50
                      analogWrite(45,fabs(sbusChannel3) );//speed
                      digitalWrite(49, HIGH);//direction
                      digitalWrite(50, HIGH);//BRAKE
                      digitalWrite(51, LOW);//STOP//
    Serial.print(“FS”);
    } else if (sbusChannel3 >= 50 && sbusChannel3 <= 255) {
        // sbusChannel is within the range from 50 to 100
                      analogWrite(45,fabs(sbusChannel3) );//speed
                      digitalWrite(49, HIGH);//direction
                      digitalWrite(50, LOW);//BRAKE
                      digitalWrite(51, LOW);//STOP//
    Serial.print(“FF”);
    } else {
        // sbusChannel is outside of all of the specified ranges
    }
     Serial.print(“\t”);
     Serial.print(“\t”);
     Serial.print(“\t”);
    //////////////////////////////
    //RIGHT SIDE OF CONTROLLER
    /////////////////////////////
    ////////////////////////////////
        Serial.print(“RX”);Serial.print(sbusChannel1); Serial.print(“\t”);
          if (sbusChannel1 >= -255 && sbusChannel1 < -50) {
        // sbusChannel is within the range from -100 to -50
                      digitalWrite(34, HIGH);
                      digitalWrite(35, HIGH);
                      digitalWrite(36, LOW);
                      digitalWrite(37, LOW);
    } else if (sbusChannel1 >= -50 && sbusChannel1 < -10) {
        // sbusChannel is within the range from -50 to -10
                       digitalWrite(34, HIGH);
                      digitalWrite(35, LOW);
                      digitalWrite(36, LOW);
                      digitalWrite(37, LOW);
    } else if (sbusChannel1 >= -10 && sbusChannel1 < 10) {
        // sbusChannel is within the range from -10 to 10
    digitalWrite(34, LOW);
                      digitalWrite(35, LOW);
                      digitalWrite(36, LOW);
                      digitalWrite(37, LOW);
    } else if (sbusChannel1 >= 10 && sbusChannel1 < 50) {
        // sbusChannel is within the range from 10 to 50
        digitalWrite(34, LOW);
                      digitalWrite(35, LOW);
                      digitalWrite(36, LOW);
                      digitalWrite(37, HIGH);
    } else if (sbusChannel1 >= 50 && sbusChannel1 <= 255) {
        // sbusChannel is within the range from 50 to 100
        digitalWrite(34, LOW);
                      digitalWrite(35, LOW);
                      digitalWrite(36, HIGH);
                      digitalWrite(37, HIGH);
    } else {
        // sbusChannel is outside of all of the specified ranges
    }
    ///////////////////////////////////////RIGHT Y
        Serial.print(“RY”);Serial.print(sbusChannel2); Serial.print(“\t”);
          if (sbusChannel2 >= -255 && sbusChannel2 < -50) {
        // sbusChannel is within the range from -100 to -50
                      analogWrite(44,fabs(sbusChannel2) );//speed
                      digitalWrite(48, LOW);//direction
                      digitalWrite(46, LOW);//BRAKE
                      digitalWrite(47, LOW);//STOP
    Serial.print(“RF”);
    } else if (sbusChannel2 >= -50 && sbusChannel2 < -10) {
        // sbusChannel is within the range from -50 to -10
                       analogWrite(44,fabs(sbusChannel2) );//speed
                      digitalWrite(48, LOW);//direction
                      digitalWrite(46, HIGH);//BRAKE
                      digitalWrite(47, LOW);//STOP
    Serial.print(“RS”);
    } else if (sbusChannel2 >= -10 && sbusChannel2 < 10) {
        // sbusChannel is within the range from -10 to 10
                      analogWrite(44,fabs(sbusChannel2) );//speed
                      digitalWrite(48, LOW);//direction
                      digitalWrite(46, HIGH);//BRAKE
                      digitalWrite(47, HIGH);//STOP
    Serial.print(“ST”);
    } else if (sbusChannel2 >= 10 && sbusChannel2 < 50) {
        // sbusChannel is within the range from 10 to 50
                      analogWrite(44,fabs(sbusChannel2) );//speed
                      digitalWrite(48, HIGH);//direction
                      digitalWrite(46, LOW);//BRAKE
                      digitalWrite(47, LOW);//STOP
                    Serial.print(“FS”);
    } else if (sbusChannel2 >= 50 && sbusChannel2 <= 255) {
        // sbusChannel is within the range from 50 to 100
                      analogWrite(44,fabs(sbusChannel2) );//speed
                      digitalWrite(48, HIGH);//direction
                      digitalWrite(46, LOW);//BRAKE
                      digitalWrite(47, LOW);//STOP
                      Serial.print(“FF”);
    } else {
        // sbusChannel is outside of all of the specified ranges
    }
    Serial.print(“\t”);
         //Serial.print(“RB”);Serial.print(sbusChannel6); Serial.print(“\t”);
    switch (sbusChannel6) {
        case 200:
          Serial.print(“RB”);Serial.print(“O”);Serial.print(“\t”);
                      digitalWrite(26, LOW);
                      digitalWrite(30, LOW);
                break;
        case 1800:
        Serial.print(“RB”);  Serial.print(“P”);Serial.print(“\t”);
                      digitalWrite(26, HIGH);
                          digitalWrite(30, HIGH);
          break;
        default:
          Serial.print(“RB”);Serial.print(“Invalid value”);Serial.print(“\t”);
          digitalWrite(26, LOW);
          digitalWrite(30, LOW);
          break;
      }
    ;
      switch (sbusChannel5) {
        case 200:
          Serial.print(“RS”);Serial.print(“A”);Serial.print(“\t”);
                      digitalWrite(27, HIGH);
                      digitalWrite(28, LOW);
                      digitalWrite(29, LOW);
                      break;
        case 1000:
          Serial.print(“RS”);Serial.print(“B”);Serial.print(“\t”);
                      digitalWrite(27, LOW);
                      digitalWrite(28,HIGH);
                      digitalWrite(29, LOW);
                      break;
        case 1800:
        Serial.print(“RS”);  Serial.print(“C”);Serial.print(“\t”);
                      digitalWrite(27, LOW);
                      digitalWrite(28, LOW);
                      digitalWrite(29, HIGH);
          break;
        default:
          Serial.print(“RS”);Serial.print(“Invalid value”);Serial.print(“\t”);
                            digitalWrite(27, LOW);
                      digitalWrite(28, LOW);
                      digitalWrite(29, LOW);
      }
    ;
    Serial.print(“\t”);
           Serial.println(rxMode);
      }
      delay(10);
    }