Designing the Schematic
The first step in the process was to design the schematic. I had to decide what components I wanted to use, how they would be connected and how they would interact with each other. I started by sketching out the layout of the controller on paper. This gave me an idea of the size and shape of the controller and how many components I would need. I then used a program called Eagle to create the schematic. This allowed me to quickly and easily draw out the connections between the components and check for any errors.
Creating the Key CAD
Once the schematic was finished, I had to create the key CAD. This is the physical layout of the controller, including the buttons, joysticks and other components. I used a program called Fusion 360 to create the key CAD. This allowed me to quickly and easily create the layout of the controller and make sure all the components fit. I also used this program to create 3D models of the controller, so I could get an idea of how it would look before I started building it.
Testing the PCB
Once the key CAD was finished, I had to test the PCB. I used a program called KiCad to create the PCB. This allowed me to quickly and easily create the PCB layout and check for any errors. Once the PCB was finished, I sent it to a sponsor of this video, PCBWay, to have it manufactured. Once I received the PCB, I tested it to make sure it worked as expected.
Building the Controller
The final step in the process was to build the controller. I used a soldering iron to solder all the components onto the PCB. This was a time consuming process, but it was worth it in the end. Once all the components were soldered, I tested the controller to make sure it worked as expected.
This was a bit more complicated, but I was able to get it done.
Creating a Custom Remote Control
In an effort to create a custom remote control, I decided to use Easy Eda, an online PCB Creator, to build it from scratch. Although this process was error-prone and tedious, I was determined to make it work. After some research, I realized that the best way to go about this was to create a schematic first, which would dictate how all the pins were connected.
Using Key CAD for Schematic Creation
I opted to use Key CAD, an open source software, to create the schematic. To get a better understanding of the program, I followed a tutorial series which provided me with the necessary information to get started. My first iteration of the remote control was similar to the original, with two joysticks, two potentiometers, and an NRF chip. However, I also wanted to include a gyroscope and a screen, which would use up every pin except one on the Arduino Nano.
Wiring Up the Symbols
The first part of the stream was spent wiring up the symbols. This was relatively easy but time-consuming, as I had to ensure that everything was connected correctly. Once this was done, I moved on to creating the footprints which would be used on the PCB. This was a bit more complicated, but I was eventually able to finish it.
Testing the Remote Control
The final step was to test the remote control. I was pleased to find that it worked as expected, and I was able to use it with no issues. Although the process of creating the remote control was difficult, it was ultimately worth it. I now have a custom remote control that I can use for my projects.
The Learning Curve
The process of creating a remote control from scratch was not without its challenges. Initially, there was a steep learning curve as I had to familiarize myself with the workflow. After some time, I was able to create the schematic and all the footprints.
Adding Pins
In order to add more pins, I came across a shift register. This device would enable me to access five additional pins. I used these to add a rotary encoder, a back button and two bumpers. The rotary encoder and back button would be used to navigate the user interface, providing an alternative to touch.
Layout of Components
The next step was to figure out the layout of the inputs and screen on the controller. I decided to place the screen in the middle, with the joysticks on either side, the potentiometer on top and the back button and rotary encoder below the screen.
Wiring the Traces
The next stage was to wire the traces. This process took nine hours, although it would likely take only an hour if I were to do it again. After completing the wiring, I tested the components on a breadboard. Thankfully, I had not ordered the PCB yet, as this would have been a waste of time and money.
Testing the Components
The goal of this stream was to wire up the components in real life and make sure everything was working before ordering the PCB. This proved to be a wise decision, as the PCB was done perfectly.
Preparation
The task of creating a new remote control was daunting, but I was determined to make it happen. I began by obtaining the necessary components, including a PCB, a Nano, and an NRF chip. I also ordered a few extras of each component, just in case.
Testing
The first step was to wire up the Nano and the NRF chip. After plugging in the Nano and uploading some test code, I encountered an issue – the programmer was not responding. I tried everything I could think of, but nothing worked. After swapping out the Nano, I was finally successful.
Antenna Version
The next step was to test the NRF chip. This one was the antenna version, and I had never been able to get it working before. I attempted to power it with a 3.3 volt voltage regulator, but it did not work. I was about to give up and use the non-antenna version when a suggestion from chat gave me an idea – solder the capacitor directly to the NRF. After doing so, the chip worked! This was the first time I had ever gotten the antenna version working.
Rotary Encoder
The next three hours were spent trying to get the rotary encoder to work more consistently. Unfortunately, this was a massive waste of time. After much trial and error, I was able to get the encoder working.
3 volts. After a few hours of soldering, I had the logic level shifter working, and the screen was working.
Project Overview
The goal of this project was to create a new remote control from scratch. To achieve this, the project required a rotary encoder, a gyroscope, four toggles, four bumpers, four buttons, two potentiometers, an NRF module, and a power switch. Additionally, a 3.5 inch 480×320 touchscreen was needed to provide a visual interface.
Challenges
The first challenge was to free up the interrupt pins for the rotary encoder. To do this, the team suggested using a PCF 8575 component, an IO extender that uses I2C. This allowed the two I2C pins to be converted into 16 digital pins, thus freeing up the interrupt pins.
The second challenge was the 3.5 inch touchscreen. The touchscreen used 3.3 volt logic, but the nano pins were 5 volts. To solve this, a logic level shifter was used to turn the 5 volts into 3.3 volts.
Testing
Testing began by getting the IO extender working. This was followed by testing the gyroscope, rotary encoder, buttons, potentiometers, NRF module, and power switch. After these components were tested, the logic level shifter was soldered and the screen was tested.
I could not get the controller to receive the data from the hexapod. I tried multiple different libraries, but nothing worked. I was about to give up when I realized that I had not tried using the NRF24L01 library.
The Challenges of Making a Remote Control
Creating a remote control from scratch is no easy feat. It requires a great deal of technical knowledge and skill to be able to successfully build one. The first challenge I faced was getting the screen to work. I had purchased a 3.5 inch LCD screen with a capacitive touchscreen, but no matter what I tried, I could not get it to work. After much trial and error, I eventually managed to get it to work by swapping out the level shifter with voltage dividers.
The NRF Chip
The next challenge I faced was getting the NRF chip to work with the screen. I had been working on this for the past four hours, but I could not get them both working. After much research, I concluded that the issue was likely due to interference between the SPI pins of the NRF chip and the screen.
Switching Screens
I decided that the screen was too much for the Nano to handle, so I ordered a different one. I bought a 2.4 inch 128×64 black and white OLED screen. This new screen had 21 times less pixels than the old one, and it also did not have color. This meant that it was much quicker to update. After about an hour, I was able to get the screen and NRF chip working.
Sending Data
My next goal was to have the hexapod send back the value of its current sensor to the controller and then have the controller display that current sensor value on the screen. Unfortunately, I could not get the controller to receive the data from the hexapod. I tried multiple different libraries, but nothing worked. I eventually managed to get it working by using the NRF24L01 library.
I was able to get the hexapod to move with the controller.
Identifying the Problem
The issue at hand was identified as a chip incompatibility. The hexapod PCB had been ordered with a non-plus version of the NRF chip, preventing successful two-way communication. After 8 hours of troubleshooting, it was determined that the chip was the culprit.
Swapping Out the Chip
The solution was to swap out the hexapod’s NRF chip with an NRF plus version. This enabled the successful two-way communication necessary for the controller and hexapod to communicate. With the correct chip in place, the transmitter was able to send data and the receiver was able to send an acknowledgement message back to the transmitter.
Integrating the Test Code
The next step was to integrate the test code into the actual hexapod and RC code. This process took 3 hours, but was ultimately successful. The hexapod was able to move with the controller, indicating that the two-way communication was working.
Designing the Remote Control
The process of designing the remote control began with the selection of the Arduino Mega Pro. This enabled the replacement of the hexapod’s Arduino Mega and the remote control’s Arduino Nano, thereby eliminating the need for an IO extender. With the additional analog pins available, the possibilities for the remote control were expanded. To facilitate the coding of the user interface in Arduino, a reference document of the functions of the display library was created.
Creating a Mockup
The next step was to create a mockup of the user interface. This was done using GDAU 4, an open source game engine. This allowed for easier iteration and experimentation with the design, as well as easy copying of the design once the mockup was complete.
Testing the Design
The mockup was then tested to ensure that it met the desired specifications. This included testing the responsiveness of the buttons, the accuracy of the display, and the overall usability of the design. Once the design had been tested and approved, it was ready to be implemented in Arduino and C.
Implementing the Design
The design was then implemented in Arduino and C, using the reference document of the functions of the display library. This allowed for the creation of the user interface, as well as the integration of the various components of the remote control. Once the design was complete, it was tested to ensure that it met the desired specifications.
Getting Started
With the goal of creating a new remote control in mind, I began by gathering the necessary components. I sourced a Mega Pro microcontroller, a few potentiometers, and some other miscellaneous components. I then set out to design the schematic and PCB layout for the remote control. After a few hours of tinkering, I had the schematic and PCB ready to be sent off for fabrication.
Building the UI
Once the components arrived, I began the process of building the user interface. I opted to use GDU, a graphical user interface development tool, to create the UI. I was able to quickly create a functional mockup of the main page, which included a representation of the current state of the hexapod. I also added a battery indicator for the controller, as well as some additional data about the hexapod, such as its battery voltage, current usage, max speed, and height off the ground.
Testing and Debugging
After the UI was complete, I began the process of testing and debugging the remote control. I tested the potentiometers to ensure they were working properly, and I also tested the battery indicator to make sure it was displaying the correct information. After a few hours of testing, I was able to get the remote control working as intended.
This page will show you the current battery voltage, the current temperature, and the current time.
Creating a New Remote Control
Crafting a new remote control from scratch is a daunting task, but one that can be accomplished with the right tools and knowledge. Knowing the current value of the components was essential in order to create a successful mockup user interface. After centering the hexapod and adding an icon to represent whether or not it was connected to the controller, the controls page was created to display the function of any button pressed on the controller.
Designing the Main Page
The main page was designed with a gate display to show the currently selected gate and allow for easy cycling through the gates. Additionally, a scrolling list with four pages was added: gate, settings, offsets, and stats. The gate page allows for selection of a hexapod walking gate, with an animation of the gate displayed on the right. The settings page is where the settings are adjusted, while the offsets page allows for tuning of the servos. Finally, the stats page displays the current battery voltage, temperature, and time.
Testing the Mockup
Testing the mockup was a crucial step in the process. The icons needed to be tested to ensure they translated properly onto the 128×64 pixel display. The controller was tested to ensure all buttons were functioning correctly and the menu was tested to ensure it was easy to navigate. After all tests were completed, the mockup was deemed successful and ready for use.
Finalizing the Remote Control
The final step was to assemble the remote control. All components were soldered together and the mockup user interface was programmed into the controller. After all components were connected, the remote control was tested one last time to ensure it was functioning properly. After a successful test, the remote control was ready for use.
Designing the Remote Control
The goal was to create a new remote control from scratch, and the first step was to design the user interface. After some brainstorming, I decided to include some interesting stats and a stat reset button. I then created a mockup of the UI and shared it with a few people for feedback. After a few days, I was ready to order the printed circuit board (PCB).
Ordering the PCB
I exported the Gerber files and ordered the PCB from PCBAa. This company offers a variety of services, including PCB fabrication. Every PCB I have received from them has been flawless, and this one was no exception. I ordered five of them, which cost 35 plus 15 shipping for a total of 50. However, if the PCB’s width is less than 100 mm and its height is less than 100 mm, one can get 10 of them for 5 plus shipping. A huge thanks to PCBAa for sponsoring this video.
Testing and Assembling
I planned on including all the testing and assembling I did with the new PCB, but this video was already too long. So, I had to wait till part two. However, I am happy to say that it worked. I did make some modifications and I may already have an updated version that should be even better, but this will all be covered in the next video.
Designing the Case
Creating a custom case for the remote control requires a few basic materials. The main materials needed are a 3D printer, some plastic filament, and a few tools. The 3D printer is used to create the basic shape of the case, while the plastic filament is used to give it a more finished look. The tools needed are a drill, a saw, and some glue.
The first step in designing the case is to create a 3D model of the remote control. This can be done using a 3D modeling software such as Blender or SketchUp. Once the model is complete, it can then be printed out on the 3D printer. Once the case is printed, it can then be sanded and painted to give it a more finished look.
Coding the UI in Arduino
The next step in creating a custom remote control is to code the user interface (UI) in Arduino. Arduino is an open-source electronics platform that allows users to easily create interactive electronic projects. To code the UI, the user will need to download the Arduino IDE and install the necessary libraries.
Once the libraries are installed, the user can then begin coding the UI. This involves writing code to control the various buttons and features of the remote control. The code can be written in either C or C++, depending on the user’s preference. Once the code is written, it can then be uploaded to the Arduino board.
Creating an Assembly Tutorial
Once the case and code are complete, the user can then begin creating an assembly tutorial. This tutorial should include step-by-step instructions on how to assemble the remote control. The tutorial should also include diagrams and pictures to help the user understand the assembly process.
Creating a Kit
The final step in creating a custom remote control is to create a kit. This kit should include all the necessary components to assemble the remote control. This includes the 3D printed case, the Arduino board, the plastic filament, the tools, and the code. The kit should also include instructions on how to assemble the remote control.
Creating a custom remote control from scratch is a great way to learn about electronics and programming. By following the steps outlined above, anyone can create their own unique remote control. With a little bit of patience and creativity, anyone can create a custom remote control that is sure to impress.
Creating a custom remote control from scratch was a challenging but rewarding experience. I learned a lot about electronics and PCB design, and I now have a controller that is better than any off the shelf controller. If you are looking for a unique and custom controller, I highly recommend giving it a try.
After many hours of hard work, I was able to create a new remote control from scratch. The process was difficult, but the reward was worth it. I now have a remote control that is tailored to my exact needs.
After 6 hours of testing, the remote control was successfully created from scratch. The project was successful in achieving its goal of creating a new remote control. The project also provided valuable insight into the challenges of creating a remote control from scratch.
Creating a remote control from scratch is no easy task. It requires a great deal of technical knowledge and skill to be able to successfully build one. After much trial and error, I was eventually able to get the screen and NRF chip working, and then I was able to get the controller to receive the data from the hexapod. Despite the many challenges I faced, I am proud of the end result.
The issue of two-way communication between the controller and hexapod was resolved by swapping out the hexapod’s NRF chip with an NRF plus version. After integrating the test code into the actual hexapod and RC code, the hexapod was able to move with the controller, confirming successful two-way communication.
The process of creating a new remote control from scratch was a challenging but rewarding experience. The use of the Arduino Mega Pro, GDAU 4, and the reference document of the functions of the display library enabled the creation of a user interface that met the desired specifications. The result was a remote control that was both functional and aesthetically pleasing.
The process of creating a remote control from scratch was a challenging yet rewarding experience. I was able to learn a lot about the design process, and I was also able to create a functional remote control that I can use for my hexapod.
