More work on the Robot Arm - EEZYBot Mk 2

 In March 2017 I 3D printed a Robot arm.  The original post is here:

https://langster1980.blogspot.com/2017/03/another-robot-arm.html

I saw the arm in amongst a pile of boxes covered in dust and looking rather sad.  In a moment of pure nostalgia...and possibly guilt I decided the robot arm needed a new lease of life and some purpose.  To be fair this is also true for me.  I rarely make time for personal projects and blog posts these days...this will hopefully change.

I also managed to find the boards I had made by Elecrow and I must have intended something as It was populated and working!  

There were various broken 3D printed parts and linkages on the Robot arm that I have 3D printed and replaced.  I also upgraded the base servo motor and the gripper.

Here is the new and improved robot arm😆

EEZYBot Mk2 - my implementation - design credits to Daguismo the original designer

The sense of satisfaction at getting this working reminded me of why I chose engineering as a profession and I really must make more time for this.

To that end I wrote up some new arduino code which I then decided to have Google Gemini assist me with.  It actually did an excellent job and provided some significant improvements.

The arduino code is here: Robot Arm Arduino Code

The code essential works as follows:

1. Prompt the user via the serial terminal as to whether they want Local potentiometer control or Serial Control

2. Handle the inputs from the serial terminal (and the Python front end)

3. Handle the inputs from the potentiometers

4. Drive the servo motors appropriately

The table below provides further information:

Section	Purpose	Key Mechanism
State & Mode	Defines the two control modes (M0 Serial, M1 Potentiometer).	The global variable currentMode dictates which handler runs in the loop().
handleSerialControl()	Reads all incoming commands (M0, S5, U90, ; comment) from Python.	Uses Serial.readStringUntil('\n') to read entire commands and a switch statement to process them. It ignores lines starting with ;.
handlePotControl()	Reads the analog values from the potentiometers.	readSmoothAnalog() averages multiple samples to prevent noisy/jittery movement.
Target Setting	Updates the target angle (targetBase, targetUpper, etc.).	setServoTarget() takes the desired angle (from serial or a pot) and updates the target variable, but does not move the servo yet.
handleRamping()	Manages the speed and movement of the servos.	Runs every 20ms (RAMPING\_INTERVAL\_MS). It moves the servo's current position (posBase) only a small step (maxSpeed) closer to its final target position (targetBase). This creates the smooth, speed-controlled motion.
reportCurrentPosition()	Sends the arm's actual position back to the Python GUI.	Sends a dedicated string (e.g., P:B85,U90,...) every 100ms to synchronize the GUI sliders with the physical arm.

I also...with Google Gemini's assistance wrote a Python front end which provides a graphical user interface to the serial terminal - very cool.  I am not a great python coder...with the AI assistance a lot was achieved.

The Python Code is here: Robot Arm Python GUI

Here is a screen shot of the GUI

Here is how the code roughly works:

Function	Purpose	Connection to Arduino
connect_serial()	Establishes the connection and starts the arm.	Creates the serial.Serial object. It includes a 2-second time.sleep(2) to wait for the Arduino to reboot.
initialize_arm_position()	Runs the initial setup (M0, S2, B85...) to guarantee a safe, stable starting state after connection.	Sends commands line-by-line using self.ser.write().
serial_reader()	Runs in a separate thread to constantly listen for incoming data from the Arduino.	Uses self.ser.readline() in a loop. It looks for lines starting with P:.
update_gui_position()	Synchronizes the interface sliders with the physical arm position.	Crucially, it ignores position updates if the GUI is set to Serial Mode (M0) to prevent the Arduino's periodic report from overriding a position you just selected on a slider.
run_sequence()	Manages script execution.	Runs in its own thread to prevent the GUI from freezing. It sends commands separated by the configurable Delay. It checks the self.stop_requested flag to allow immediate interruption.
record_all_positions()	Creates movement script lines.	Reads the current angle values from the synchronized sliders and formats them into the line-by-line command structure (e.g., U90\nL150\n).

Finally here is a video of the arm performing a pre-determined function <massive grin>

