BESKAR2D2 – test board with RJ45

Posted on by
#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!

Posted on by
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

Posted on by

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.

Metric Frame Rates: Banishing the Bizarre

Posted on by

Metric Frame Rates: Banishing the Bizarre

In a digital world governed by binary precision, there is a ghost in the machine. It appears in the settings menus of our cameras and the export windows of our editing software. It is the spectral presence of fractional math: 23.976, 29.97, and 59.94.

These numbers are messy. They are relics. It is time we fully embraced a concept that brings sanity back to video: Metric Frame Rates.

Defining the Metric Frame Standard

What are Metric Frame Rates? They are the clean, integer-based measurements of time that align perfectly with the way we count seconds. They are the logical progression of temporal resolution:

* 25 fps: The cinematic baseline.

* 50 fps: The standard for smooth, lucid motion.

* 100 fps: High precision and clarity.

* 200 fps: Extreme fluidity and slow-motion capability.

Unlike the fractional legacy standards, these rates—25, 50, 100, and 200—do not require a calculator to determine how many frames exist in an hour of footage. They are absolute.

The NTSC Hangover: Where the “Weird” Came From

To understand the beauty of Metric Frame Rates, you have to look at the chaos they replace.

For decades, North America and parts of Asia have been stuck with the “NTSC” standard. Originally, black and white television ran at a clean 30 frames per second. But when engineers added color in the 1950s, they hit a snag: the color signal interfered with the audio signal.

Their solution? Slow the video down by exactly 0.1%.

Suddenly, 30 fps became 29.97 fps. 60 fields per second became 59.94. Cinema’s 24 fps was slowed to 23.976.

This “fractional frame rate” created a nightmare for editors and engineers. Timecode became a headache (Drop-Frame vs. Non-Drop Frame). Audio drifted out of sync over long durations. We have been carrying this baggage for over half a century, long after the analog cathode-ray tubes that required it were thrown into landfills.

The Elegance of the Metric System

Metric Frame Rates (rooted historically in the PAL/SECAM regions and 50Hz power grids) bypassed this absurdity. They stuck to the integers.

1. The Mathematical Harmony

Metric rates scale perfectly.

* 25 fits into 50 exactly twice.

* 50 fits into 100 exactly twice.

* 100 fits into 200 exactly twice.

This base-2 geometric progression makes frame-rate conversion, math, and compression algorithms significantly more efficient. If you shoot at 100 fps and want to slow it down to 25 fps, the math is flawless: play every frame for 4x slow motion. No “pulldown” patterns, no jitter, no ghost frames.

2. 25 fps: The Aesthetic Sweet Spot

While Hollywood clings to 24 (or the dreaded 23.976), 25 fps offers a nearly identical aesthetic experience with a slightly higher temporal resolution. It retains the “dreamlike” quality of film without the fractional headache.

3. 50 fps: The Reality Standard

50 frames per second is the metric answer to the “soap opera effect,” but used correctly, it provides the “being there” feeling required for news, sports, and documentation. It captures reality with fluid precision, free from the flicker of lower rates.

4. 100 and 200 fps: The Future of Clarity

As we push into high-refresh-rate displays (120Hz, 144Hz, 240Hz), Metric Frame Rates like 100 and 200 are becoming vital. They offer a hyper-real smoothness that 29.97 can never achieve. Furthermore, 100 fps serves as the perfect “universal donor” for slow motion—fast enough to capture high-speed action, but mathematically simple enough to conform down to 50 or 25 for delivery

We no longer live in an analog world of interfering radio frequencies. We live in a digital world of absolute values.

There is no technical reason for a modern digital creator to be forced to use 29.97 unless they are broadcasting to legacy television networks. For the rest of us—creating for the web, for streaming, and for the future—it is time to reject the bizarre numbers of the past.

It is time to standardize on the clean, logical, and precise integers of 25, 50, 100, and 200.