In a previous blog article, I showed how you can make 2 and 4 port USB adapters to use with retro Atari Joysitcks. While that was really awesome, I recently made improvements leading to this next generation adapter that I will cover in this article. The top improvements are:
Wireless Bluetooth support
Paddle support in addition to joysticks
Additional buttons you can use without having to open up your joysticks
Here is a video that shows the result if you dont feel like reading.
Wireless Bluetooth Support
Atari and retro joystick wires are typically just 5 feet long. The main idea for wireless bluetooth support was to be able to sit back away from the TV while you played your classic games. So this is now possible with my new Bluetooth retro adapter! My PC will pair to the adapter with Bluetooth and I just plug my joysticks and paddles to the adapter and I am golden!
In my last blog, I showed a preview to this original prototype I made to prove it would work:
I used an ESP32 micro controller because it has built-in Bluetooth capabilities. By using a chargeable lipo battery (you can see it on the bottom), the right code, and the right wiring, the unit can be paired to your computer or phone via Bluetooth.
Joystick and Paddle Support
With the 2 game controller ports, you can connect 2 joysticks or even 2 paddles and a joystick at same time!
Getting paddles turned out to not be very simple because Atari paddles use mega ohm potentiometers and getting them to be jitter free needed a really decent analog to digital converter or use or an RC circuit for better precision. It was kind of fun playing old paddle games like Breakout.
I decided to get a bit more fancy and added additional buttons on the device that could be mapped to simulate additional buttons on the joysticks. This is great because having the extra buttons will be useful to map to things like Start, Select, Reset, etc..
I also added a small screen to see immediate feedback of the Joysticks, paddle, and the buttons on the device! In the photo above I have connected a dual paddle controller to the port on the right and the screen shows 2 half circles for that port. As I move the paddles the dials move on the screen. Real-time information is sent to the PC with built-in bluetooth and my PC sees the joysticks and paddles as game controllers.
I designed a nice case with Fusion 360 and added a charging circuit for the battery and with a few sleepless nights getting the code to work, finally had success.
Buy one here
You can buy one here on sale and proceeds go to charity since I just do this for fun.
Couple of weeks ago, I received a request on if I could make my retro joystick adapters compatible with Atari 5200 controllers, so I decided to give it a go. So I got myself a controller on eBay for $30 so I can begin the project. I knew right away that i would likely need to design a whole new adapter, given Atari 5200 controllers use 15 pin connectors compared to 9 pin connectors of most of their other consoles.
With some googling, I located the schematic below showing the controller has two potentiometers that control the x and y coordinates and couple of switched for the two fire buttons, and then a 4×4 keypad matrix. So thats total of 12 input lines needed for each joystick. 8 lines for 4×4 matrix, 2 for the stick position, and 2 for the fire buttons. To handle 2 joysticks, I would need at least 24 input ports.
I decided to use a Pro Mirco micro-controller along with a 16 port PCF8575 I/O expander and created the schematic below.
For a while I had trouble getting the buttons to work, but with some trouble shooting, I found out the controller I purchased had a bad flex circuit.
Luckily I had a conductive ink pen and it did the magic, at least for my testing. I ordered a new flex circuit for the controller for long term fix but I suspect the ink patch I did will last for several years.
I had 6 ports to spare, so I added common buttons on the unit dor things like Start, Select, etc.. I then designed the PC Board, and cleaned up the code to get it to professional quality, designed and printed a case and success!
Check out my video above to see it in action and give me a thumbs up. If you want to purchase one, you can get them here as well.
Atari 5200 Controller USB Adapter Pro – 2 ports
Connect 2 Atari 5200 joystick controllers with this device to your USB port. Your system will recognize your Atari 5200 joysticks as standard gamepads ready for you to use with your emulators and games. Small screen shows mode your ports are in and reacts to your movements. No drivers needed!
This device also recognizes the keypad and each of the buttons map to joystick buttons on your PC. Works with PC, MAC, Linux, and Mobile phones. See my blog for some more info. See Youtube video here
Remember this is home made quality. Does not include joysticks. All net proceeds go to charity since I just make these for fun.
Many micro-controller projects use lithium ion (li-ion) batteries and we needs a simple way to display the state of charge (SoC) which is how much battery we have left. This is typically displayed on the screen as a partially filled battery icon and optionally a percentage indicator next to it.
There are however several challenges we need to address to be able to display reasonably accurate information on the screen. We will focus on the three primary items below which does the job with very little effort.
How o we measure the battery level?
How does the batteries characteristics taken into account?
How do we quickly draw this visually without having to worry about bitmaps that can be slow and harder to work with?
Measuring Battery Level
Measuring of the battery level can be accomplished by by using one of the micro-controllers input ports set up as an analog to digital converter (ADC). The main thing is to account for max voltage on the input pins compared to your batteries max voltage. For example, most li-ion batteries produce around 4.2 volts when they are fully charged so connecting them to a 3.3 volt operated micro-controller input pin will either burn out the pin or the input will read it the same level so you will not be able to see the difference between 4.2V and 3.3V.
The solution is to use two resistor as voltage dividers to reduce the voltage slightly so the maximum voltage to the pin is 0.75X of the micro-controllers rating. So say we we have a Li-on battery at 4.2V and running a ESP32 micro-controller at 3.3V, we want the maximum voltage to the Analog Input pin to be: 3.3V x 0.75 = 2.5 Volts
Using ohms law and this example calculator, we find out the values we need for the two resistors we need as shown:
So all we need to do is connect our Li-Ion battery to the 2 resistors and feed the divided voltage to the input pin of our micro-controller and we will be within safe specs of the ESP32 and we will get much more accurate readings, especially on the higher end.
For the lower end, we need to know approximately the minimum voltage the micro-controller will still operate before it just gives up and shuts down. Looking at the ESP32s data sheet for operating range it says it can operate with minimum source voltage of 2.3 volts.
At this low end right before they system gives up, what is the voltage applied to our input pin through our divider? Using the same formula above we get 1.37 volts.
So what will the ESP 32 input pin measure when it sees 2.5V on the high end and 1.37V on the low end? This can vary depending on how many bits the ADC of the micro-controller has. The ESP32 has 12-bit ADCs which means it can report 4096 different levels on the ADC pin. If you assume 4096 = 3.3V and 0 is 0V, this means our range of 1.37 to 2.5v should give us values between 1700 and 3100. In practice, its not 1:1 like this as the ADC performs differently in higher and lower ends and amount of load on battery can effect it, so you may need to measure the full charge level for your project. For now we can use these and I will show you how to adjust for load later in the article. This brings the next challenge as follows.
Li-ion batteries do not discharge linearly!
We need to understand how a Li-Ion batteries discharge over time because if we simply take the voltage we measure and show it as a percentage between low and high range, we will not get correct results because the discharge curve for Li-Ion batteries are not linear. Instead the they typically look something like below.
Between full charge (V full) say 4.2V and (V exp) ~3.3v, the discharge rate is rapid. For majority of the operating time, the discharge rate is very low. this is the mid section of the graph above. The higher the battery capacity, the longer this middle cycle is. Finally, when the voltage reaches (Vnom), the discharge rate picks up quickly. If we do not account for this you will see some ugly results on your display.
For example, lets say you have a 500mah battery that lasts about 4 hours in your project and our battery reading range was 3100 at full and 1700 right before it would shut down as described previously:
First 30 minutes you would see the battery go down from 100% to 80% (readings of 3100 to 2820 )
Next 3 hours you would see it go from 80% to 60% (reading of 2820 to 2540)
Then, you would see it drop from from 60% to 0 in last 30 minutes! (reading of 2540 to 1700)
How did I go from 60% to 0 so fast? Sounds familiar 🙂
We can give users a much better experience and account for this in our project by treating each of these 3 phases differently. We can normalize these phases by
Mapping the first phase which was originally 100 to 80%, to be instead 100 to 90%.
Mapping the second phase which was originally 80 to 60%, to be instead 90%-10%.
Mapping the last phase which was originally 60 to 0%, to be instead 10%-0%.
This is how it would look like in code:
value = analogRead(GPIO_NUM_36);
if (value >= 3100) bat_percent = 100;
else if (value >= 2820) // 90-100% range
bat_percent = map(value, 2820, 3100, 90, 100);
else if (value >= 2540) // 10-90% range
bat_percent = map(value, 2540, 2820, 10, 90);
else if (value >= 1700) // 0-10% range
bat_percent = map(value, 1700, 2540, 0, 10);
else bat_percent = 0;
So I tested this in a test project where I used a small screen with an ESP32 connected to a 500mah Li-Ion battery.
Remember I mentioned earlier that load of projects can effect the range I used above which was 3100-1700. So I fully charged the battery and connected to the ESP32 to capture battery levels and saw the high was almost 2700 and they lows before my battery died was 1700 . I decided to graph my batteries discharge curve by checking voltage every second and sending the values via Bluetooth communication to my PC where I could graph the discharge curve using raw levels and the mapped percentages based on adjustments I made. Here are the results:
You can see the true discharge curve in blue and how the modified code below transformed it to the orange much linear percentage over time.
value = analogRead(GPIO_NUM_36);
if (value >= 2650) bat_percent = 100;
else if (value >= 2500) // 85-100% range
bat_percent = map(value, 2500, 2650, 85, 100);
else if (value >= 2100) // 10-85% range
bat_percent = map(value, 2100, 2500, 10, 85);
else if (value >= 1700) // 0-10% range
bat_percent = map(value, 1700, 2100, 0, 10);
else bat_percent = 0;
Drawing the Battery Indicator
Instead of messing with loading bitmaps which can we a bid difficult to deal with, I found it much easier to just draw 3 of rectangles as follows:
You can then easily update the last filled rectangle with the current percentage adjusted for size of the rectangle. For example if the rectangle is 20 in width, you would just divide your battery percentage by 5 to get the width of the filled rectangle. This is what it looks like on my sample project. You can tell I missed the thickness of my first rectangle 🙂
Good luck and make sure to leave comments and questions!
I recently built a Raspberry Pi 4 unit with Retro Pi and Emulation Station to check out its performance for retro gaming and when I got the Atari 800 emulation to work, it brought back many childhood memories of my first real PC. Games like Star Raiders and M.U.L.E. were well ahead of their time and to get the true experience, they have to be played with real Atari joysticks!
Star Raiders and M.U.L.E. on Atari 800
For past few months, I spent a good amount of time programming micro-controllers for IoT devices for my work projects and I thought about the possibility of using a micro-controllers to adapt Atari Joysticks to a PC so they can be seen as regular PC Gamepads.
I looked online and found some classic joysticks that came with the Atari Game Console Flashback unit for $15 on eBay and decided to give it a shot.
I checked out the Pin Diagrams for the joysticks and it seemed simple enough as they are basically 5 switches (1 for each direction and 1 fire button). Since I wanted at least 2 Joysticks connected for multiplayer games, I needed at least 10 IO ports to connect the 5 switches of each joystick.
I decided to use an Arduino Pro Micro controller since it was only $4, had plenty of IO ports, and most importantly it had a USB port that can communicate with PCs as a HID device.
I created a circuit design on EasyEDA so I could later order a PC baord but initially I created a prototype using PCS Prototype Boards you can get from Amazon or Aliexpress for pennies.
I ordered a few DB9 male connectors where the I could plug the joysticks into and put the parts on the board and soldered the connections.
If you are wondering how the animation below shows 5 button working, its not related to directions.. keep reading as there are multi button Atari joysticks.
Next. I decided to make an enclosure for it using my 3D printer! I drew it up in Fusion 360 and printed the top and bottom and made quite a tight fit.
I was finished with first working prototype. Next I refined it to a smaller version with a professionally made circuit board so its more reliable, no jumper wires, and less soldering. So its basically done.
But wait, M.U.L.E. is best with 4 players and I had to find a way to get it done so I could play with my nephews. One way was just to build another one taking up 2 USB ports and double the parts, and another was to challenge myself to do a 4 player design with a single USB port. So I did both 🙂
For the 4 port unit, I needed more ports so I decided to use a I2C I/O extender that can extend 2 GPIO pins to 16 using serial communication. I also wanted to support the modified Joysticks that have the extra Start, Select, Menu, and a few more button. Here is the circuit diagram and the outcome.
It worked great and I can tell you we had an amazing time playing 4 player M.U.L.E. ! So give it a shot and make one. You can get the code here.
If you rather just buy one from me, you can get it below. All net proceeds go to charity.
Next blog post, I will show you how I made a wireless version! It was not easy to get more than 1 joystick to work with a single device Bluetooth connection but I finally did it! The code was intense. Take a peek:
Very cool with no wires so I can sit back far from the TV and still play. Will be working on getting a commercial one out soon. Stay tuned!
Eight Constitution Medicine (ECM) is a comprehensive system of healing that has been proven effective for over 2500 years. It is one of the fastest growing health care modalities today.
Why does one get tired after eating a meal? Why is one allergic to a particular food or medication and others are not? Why does one get angry easily but another is calm from the moment they were born? The answer to these and similar questions is that each person’s make-up (also known as constitution), is different.
Everyone is born with a different constitution based on their genetics and physiology being either like their mother or father, as far as the relative strength and weaknesses of their organs. People with the same disease or condition react differently to a food or a medication. This is because of their constitution.
In ECM, a specialized pulse taking technique is used to diagnose your constitution (your make up) to identify what your strengths and weaknesses are (which appear inherently in the organ system, shape, character, personality, etc.).
Your constitution will dictate what food groups to eat or avoid to help your body to heal itself. By following the right food regimen based on your constitution, you can help strengthen the weak and the deficient, or balance the overactive and the excess condition that you have.
Each constitution’s food intake plan is categorized in 3 groups based on the energetic nature and the effect of the foods on the body as follows
Good for You: Foods that are most beneficial for your health. Consuming them balances your organ system.
Better to Avoid: Food that you should eat in moderation and rarely, and should not be a large portion of any meal.
Bad for You: Foods that are harmful to your well- being, and contribute to your illness.
If you do not know what your Constitution is, contact Verity and setup an appointment to have them examine you and determine your constitution.
Here at iCode, we developed a mobile application that lets individuals quickly lookup foods and displays the properties, nature, and effectiveness as they relate to their specific constitution.
Here is a simple mobile app I helped my son write. He is a big Risk fan and this seemed like a great way for him to get introduced to android development.
Risk Dice Roller app is designed to replace dice needed for the original risk board game. It automates the rolling process and keeps history and statistics of each players rolls. You can even automate larger battles and watch as your large army takes on the defenders. It can be really fun to compare player stats and its effect on the outcome of the game.
If you need to locate a field in a large database and you don’t know what table the filed is or not really sure of the exact spelling of the field, you can use this simple query to search for fields names in a database.
SELECT t.name AS table_name,
SCHEMA_NAME(schema_id) AS schema_name,
c.name AS column_name
FROM sys.tables AS t
INNER JOIN sys.columns c ON t.OBJECT_ID = c.OBJECT_ID
WHERE c.name LIKE '%Your_Field_Name%'
ORDER BY schema_name, table_name
To use the function, simply pass in the 4 point and a time (between 0 and 1). To draw the curve, try calling this function from a for loop that looks something like this:
// preset your p0,p1,p2,p3
for (float t = 0; t <= 1.0f; t += 0.01f)
PlotPoint = GetPoint(t, p0, p1, p2, p3);
// now call some function to plot the PlotPoint
This basically starts you at p0 when time t is zero and at each increment of time +0.01 you will slowly move on the curve towards p3.
So to give you an idea of how this was used by my son in one of his games, watch the video below
Note these are circular Paths each withe 3 segments. Each segment is a 4 point Bezier calculation.
p3 of the each segment is common to p0 of next each segment.
To make the circular, p3 of last segment must be same as p0 of 1st segment.
p2 and p3 of each segment must be on a strait line with p0 and p1 or the next segment. (this give you the double handles for each point)
So this means:
If a path point was moved by user, you must also move left and right control handler points by same deltas
If left handler moved, must also move corresponding path point so it intersects line to other handler at mid point
If right handler moved, must also move corresponding path point so it intersects line to other handler at mid point