I intend doing a lot more with this Robot arm now that I have it working reasonably consistently.  I have always wanted to couple a robot arm with an AI assisted camera to perform sorting operations...so that's next.  I expect I will need to create a leader arm to assist with creating the AI learning model.

Take care as always - Langster!

Create Wiring Harnesses using WireViz 0.41

I often need to create diagrams showing how to make wiring harnesses for test cables in work.  I have tried previous versions of WireViz and found it to be useful but needed a little more work.  I am not a coder by any stretch of the imagination and YAML (Yet Another Markup Language) syntax is new to me.

Here is the Hackaday article on WireViz:

https://hackaday.com/2020/06/23/an-open-source-tool-to-document-your-wiring/

Installing WireViz is fairly simple assuming one has Python installed properly and the system variables in the path.  Instructions for installing Python correctly here:

https://docs.python.org/3/using/windows.html#

Ensure you add the python path to the system variables...if this doesn't happen WireViz does not work.

Next grab the latest version of Wireviz....

Open a command prompt and type:

pip install wireviz

Once installed check things are working by typing:

wireviz --version

If things are working correctly the result should read:

WireViz 0.4.1

If that doesn't happen please check your python installation and system variables etc.

For reference here is the git repository for the WireViz Project - it contains useful information and example files:

https://github.com/wireviz/WireViz

If WireViz has correctly installed we can start to create a simple wiring harness diagram. Lets create a simple test cable - a BNC to screw terminals connector on one end and a red 4 mm banana connector and a black 4 mm banana connector at the other end with two red and black wires which are 24 AWG.  Lets make the cable 400 mm in length.

To describe this in YAML we create a text file.  I like to use notepad++ but one can use any text editor they wish providing it can save the file with a yml extension.  We can call it whatever we like but it is good practice to use a sensible filename.  I called mine BNC2Banana.yml.  Ensure you save it in a folder you can locate.

While we are at it lets create a folder called IMG within the same folder we are using to store the text file.  We will need this later...

Lets look at the example code provided for some context:

connectors:
  X1:
    type: D-Sub
    subtype: female
    pinlabels: [DCD, RX, TX, DTR, GND, DSR, RTS, CTS, RI]
  X2:
    type: Molex KK 254
    subtype: female
    pinlabels: [GND, RX, TX]

cables:
  W1:
    gauge: 0.25 mm2
    length: 0.2
    color_code: DIN
    wirecount: 3
    shield: true

connections:
  - - X1: [5, 2, 3]
    - W1: [1, 2, 3]
    - X2: [1, 3, 2]
  - - X1: 5
    - W1: s

Ok so the code is fairly easy to read...lets break things down:

The code creates a wiring harness with two connector types (X1 and X2) - a 9 pin D-type connector and a three pin molex kk connector with 2.54 mm pitch.  An RS232 serial cable has the following signals present: DCD, RX, TX, DTR, GND, DSR, RTS, CTS and RI.  The code makes connections to GND, RX and TX which will be present at the Molex Connector.  The wire type is set in the cables: section - the wire gauge used will be 0.25 mm squared cable and will use the DIN colour code and the cable itself will be 200 mm in length or 0.2 metres.

If we run this code the output looks like this:

We are going to edit this code for our own purposes to create our test cable:

Instead of calling the connectors X1 and X2 lets use variable names that make sense:  Lets call them what they actually are:

4mm_Red_Banana:

4mm_Black_Banana:

BNC_SCREW_Terminal:

Let us also update the type and pinlables variables to something more appropriate:

type:

Therefore our code should look like this:

connectors:
 
  4mm_Red_Banana: 4mm_Banana_Red # Red 4mm Banana
    type: 4 mm Red Banana Connector
    pinlabels: [+VE]
    
  4mm_Black_Banana: 4mm_Banana_Black # Black 4mm Banana
    type: 4 mm Black Banana Connector
    pinlabels: [GND]

  BNC_SCREW_Terminal: # Female BNC to Screw Terminals
    type: BNC Connector female - Screw Terminal
    pinlabels: [+VE, GND]

The next section of the code relates to the cable itself (cables: Section).  We want to use something sensible but we only need two wires and I would like to specify the insulation jacket colour and the length as well as the gauge.  To achieve that we can update the code as follows:

