neopixel party lights

import board
import neopixel
import time

# Define the number of pixels in the strip and the pin it is connected to
num_pixels = 60
pixels = neopixel.NeoPixel(board.D18, num_pixels)

# Define the party LED sequence
sequence = [
(255, 0, 0), # Red
(0, 255, 0), # Green
(0, 0, 255), # Blue
(255, 255, 0), # Yellow
(255, 0, 255), # Purple
(0, 255, 255) # Cyan
]

while True:
for color in sequence:
for i in range(num_pixels):
pixels[i] = color
pixels.show()
time.sleep(0.05)

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() Continue reading →

    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);
    }

    I asked Chat GPT to write arduino code – and it blew my mind!

    Write and Arduino sketch that has 4 motor controllers and s-bus inputs from a remote control. Then midi notes for each motor controller.

    Sure! Here is an example of an Arduino sketch that uses four motor controllers and receives s-bus inputs from a remote control, and also maps MIDI notes to each motor controller:

    #include <SBUS.h> // include the SBUS library
    #include <MIDI.h> // include the MIDI library

    // define the pin numbers for the s-bus input and the four motor controllers
    const int SBUS_PIN = 10;
    const int MOTOR1_PIN = 3;
    const int MOTOR2_PIN = 5;
    const int MOTOR3_PIN = 6;
    const int MOTOR4_PIN = 9;

    // create an instance of the SBUS library
    SBUS sbus(SBUS_PIN);

    // create an instance of the MIDI library
    MIDI_CREATE_DEFAULT_INSTANCE();

    void setup() {
    // initialize the s-bus input and the four motor controllers
    sbus.begin();
    pinMode(MOTOR1_PIN, OUTPUT);
    pinMode(MOTOR2_PIN, OUTPUT);
    pinMode(MOTOR3_PIN, OUTPUT);
    pinMode(MOTOR4_PIN, OUTPUT);

    // begin MIDI communication
    MIDI.begin(MIDI_CHANNEL_OMNI);
    }

    void loop() {
    // read the s-bus input
    sbus.read();

    // get the values of the channels from the s-bus input
    int channel1 = sbus.getChannel(1);
    int channel2 = sbus.getChannel(2);
    int channel3 = sbus.getChannel(3);
    int channel4 = sbus.getChannel(4);

    // set the speed of the first motor based on the value of channel 1
    analogWrite(MOTOR1_PIN, channel1);

    // set the speed of the second motor based on the value of channel 2
    analogWrite(MOTOR2_PIN, channel2);

    // set the speed of the third motor based on the value of channel 3
    analogWrite(MOTOR3_PIN, channel3);

    // set the speed of the fourth motor based on the value of channel 4
    analogWrite(MOTOR4_PIN, channel4);

    // check for incoming MIDI messages
    MIDI.read();

    // if a MIDI note on message is received, set the speed of the corresponding motor
    if (MIDI.getType() == midi::NoteOn) {
    int note = MIDI.getData1(); // get the MIDI note number
    int velocity = MIDI.getData2(); // get the MIDI velocity value

    // map the MIDI note to a motor controller and set its speed
    if (note == 60) { // map MIDI note 60 to motor 1
    analogWrite(MOTOR1_PIN, velocity);
    }
    else if (note == 61) { // map MIDI note 61 to motor 2
    analogWrite(MOTOR2_PIN, velocity);
    }
    else if (note == 62) { // map MIDI note 62 to motor 3
    analogWrite(MOTOR3_PIN, velocity);
    }
    else if (note == 63) { // map MIDI note 63 to motor 4
    analogWrite(MOTOR4_PIN, velocity);

    Adult Autism and Awareness

    1. Feeling Like an Outsider

    The sentiment of being on the outside looking in, even in social groups, resonates with many. This recognition can be an important step in understanding oneself and how social dynamics work.

    2. Balance Between Isolation and Connection

    the duality of needing solitude to recharge after social interactions while also feeling the weight of loneliness. Finding a balance is essential for emotional well-being.

    3. Shifts in Social Needs Over Time

    There’s an interesting perspective that social needs evolve with age. Early in life, there’s a strong biological drive to socialize. As people age, the focus often shifts toward isolation or smaller, meaningful connections before swinging back to a desire for socializing later in life. For those on the autism spectrum, this shift may be complicated by delays in emotional maturity or differences in social awareness.

    4. Importance of Emotional Growth

    Therapy and self-reflection are highlighted as tools for developing emotional maturity and understanding the why behind behavioral changes, rather than simply conforming to fit in. This kind of growth can lead to more authentic connections.

    5. Navigating Loneliness Through Self-Awareness

    For many, learning about themselves and their needs, often through communities, helps them better navigate social interactions and combat feelings of isolation.