Author: directorcia
Arduino Uno R4 Wifi Matrix display
The next controller I’m going to play with is the Arduino Uno R4 Wifi. I really like the ease and compatibility of the Arduinos I have used so far but the lack of WiFi I know will be a major limitation. So it make sense to explore a Wifi Uno.
One of the additional ‘nice’ features of the Arduino Uno R4 Wifi is that it has a LED matrix included on the board. Thus, the starting point is to try and get something to display on there.
First I tried displaying a simple emjoi. The code for this is here:
and there are range of emojis to display.
I then uploaded the demo code here:
to display Hello World on the matrix, which all worked as expected as shown on the image above.
The next step after getting something to display on the matrix will be to get the Wifi working.
Garage distance sensor V2
My initial prototype started back here:
and is now at the point where I am designing version 2.
The biggest change for version 2 will be the replacement of the 5 individual LEDs and the board they live on with a Keyestudio 40 RGB LED WS2812 Pixel Matrix Shield for Arduino:
The main reasons for this are:
– less soldering is required
– the LEDs are brighter
– there will be a 5 x 8 matrix of LEDS allowing more options
– the shield plugs directly into the controller board
So the circuit diagram will now look like:
The code will, at least initially remain functionally the same but may get enhanced once I have it working.
I have ordered an additional distance sensor and QWIIC LED 4 Digit display but the LED shield is ready to go as you can see in this video:
Video link = https://www.youtube.com/watch?v=49V33TKXt3c
The test code shown in video is here:
I think this LED shield will be a big improvement for the project, so stay tuned for more updates soon.
Robot Arm with Multi Motor Movement
I’ve improved the movement of my robot arm by implementing multi motor movement. This means moving large distances will be more efficient since the arm can take a more direct route. You can see this in the video I created above. You’ll find my code for this routine here:
https://github.com/directorcia/Azure/blob/master/Iot/Arduino%20Uno%20R3/Robot%20Arm/routine2.cpp
This has lead me to go down the rabbit hole of kinematics.
Kinematics is the science of motion without considering forces. For robot arms, it answers questions like:
-
Where should each joint move to place the end-effector at a specific position?
-
What angle should each servo rotate to reach a target point?
There are two primary types:
-
Forward Kinematics – You provide joint angles, and it calculates the end-effector’s position.
-
Inverse Kinematics (IK) – You provide a desired end-effector position, and it calculates the joint angles needed to get there.
I’m going to try and implement kinematics for my arm going forward, so stay tuned for updates.
Keyestudio Sensor Shield/Expansion Board V5 for Arduino
One of the issues I found when powering the servos for the robot arm was that I found I couldn’t power them from the Arduino board, I needed an external power supply. This fact made wiring the servos up challenging as the control signal still had to come from the Arduino but the power elsewhere. Thus, lots of messy wires.
All that has been solved with the addition of a Keyestudio Sensor Shield/Expansion board as seen above.
Basically, the shield simply plugs into the pins in the Arduino controller (extending them) while providing:
– An alternate power supply
– Easy connections for all the servos
A nice compact solution to a few challenges with the robot arm. All I needed to do was connect up the shield onto the Arduino and then connect the servo motors directly to their ports and change nothing else. No code or other wiring was done except to also connect an external power supply to the shield board as seen in the lower right above.
I have to say, that if you need to control devices that require more power than the standard Arduino board can provide then this type of shield is exactly what you want!
Thumbs up to Keyestudio for both the controller:
KEYESTUDIO UNO R3 Development Board For Arduino Official Upgrated Version With Pin Header Interface
and the shield
Keyestudio Sensor Shield/Expansion Board V5 for Arduino
A diagram of the project looks like:
Nanoblock Tokyo Skyline Building Kit
Nanoblock Tokyo Skyline Building Kit, White – https://www.amazon.com.au/Nanoblock-Tokyo-Skyline-Building-White/dp/B07CDQQXWG/
1310 pieces
A kit with a lot of different components and colours. Takes longer to assemble than you think simply because you need to find a lot of unique pieces. However, enjoyed the longer assembly process and overall details of the end result. If you don’t mind so many unique pieces then this is great longer term build of intermediate difficulty.
Garage sensor–Version 1 summary
Video link = https://www.youtube.com/watch?v=MBYtc1O-l94
I’ve rounded off version 1 of the Garage sensor and am about to start work on version 2. There is a short video summary of what he sensor does in the video above.
I’m not happy with the daughter board that runs the 5 LEDs. It is cumbersome, challenging and time consuming to build. I plan to replace this with something pre-built. I’ll also opt for a cheaper Arduino board. The process will also require me to rework the 3D printed board all the components are mounted on.
Stay tuned for Version 2 coming soon!
Robot arm in action–Linear motion
Video link = https://www.youtube.com/watch?v=zdtojnnbCBg
Now that I have my robot arm actually working, I can share the video of its operation above. It basically operates one servo at time to pick up and object and then place that object to the left. It will simply continue to do that over and over.
The code for this is here:
https://github.com/directorcia/Azure/blob/master/Iot/Arduino%20Uno%20R3/Robot%20Arm/routine1.cpp
Which I’ll explain in an upcoming post soon.
After that I want to modify the operation so that it more more naturally and operates multiple servos together to arrive at its destination.
Getting the robot arm to actually work
After taking a good while to get the robot arm assembled, the next challenge was hooking it up and doing some initial testing.
To control the arm I had invested in a
KEYESTUDIO UNO R3 Development Board For Arduino Official Upgrated Version With Pin Header Interface
This is the same board that is used on the Sun follower kit I recently built. I like this board because it has all the connections for each port already mounted on the board. It also has the GND and VCC for each port as well making it easy to plug standard connectors into it. Less soldering, in my case , means less problems or stuff ups by me!
The first issue I discovered was that many of the leads to the servos were too short when the servo moves the arm through its full motion. In one case I threw the controller board off the table. Thus I needed to invest in:
and
to allow full movement of the arm.
The next challenge I found was when I moved on from testing each servo individually to testing the arm as single unit, some of the servos didn’t seem to work! Another oversight by me upon further investigation. The controller board has enough power to run a single servo but not a bank of servos all together from the VCC rails on the controller board.
I therefore connected the VCC of the all the servos directly to my bench top power supply to give it the juice needed. Interestingly, during testing I have seen the arm draw well over 1 amp in total from the power supply as various servos operate. Clearly, no way the controller board could provide that by itself.
With all the servo motors now working, I started to try and get the arm to move to a location and pick up an item. After a while, servo 0 (gripper) stopped working?? I checked all the connections and it still wasn’t working. It wasn’t until I actually touched the servo and found that it was super hot that I realised I must have burnt it out. Damm.
I replaced the burnt out servo with another I had. I also attempted to fix the burnt out servo by opening it up to see if I could free things up inside, but that didn’t go well and I ended up with the internals of the servo motor all over the floor.
I also learnt that when power is removed from the servos, for example when re-flashing the controller board, the servos don’t hold the arm in place. This means that when power is removed from the servos the arm collapses under its own weight. This can cause some unexpected impacts with the environment when power is restored. I’ll need to think about how to solve this down the track but for now I simply support the arm when I flash the controller with updated code.
Finally, with a replacement servo for the gripper and motor extension cables I had the arm operational to a point where I could start getting it to do something interesting.
I’ll cover off the code development in an upcoming article and hopefully also provide some videos of the arm in operation.
Building a 6DOF Programmable Robot Arm: A Step-by-Step Guide for Educators and Enthusiasts
There’s something incredibly satisfying about assembling your own robot arm. As someone who recently built the 6DOF Programmable Robot Arm Kit from IDY Production, I wanted to share my experience and provide a comprehensive guide for fellow educators, students, and robotics enthusiasts.
What’s in the Box
When my Amazon package arrived, I was impressed with how neatly everything was organized. The kit includes:
- 2mm thick aluminium plate components (pre-cut and precision machined)
- 6 high-torque servo motors for each degree of freedom
- All necessary hardware (screws, nuts, spacers)
What was noticeably missing, however, was a comprehensive instruction manual. Despite the kit’s professional appearance, I had to hunt down assembly instructions online—an unexpected challenge that’s worth mentioning for anyone considering this purchase.
The quality of the materials immediately stood out – the 2mm aluminium plates are robust and precisely manufactured, providing a solid foundation for educational applications.
Finding Assembly Instructions
After discovering no instructions were included in the package, I immediately went searching online. Fortunately, I found several helpful resources:
-
PDF Assembly Guide: Downloadable Assembly Instructions PDF – This detailed document provides clear illustrations and step-by-step instructions for assembling the robot arm.
-
YouTube Tutorial: 6 dof robotic arm build tutorial part1 – This comprehensive video walks through the assembly of a similar 6DOF robot arm and was invaluable for understanding the correct positioning of components and servo motors.
I recommend downloading and printing the PDF instructions before beginning assembly, and having the video tutorial available for reference during the more complex assembly steps.
Assembly Process
1. Preparing Your Workspace
Before diving in, I recommend setting up a clean, well-lit workspace with all your tools organized. You’ll need:
- Phillips screwdriver set
- Needle-nose pliers
- Small adjustable wrench
- A container to hold small parts
2. Base Assembly
I started with the base, attaching the first servo motor to the bottom plate. The pre-drilled holes aligned perfectly, though I found it helpful to loosely thread all screws before tightening any of them fully. This allowed for minor adjustments as I completed each section.
3. Building the Arm Segments
Each joint required careful attention to the orientation of the servo motors. The PDF guide provides excellent diagrams showing the exact positioning of each component, while the video tutorial shows the assembly process in action. This combination of resources made even the trickier joint assemblies manageable.
The aluminium plates connect seamlessly, creating a professional-looking result that’s both sturdy and aesthetically pleasing.
4. Wiring the System
Cable management proved to be one of the more challenging aspects. The kit includes cable ties, but I supplemented these with spiral wire wrap to keep everything tidy. Take your time routing the wires to ensure they won’t impede movement once the arm is operational.
The video tutorial shows a good approach to cable management around the 12:40 mark, which I found helpful for keeping wires organized without restricting movement.
Programming Your Robot Arm
Once assembled, the real fun begins. The arm can be programmed using:
- Arduino IDE (for customized control)
- ROS (Robot Operating System) for advanced applications
- Various GitHub repositories with open-source robot arm control code examples
I am planning on creating pick-and-place applications and programming choreographed movements across all six degrees of freedom.
Final Thoughts
The 6DOF Programmable Robot Arm Kit from IDY Production strikes an excellent balance between educational value and build quality. The 2mm aluminium construction ensures longevity even in classroom environments where equipment typically endures heavy use.
While the absence of included instructions was initially frustrating, finding the PDF guide and YouTube tutorial ultimately provided more comprehensive guidance than a basic manual might have offered. The assembly process itself is educational and deeply rewarding, though newcomers should expect to spend time studying both resources before and during assembly.
For college instructors looking to provide students with practical robotics experience, this kit offers tremendous value—just be prepared to supplement the package with the online resources I’ve mentioned.
Have you built a similar robotics kit? I’d love to hear about your experience and any creative applications you’ve developed in the comments below!
This blog post is based on my personal experience with the IDY Production 6DOF Programmable Robot Arm Kit, purchased through Amazon. The opinions expressed are my own, and I received no compensation for this review.
CIAOPS Labs 