cables:
 
  C:
    colors: [RD, BK] # number of wires implicit in color list
    gauge: 0.25 mm2 # also accepts AWG as unit
    show_equiv: true # auto-calculate AWG equivalent from metric gauge
    length: 0.4 # length in m
    shield: false

I have chosen to call the cable C as opposed to W1. It makes more sense to me. Feel free to use your own variable names...

Finally we need to write the code which describes how the connectors and cables are connected which is denoted in the connectors: section...I like how simple this actually is to read...

The BNC connector pin 1 needs to connect to the cable C1 which will have a red insulation jacket and then on to the red 4 mm banana connector.  The BNC connector pin 2 needs to connect to Cable C2 which will have a black insulation jacket which in turn connects to the black 4 mm banana connector.

The code looks like this:

connections:
  -
    - BNC_SCREW_Terminal: [1]
    - C.C1: [1]
    - 4mm_Red_Banana: [1]
  -
    - BNC_SCREW_Terminal: [2]
    - C.C1: [2]
    - 4mm_Black_Banana: [1]

The entire code for reference looks like this:

connectors:
 
  4mm_Red_Banana: # Red 4mm Banana
    type: 4 mm Red Banana Connector
    pinlabels: [+VE]
    
  4mm_Black_Banana: # Black 4mm Banana
    type: 4 mm Black Banana Connector
    pinlabels: [GND]

  BNC_SCREW_Terminal: # Female BNC to Screw Terminals
    type: BNC Connector female - Screw Terminal
    pinlabels: [+VE, GND]
    
cables:
 
  C:
    colors: [RD, BK] # number of wires implicit in color list
    gauge: 0.25 mm2 # also accepts AWG as unit
    show_equiv: true # auto-calculate AWG equivalent from metric gauge
    length: 0.4 # length in m
    shield: false
 
connections:
  -
    - BNC_SCREW_Terminal: [1]
    - C.C1: [1]
    - 4mm_Red_Banana: [1]
  -
    - BNC_SCREW_Terminal: [2]
    - C.C1: [2]
    - 4mm_Black_Banana: [1]

Save the code - always a good idea!

Jump into a command prompt and navigate to the directory where you have saved your YAML code:

Type the following command:

WireViz BNC2BananaSimple.yml

If everything has gone according to plan you should see the following response:

A number of files should have been created in the folder:

• An SVG file
• An HTML file
• A TSV file
• A PNG file

If we look at the PNG file we can see our cable harness diagram:

The other files are copies of the above diagram except the TSV file which is a tab separated value file making up the bill of materials.

The above diagram should be more than enough information for a wiring person to create a wiring loom but due to the improvements in WireViz we can now add more code which in turn creates more information.

As 4 mm banana connectors are essentially all the same part apart from the number we can use some programming tricks to make the code slightly more easy to understand and we can add more information to make our diagram more comprehensive and the bill of materials more explicit:

connectors:
 
  4mm_Red_Banana: &4mm_Banana_t # https://uk.rs-online.com/web/p/banana-connectors/2080252
    pinlabels: [+VE]
    type: 4 mm Red Banana Connector
    manufacturer: RS Components
    mpn: 2080252
    supplier: uk.rs-online.com
    spn: 2080252
    subtype: male
    color: RD
    image:
      src: IMG/4mm.Red.Banana.png
 
  4mm_Black_Banana: # https://uk.rs-online.com/web/p/banana-connectors/2080251
    <<: *4mm_Banana_t
    pinlabels: [GND]
    type: 4 mm Black Banana Connector
    mpn: 2080251
    spn: 2080251
    color: BK
    image:
      src: IMG/4mm.Black.Banana.png
 
  BNC_SCREW_Terminal: # https://uk.rs-online.com/web/p/coaxial-adapters/1242521
    pinlabels: [+VE, GND]
    type: BNC Connector Male - Screw Terminal
    manufacturer: RS Components
    mpn: 1242521
    supplier: RS Components
    spn: 1242521
    subtype: female
    color: BK
    image:
      src: IMG/BNC-SCREW-TERM-MALE.png

