Select Project
This is a full-stack web application that tracks grocery prices from various stores in South Africa and allows you to compare them. It is under active development and far from complete. No mobile support yet. View the app here!
In this project, a broken XBOX 360 controller is converted into a fully functioning Drone Radio Transmitter. Basic I/O of the devic is handled using an Arduino Nano while an NRF24L01 module is used for the radio transmission.
A broken console controller is still very useful as long as the joysticks are working. This project discards most of the internals of the XBOX controller, but utilizes the body and the existing joysticks in an excellent display of repurposing. The components required to do this conversion are:
For the purposes of testing the completed transmitter, a receiving device is built using the following components:
The completed transmitter and receiver are shown below (Transmitter cover removed and antenna cropped
out):
As these console controllers are built for a specialized use-case, there are plenty of components that
cannot be reused and the first step of the project is to seperate the useful from everything else. As
shown in the image below, the joysticks are initially soldered onto a pcb that neatly houses all the
components of the device and the first step is to de-solder these joysticks.
To be able to reuse the housing of the controller, a piece of proto-board needs to be cut out to match the
shape of the existing pcb, allowing the assembly to fit snugly. Next, it is important to ensure that both
joysticks line up exactly as they did initially when they are soldered onto the proto-board.
Without getting into too much detail regarding the rest of the build, it follows these steps:
Testing is first done indoors to verify the expected behaviour. Thereafter, the same procedure is carried out in a field at increasing transmission range. Testing is done as follows:
By repeating step 4 of the testing procedure above, it is found that the transmitter performes extremely well and at a range of 600 meters, there was no more space on that field to move further away from the receiver.
Although a maximum range was not found, it is confirmed to be at least 600 meters which exceeds the
requirements for this simple hobby project. This controller is also adapted to work with drone simulation
games. One simply connects the Arduino in the transmitter to a PC via USB.
It is planned to find a new location to test the device in the future and find its actual maximum range.
Importantly, I am also planning to build en entire drone from scratch, implementing a PID control system
and expanding on the receiver that is already built.
Depreciation Station (not actively maintained) is a full-stack web application that aims to learn what colour of car is most likely to hold its value for the longest time in South Africa.
The goal of
Depreciation Station
is to compare the rate at which different coloured cars depreciate and for this, data is obtained from
Autotrader using Python and web scraping. The scraping is automated to run daily on a Raspberry Pi
while the web page is hosted on PythonAnywhere. Data is communicated between these two nodes using a
Flask API. The scraper has since become outdated and I currently have no plans to update it, so the data
has become stale. You can view the app here.
YikesBikes is a web shop that sells mountainbikes
YikesBikes is a fully functioning web shop that I created from the ground up for a course I took in 2021, at Reutlingen University, in Germany. The purpose of the video that I have linked to, is to show my proficiency in HTML, CSS, JavaScript, PHP, MYSQL and Python without going into too much detail. The web shop is not currently hosted on the web for you to explore, but in the video, I explain how it works:
I decided to build a website to serve as my Mechatronic Engineering portfolio. This is how it happened.
2020 gave us the Covid-19 lockdown in South Africa and I was lucky enough to gain some free time while the
University made the switch to remote learning. At the time, I had very little experience in software and
decided to start by learning web development. This website is the result of my efforts in that time and is
what sparked my interest in programming.
YouTube and
Skill Share
taught me all I needed to know back then and are great tools for beginners. Here, I also learned about
Git, Github and hosting. HTML, CSS and JavaScript were all that I needed to build this static site and the
understanding I gained using those languages proved to be very helpful when I learned PHP and Python's
Flask at a later stage.
In this modelling experiment, the goal was to determine the sping constant and dampening coefficient for the suspension of a given passenger vehicle through visual analysis.
The vehicle was set up by parking one wheel elevated on three garden tiles. The data was captured by
reversing off the tiles while recording from a camera on a tripod to the side and the video footage was
analyzed in a program called Tracker. This software can track and plot fixed points from frame to frame,
which is why there were two stickers on the side of the car at the start of the experiment. One on the
body of the car and one in the center of the wheel.
With the data from tracker, MatLab was used to subtract the height plots of the two dots from each other
and form a new plot. At this point, the data was in a workable state and modelling formulas and
calculations were used to determine the required parameters.
This is my first PWA (progressive web application) that I have built. Users can create an account, sign in and start uploading recipes. Recipes can be made public or private. Public recipes can be viewed in the community section.
This is my first functional PWA (Progressive Web Application). PWA's are web applications with additional
advanced functionality that allow them to behave similarly to native apps. This includes the ability to
cache data to improve the user experience. Loading times are decreased and this also allows a PWA to be
used while offline. This is in strong contrast with standard web applications. Additionally, PWA's allow
for the use of push notifications and they are able to access mobile device features such as the
camera.
Building native applications traditionally requires of one to know programming languages other than HTML,
CSS and JS (which are used for building websites). However, PWA's can be built using these three popular
languages, which removes the need to learn a new language like Java or Kotlin altogether.
Building
Some Kickass Recipes
and all its functionality taught me the skills required to expand existing web applications into PWA's and
to understand the gains that can be made accordingly.
In this project, I used Blynk to log data being read from three different motion sensors and to export this data to Excel for analysis.
Blynk is a "hardware agnostic IoT platform" useful with
device management, data analytics, machine learning and more. Finding blynk has been one of my best
discoveries considering how much it has helped me and I am amazed by how easy it makes it to perform IoT
tasks. Blynk supports over 400 hardware modules including all Arduino boars and more. As an exercise to
play around with different features, I decided I would conduct an experiment to determine which of three
motion sensors that were available to me was the best at different ranges.
The three sensors I had were the SR602 mini PIR sensor, the HC-SR501 PIR sensor and the RCWL-0516
Microwave Radar Sensor. I used the Arduino Nano 33 Iot to connect to Blynk's servers and to read data from
these sensors. The experiment was set up as follows:
I used an old camera tripod to mount the sensors onto, because they needed to be held securely and all at
the same height for it to be a fair experiment. I also fixed a breadboard and the Arduino to the tripod,
because there was no need to find a more permanent solution.
Blynk provides some good documentation for most of its services, which made it very easy to write code for
the Arduino to connect to the mobile Blynk app which is where the data would be displayed. As opposed to
normal GPIO Pins, Blynk makes use of a concept called Virtual Pins (VPs) which work similarly to harware
pins, but are obviously virtual. This meanse that there is almost no limit to the number of virtual pins
one can use. These pins are a way for the Arduino to interface with the Blynk cloud. I used Blynk's free
app with its VPs to build a project layout that listened for input to these VPs from the Arduino. This app
gives the user control over exactly what kind of controls or interfaces he/she want to see in the project
layout and I set it up as follows:
In the upper section of the layout, there are three LEDs that light up whenever its respective sensor
senses movement. This all happens in real-time, which feels a bit like magic.
Just below that, I decided to use Blynk's SuperChart widget to display the amount of motion every sensor
senses over time. This data is what I was interested in and after completing testing, this data can be
exported to CSV format, perfect for analyzing in Excel.
The lower half of the screen contains a table which is also updated live and shows the number of times
every sensor was triggered and what each sensor's delay time was when it was last triggered.
Having set up the experiment, I started testing by repeating a series of movements infront of these
sensors from various distances. After each iteration, I exported the data and repeated the process at the
new distance. I knew all three sensors worked almost identically well at the datum, 0.5m away. In this
way, I could use the data to compare how each sensor performs against its own datum at different
distances.
I used Excel to convert the data into a workable format and plotted the results in the graph below:
Clearly, the HC-SR501 PIR sensor works best at a longer range, unlike the other two. The results of this
experiment may not be extemely useful to me (until I find an appropriate use case), but the goal was to
test the capabilities of Blynk and I am very happy with it. Everything that I used it for could be done
locally within the arduino script, but the power of Blynk really shows when you want to add wireless
control to IoT projects.
In this project, I controlled a stepper motor and driver using an ESP32 with the Arduino IDE. The ESP32 received input from its relevant topics on AWS Iot. Depending on these inputs, the microcontroller (ESP32) would either turn the motor to the desired location or publish back to the topics on AWS Iot.
The goal of this project was to communicate to the ESP32 board from AWS IoT core. A typical
message that would be sent to the board would include an angle that the ESP would have to extract before
instructing the stepper motor to move to that exact angle. The motor driver used in this project is the
A4988 stepper motor driver. It includes 3 pins that are used to select the motor step size, which allows
for a lot of control over the motor's accuracy and speed.
As with most of my electronics projects, there is a hardware and software side to the problem.
In this case, the hardware problem was figuring out the correct wiring from the ESP to the stepper driver
while ensuring the motor voltage and current would stay inside a safe boundary. This was my first time
working with a stepper motor and I thoroughly enjoyed learning how to control it.
The software side of the problem included writing the arduino code that would be flashed to the ESP.
It had to facilitate the communication with AWS IoT core while controlling the motor's angle and
speed, but fortunately, connecting to AWS proved to be a simpler task than I had thought, owing to
this
helpful guide AWS has published specifically for the ESP32 board. Another thing to consider when programming
the Arduino is the math involved with calculating how many pulses to send to the driver and at what
frequency, depending on the step-size that was chosen. A higher frequency will casue the motor to turn
faster and more pulses cause it to turn further.
In conclusion, considering that I started this project with little knowledge about AWS IoT Core or
controlling stepper motors, I have thoroughly enjoyed the learning curve and it has increased my interest
in power electronics as a whole.
This DIY weather hub is powered by an Arduino Nano 33 IoT, which displays weather information from the OpenWeatherMap API to a 20x4 LCD screen. The arduino fetches the temperature, wind and precipitation at a chosen time interval, for a pre-determined location.
The goal of this project was for me to learn how API calls are made from an Arduino, to learn how LCD
screens are used with Arduinos and to practice my soldering.
Writing code to display to the LCD screen was really very easy once it was wired correctly. This is made
possible by the library, LiquidCrystal.h, which includes intuitive functions like lcd.clear() and
lcd.setCursor(). Below is a diagram for wiring the LCD screen correctly:
The potentiometer is useful for adjusting the screen's contrast.
Some additional features that I have added to this simple diagram are a PIR motion sensor and a BC547
Transistor. These are used to switch the backlight of the LCD on when the sensor is triggered and off
again 10 seconds later and the transistor is connected to the anode and cathode pins on the very right of
the LCD's diagram above (Transistor not in diagram).
The most tricky part of this project was figuring out how to make an API call and deserialize the received
Json data. This was made particularly difficult by the fact that the code is different depending on the
board you are using. The board I used, the Nano 33 IoT, is still a relatively new product which is why it
lacks the kind of online support that can be found for older wireless boards like the ESP8266. However,
the effort I had to put in to write working code has taught me much more than I would have learned
otherwise.