The change in the connectors section is the line containing this:

&4mm_Banana_t

Essentially what this line of code does is create a template for the 4 mm banana connector type.   

It means that connectors of the same type but with slightly different attributes can be used without quite so much typing needed.  If we look at the next connector section it references the template with this line of code:

<<: *4mm_Banana_t

The rest of the code should be self explanatory.

We now need to obtain some images of our connectors.  I downloaded some stock images with white backgrounds:

The BNC to Screw Terminal Connector

The Red 4 mm Banana Connector

The Black 4 mm Banana Connector

Save these pictures (or find your own) into the IMG folder we created earlier.  Be sure to rename them to the same names used in the code:

• 4mm.Red.Banana.png
• 4mm.Black.Banana.png
• BNC-SCREW-TERM-MALE.png

The rest of the code remains unchanged but for completeness here it is in case it is needed:

   

connectors:
 
  4mm_Red_Banana: &4mm_Banana_t # https://uk.rs-online.com/web/p/banana-connectors/2080252
    pinlabels: [+VE]
    type: 4 mm Red Banana Connector
    manufacturer: RS Components
    mpn: 2080252
    supplier: uk.rs-online.com
    spn: 2080252
    subtype: male
    color: RD
    image:
      src: IMG/4mm.Red.Banana.png
 
  4mm_Black_Banana: # https://uk.rs-online.com/web/p/banana-connectors/2080251
    <<: *4mm_Banana_t
    pinlabels: [GND]
    type: 4 mm Black Banana Connector
    mpn: 2080251
    spn: 2080251
    color: BK
    image:
      src: IMG/4mm.Black.Banana.png
 
  BNC_SCREW_Terminal: # https://uk.rs-online.com/web/p/coaxial-adapters/1242521
    pinlabels: [+VE, GND]
    type: BNC Connector Male - Screw Terminal
    manufacturer: RS Components
    mpn: 1242521
    supplier: RS Components
    spn: 1242521
    subtype: female
    color: BK
    image:
      src: IMG/BNC-SCREW-TERM-MALE.png
 
cables:
 
  C:
    colors: [RD, BK] # number of wires implicit in color list
    gauge: 0.25 mm2 # also accepts AWG as unit
    show_equiv: true # auto-calculate AWG equivalent from metric gauge
    length: 0.4 # length in m
    shield: false
    mpn: UL1007-24AWG
 
connections:
  -
    - BNC_SCREW_Terminal: [1]
    - C.C1: [1]
    - 4mm_Red_Banana: [1]
  -
    - BNC_SCREW_Terminal: [2]
    - C.C1: [2]
    - 4mm_Black_Banana: [1]

With that done we can now re-run the WireViz command and we get a different and in my opinion, a much improved diagram:

In my opinion that is a more than satisfactory diagram for a test cable harness.  There are ways to set the page size adding a header section to ensure that the code is more readable.  I would like to be able to add a template with a title block but at the moment this feature isn't working.

Here is the full code in case it might provide further insight:

metadata:
 
  title: BNC <-> 4 mm Banana
  pn: BNC2Banana01
 
  authors:
    Created: 2025-09-14
    name: Lang 
    date: 2025-09-14
    Approved:
      name: Lang 
      date: 2025-09-14
 
  revisions:
    A:
      name: Lang 
      date: 2025-09-14
      changelog: Initial commit
 
  template:
    name: din-6771
    sheetsize: A3
 
connectors:
 
  4mm_Red_Banana: &4mm_Banana_t # https://uk.rs-online.com/web/p/banana-connectors/2080252
    pinlabels: [+VE]
    type: 4 mm Red Banana Connector
    manufacturer: RS Components
    mpn: 2080252
    supplier: uk.rs-online.com
    spn: 2080252
    subtype: male
    color: RD
    image:
      src: IMG/4mm.Red.Banana.png
 
  4mm_Black_Banana: # https://uk.rs-online.com/web/p/banana-connectors/2080251
    <<: *4mm_Banana_t
    pinlabels: [GND]
    type: 4 mm Black Banana Connector
    mpn: 2080251
    spn: 2080251
    color: BK
    image:
      src: IMG/4mm.Black.Banana.png
 
  BNC_SCREW_Terminal: # https://uk.rs-online.com/web/p/coaxial-adapters/1242521
    pinlabels: [+VE, GND]
    type: BNC Connector Male - Screw Terminal
    manufacturer: RS Components
    mpn: 1242521
    supplier: RS Components
    spn: 1242521
    subtype: female
    color: BK
    image:
      src: IMG/BNC-SCREW-TERM-MALE.png
 
cables:
 
  C:
    colors: [RD, BK] # number of wires implicit in color list
    gauge: 0.25 mm2 # also accepts AWG as unit
    show_equiv: true # auto-calculate AWG equivalent from metric gauge
    length: 0.4 # length in m
    shield: false
    mpn: UL1007-24AWG
 
connections:
  -
    - BNC_SCREW_Terminal: [1]
    - C.C1: [1]
    - 4mm_Red_Banana: [1]
  -
    - BNC_SCREW_Terminal: [2]
    - C.C1: [2]
    - 4mm_Black_Banana: [1]

It is possible to use WireViz using Linux but I haven't had the time to try it.  I am confident it works just as well.

I used this blog post as reference material for this post but I changed it slightly.  If blog readers need more examples on how to use WireViz please leave a comment below.

I think that's all for now - take care always - Langster!

Plotting Data and performing integration using a spreadsheet program

I haven't written a post in ages...my apologies but I rarely have time these days or anything of interest to post about...my work has taken over. I hope to get back to writing and doing more things for myself but I have no idea when.  I suspect I will have to make myself get back into blogging.  It is useful as an aide memoire to myself if nothing else.  

A colleague asked me to plot some sensor data for him in a spreadsheet program and perform some analysis on it and to be completely honest I had forgotten how.

So I did some quick research and here is an example of what I did so that I can refer to it next time...It may be useful to someone else so I'm writing it up as a post.

Sensor data is collected in various ways but is normally saved to a text file in comma separated values.  

Here is an example of some comma separated value data:

sample,measurement1,measurement2
0,0,0
1,1,1.12
2,2,2.05
3,3,3.01
4,4,3.95
5,5,5.05
6,6,6.02
7,7,7.08
8,8,7.99
9,9,9.04
10,10,10.02

I made the data up as I cannot share the actual data that was discussed.

The first column is the sample No.

The second column is the current measurement in mA

The third column is the voltage measurement in volts

In case anyone is wondering these are supposed to be measurements from a simple circuit to find an unknown resistance.

A constant current power supply has been used to supply energy to an unknown resistor;  The voltage and current in the circuit were measured and recorded and the results are in the csv text file as shown above.

Here is the circuit:

Here is the tabulated measurement data:

Here is the data plotted as a line graph:

We can calculate the resistance and plot that as well...

So the Resistance (from Ohms Law) is equal to (measured volts / supplied current) * 1000

I have added a column to the table:

We can now plot this data as well if we wanted:

If we like we can get the spreadsheet program to compute the mean average resistance:

For completeness we can calculate the mean average by performing an average calculation:

The value is 1016.58 Ohms - I wish LibreOffice Calc gave me a way of easily displaying the value on the graph...I used the AVERAGE function to calculate it.

Returning to the first graph we can also use the spreadsheet program (Libre Office Calc) although Excel also has this functionality; to calculate the power consumed.

This is achieved by adding a polynomial trendline to the graph in question and then from the trendline performing integration to calculate the area under the curve which is equal to the power consumed in Watts.  Helpfully the trendline function displays the integral for us!  It has been a long time since I had to use integration and possibly the only time I have actually ever had a practical reason to apply it.  My university education wasn't a waste!

 

The function has been found to be: 

If we integrate this we have:

If we apply limits we have:

 If we then calculate out the integral applying the limits we get:

Which gives a value of 40.46...

We need to account for the fact that the current was in milli-amps:

Power (Watts) = Amps * Volts

so we need to divide our solution by 1000 giving:

Power (Watts) = 0.04

A simple check using the tabulated data finds this to be correct:

Now I'm aware in this example we could have used the (base * height) / 2 method to achieve the same result...however when we have a graph that isn't linear (straight line) as the example then the integration method is the best solution.

There is also the trapezoidal method which could be performed on the data itself but that is for another post.

I may yet write a python script which reads in the CSV data, performs the above plots and then performs the integration for me...It may be a useful exercise but that is also for another post!

That's all for now...take care - Langster! 

NeoPixel Circle PCB

The next step in the DMX patio lamp is to create a PCB with the neopixels on it.

The previous posts for reference are:

https://langster1980.blogspot.com/2022/07/designing-dmx-controlled-patio-light.html

https://langster1980.blogspot.com/2022/07/dmx-to-neopixel-arduino-shield.html

I am going for 32 LEDS but I may change my mind. It depends really on the size and spacing achievable as well as current draw and voltage drop.  Lets see what works first.

I'm confident I could design this PCB straight away but it is always a good idea to read through the datasheet and do some calculations...there may be something critical I have missed or didn't know.  I've used neopixel tape several times but I've never really bothered to read up on their technical aspects.

Here is the datasheet: https://cdn-shop.adafruit.com/datasheets/WS2812B.pdf 

The datasheet isn't the worst I've looked at but it isn't the best either...

After some reading...and some more reading here is what I have found:

The package contains 3x LEDS and a control circuit.  According to the research the control circuit draws
8 mA with all the LEDS not active (Off). 

The Red LED draws 13 mA when fully on. 

The blue LED and green LEDS also draws 13 mA when fully on.

Therefore each pixel (3x LEDS in one package) draws 60 mA.  

If we have 32 pixels our current draw with each LED fully on (White colour) will be:

So if the calculations are correct...then we need to account for this 1.6 Amp current draw on our PCB layout. Our connector and wiring also need to handle 1.6 Amps - I'm going to design for 2 Amps to provide a little margin.

Here is the circuit diagram:

NeoPixel Lamp Schematic

Next we need to design a PCB layout.  I'm going for a circular PCB which will fit behind the 84 mm polycarbonate cover.  Lets set the diameter of the PCB to 80 mm - that way I know it will fit with room to spare. I will need a mounting option too...not worked that out yet!  I suspect some stand offs and attached to the cover will work fine.

Here is the PCB layout:

NeoPixel Lamp Top Layer - PCB Render

NeoPixel Lamp Bottom Layer - PCB Render

I added an extra pixel in the centre of the PCB as there was room.  I also added some mounting holes which weren't on the schematic.  The layout went quite well and only took me a couple of hours...must be getting better at this although it isn't because of practice!  I did have a nights sleep between the hours...maybe that helped...

I have exported the gerber files...next job is to get a quote from JLPCB and then assuming the price is right get some boards made.  I'm going to go with black silkscreen.  

I think that's all for now - take care, Langster!

DMX to Neopixel Arduino Shield

In a previous post (nearly a year ago!) I mentioned I was going to design an Arduino shield to allow DMX control to Neopixels.  I actually did design a board but never wrote a blog post about it.  Here is where I rectify that.

The previous post - in case one is interested!

I decided to design my own DMX shield for the Arduino R3 as although there are commercial off the shelf versions available they don't have electrical isolation between the RS485 transceiver and the IO (Input Output) ports. This can be quite critical when connecting up DMX lamps as some of them are not well designed and lets just say ground loops and cheap DMX lamps becoming live when they shouldn't and releasing of magic smoke and electric shocks being a very real and present danger...don't ask me how I know... 

The circuit itself is pretty much the same as those already available.  It has opto-coupling present on the IO, the power supply and has DIP switches on board to set the DMX start address.

Here is the circuit diagram:

DMX to SPI Converter Shield

I suppose I had better explain the circuit - This is as much for me as for the casual reader...I'll be honest I haven't looked at this for a year and some decisions taken were odd to me at first...  

12 V dc input to 5 Vdc out circuit (Switch-mode)

The circuit section shows the 12 V dc input coming from the connector J1 going to C1 (100 nF) - this is a filter capacitor.  Then a DC to DC converter module is present.  Three 100 nF capacitors are then present to filter the output of the DC to DC converter.  These switching converters are known to often cause electromagnetic interference.  The capacitors are present to try to mitigate those issues.

The switching converter (PS1) used is a TRACO TEA_1-505 and it's datasheet is here: 

https://uk.farnell.com/traco-power/tea-1-0505/dc-dc-converter-5v-0-2a/dp/3465028

The next section is the opto-coupled RS485 (DMX)section:

The serial and control signals from the Arduino R3 are connected to Jumpers (JP1 to JP4).  This allows the user to isolate the connections from the serial pins of the Arduino R3 to allow for code upload and control of whether the DMX device will be active (in control of the DMX network and sending data packets) or passive (receiving Data packets).

I'm going to discuss each opto-coupler in turn to simplify things:

Resistor R1 (4.7 kΩ) is connected to output of Opto-coupler U1 and is present to current limit the signal presented to the serial input RX of the Arduino R3 (or clone).  Resistor R6 (470 Ω) is present to current limit the signal presented to the input of U1 coming from the RO output of the RS485 transceiver (U4 - MAX 481E).  

Optocoupler Datasheet

Resistor R2 (470Ω) is connected to the input of Opto-coupler U2 and is present to current limit the signal presented to the internal diode of the device.  The output is current limited by resistor R4
(4.7 kΩ) and is connected to the DE and RE (inverted) inputs of the RS485 transceiver (U4 - MAX 481E). 

Resistor R3 (470Ω) is connected to the input of Opto-coupler U2 and is present to current limit the signal presented to the internal diode of the device.  The output is current limited by resistor R5
(4.7 kΩ) and is connected to the DE and RE (inverted) inputs of the RS485 transceiver (U4 - MAX 481E). 

The Opto-Couplers are powered by 5 V dc coming from the regulated Arduino R3 supply and are isolated from the 5 V dc signal coming from the DC to DC converter 

The IO (A and B) signals of the R485 transceiver (U4 - MAX 481E) are connected to three resistors (R7 - 562 Ω, R8 - 133 Ω, and R9 - 562 Ω).  These are present to provide the 120 Ω impedance matching for the RS485 transceiver.  The input and output to the RS485 transceiver are connected to screw terminals with an isolated return (GND2).  These will connect to the signal cable used to connect this circuit to the DMX controller. 

Max 481 datasheet

The next section is present to allow the user to pre-set the DMX address:

The 8 way DIP switches (SW1) are connected to the Arduino R3 spare pins and 330 pull up resistors.  It is a standard way of connecting switches to microcontroller input pins.  The current presented to the microcontroller inputs when the switch is closed is 15 mA which is within the specification of the device (ATMEL 328).

8 Way DIP switch datasheet

The SPI output of the circuit is taken from Pin 12 of the Arduino R3 along with supply voltage and ground to a three terminal screw connector.  This is a nice robust way of connecting to off the shelf Neopixel circuits. 

The final section is the standard layout used for connecting a shield circuit board to an Arduino R3.

It saves time designing PCB layouts as all of the dimensions and connections are present and contain NET labels.

Here is the bill of materials in case it is needed:

I haven't ordered any of these parts yet but I already know that some are not in stock...the fallout from the pandemic is very real.  Some are due in next week so I can get ordering!

Here is the PCB layout: 

The 3D render is probably easier to see and understand:

The DMX to SPI Converter shield - Top Layer 

The DMX to SPI Converter shield - Bottom Layer

There isn't much to say about the PCB layout.  I've tried to make sure that all of the traces carrying high current are nice and thick. The silk screen labels are visible and it is fairly easy to populate by hand if required.  I wish I had labelled in the inputs and outputs so I know where the GND and +12 V input connections are and where the DMX and NeoPixel connections are.  There are always things I would do differently if given a chance to repeat.

I got ten boards made by PCBWay for a reasonable price and they were delivered in very short order!

Here is a picture of the unpopulated board:

My plan is to populate and test this board as soon as possible as I intend to use it in my next project - the DMX controlled patio lamp :)

That is all for now - take care always - Langster!