It’s been a long time since I’ve posted something new here, but that doesn’t mean I’m not working on cool projects. I’ve got lots of new ideas and more resources than ever before being in college (Lehigh University.)
I’m hoping to work on some new FPGA stuff, a higher quality wireless power system, and I also want to build a coil gun. As I get to building it all, I’ll update on here and put up pictures, schematics, and code for whoever is interested.
Though I love my hobbies, my work in college is more important, so I’ll be a little slow on updates. Just check back once in a while. Or maybe you’ll see something I built featured on Hackaday or a similar site.
A few months ago I decided to purchase the new third generation Amazon Kindle 3G. One of my favorite qualities of this device was the e-ink display, which uses no power to display an image. This allows the battery to last for extremely long periods of time without needing to be recharged. In addition, to protect my new device, I purchased the lighted leather case made by Amazon specifically for the Kindle.
Unfortunately, the official lighted case ruins the battery life, even when the light is not in use! Instead of the week of battery life that I had gotten before using a case, I could now only manage a day or two, even with the device turned off and wireless communication fully disabled. At first, I didn’t believe that the case was the problem. I assumed it was due to the indexing of books, a bad battery, or something else. As an engineer, I decided to test my ideas to find the most likely reason for my bad battery life.
I removed all my books to be sure it wasn’t an indexing problem. I tested the battery without a case. The battery went back to normal. I checked the resistance of the light’s power terminals when off. There was no connection at all. Then, I discovered the ;dumpmessages command. This, when typed into the search box on the device, makes the Kindle dump all logs, including battery drain logs to the internal memory where they can be accessed on a computer. Every 10 minutes, the battery capacity in milliamp-hours, the current potential in millivolts, the load in milliamps, and some other information is logged. By leaving my Kindle for an hour both in the case and outside the case, I would get 6 data points for drain in each situation. Finally, I found that the drain actually doubled with the case on!
The drain with no case averaged 39mA while in sleep mode (when the screensaver image is displayed.) With the case, however, the drain averaged 83mA, more than double the original. But why? The wireless connection was turned off, so it couldn’t be a signal problem. There is no connection between the two clips of the case when the light is retracted. The only other possibility that I could see is that the clips are causing an internal short or in some other way are triggering something internally.
Unfortunately, this is as far as I have gotten. I have read people say that these internal connections next to the clip connection point aren’t an issue, but from my tests they do seem to be. I’m still doing more research, but until I find out the problem, I am just going to attempt to get a replacement Kindle, which hopefully will not have this problem. It seems that the official Kindle cases may not be the best choice if battery life and stability are important. Even the non-lighted cases have been causing many problems.
If I can find anything new, I’ll post it here right away.
Edit: I have called Kindle support and they decided to send me a whole new Kindle. Once I get it, I’ll test it again and see what happens.
Edit 2: I received my new Kindle and immediately tested it. It turns out that the Kindle was really the problem. From the way the logs look, the old one wasn’t going into suspend mode properly, as it continued to report power drain information while it was off. In the new device, it only reports total power consumed in suspend once the device is turned back on. In an overnight test with 3G enabled and the Kindle in its case, the battery drained 31mAh and dropped 50mV, and lost only 3% of it’s total capacity, down to 97% remaining.
It seems that this has fixed the problem, but it is still odd that in the original the case doubled the drain. I’m going to continue testing this to see the effect in my new Kindle.
Well, I haven’t updated my site in quite a while, but I’m still working on projects. I have a lot of cool things coming, so keep watching this site. For now, I’m focusing on AP tests so I can get myself some college credits. When that’s all over, I’ll start documenting my projects again.
Today is my 18th birthday, so of course I’m going to post about something.
This is something interesting that I discovered when I was messing around with some LEDs. It turns out that not only do they convert energy into light, but this is reversible. By shining a light on an LED, you can get power back out! It’s not the most efficient setup, but it’s great to experiment with.
What’s even more interesting about using LEDs as photovoltaics is that they are more sensitive to their color. Knowing this, you can actually somewhat detect the wavelength of light using LEDs. Also, you can set two of the same color LEDs facing each other with one powered and the other as a photovoltaic, creating a simple and cheap photogate that can be used for timing, speed control, and similar projects. Also, I set up a laser pointed at an LED and got significant voltage out on the other end.
What I really like about this whole thing is that it allows you to use parts you already have for quite a variety of different things. Whether you’re harvesting energy or detecting motion, LEDs make a great, cheap alternative to more expensive parts for some fun experiments.
Pictures and more info will be added soon.
Recently I’ve been learning a lot about binary logic, which is the basis of digital systems. By combining simple logic gates, which each have their own functions, one can do a variety of operations. The most obvious operations are mathematical, like addition, subtraction, multiplication, and division. By looking at logic diagrams, then expanding the logic gates to the transistor level, we can build simple calculation circuits similar to the ones used in microprocessors.
Today, I found myself with a bit of free time, an empty breadboard, and a nice selection of components, so I decided to test what I’ve been studying to see how well it all works in the real world. To start off, I decided to build a simple 1 bit half adder, which adds together two single bit inputs and outputs two bits. The first bit is the sum, and the second is the carry. The sum is the lower digit, similar to the ones place value in the decimal system. The carry is the next, like the tens value. Of course, this is binary and not decimal to they have values of 1 and 2, respectively.
Originally I wanted to build my circuit entirely using discrete transistors, but unfortunately I couldn’t find a simple way to build the exclusive-or (XOR) gate needed to take the sum of the two inputs. Instead, I had the HD47LS00 Quad 2-input NAND gate integrated circuit, so I put that to use. Using four two input NAND gates, it’s possible to create a single XOR gate, which was perfect for my situation. Building the other gate that I needed, an AND gate, was quite simple and only required the use of two transistors. I combined both gates on my breadboard, threw in some LEDs for outputs, and applied power, giving me a working half adder circuit.
Maybe my next circuit will be a full adder, or maybe I’ll move on to using all integrated circuits rather than discrete transistors and build something even more interesting. Either way, I’ll document my progress and post about it here.
Edit: So I decided that instead of using more ICs, I’d use just transistors. It’s a lot more interesting that way.
I figured out how to do this using the following site:
Another possibility – XOR gate using diodes:
This would work the same way as the first circuit using the XOR as the sum and the AND as the carry.
So I’ve decided to use my new website to document my various electronics projects. This will be the first real post.
At my high school, we have a Vex robotics competition run by my physics teacher. I am a lab assistant for this teacher, so I help out whenever he needs things done. A few weeks ago, my teacher purchased new batteries for the Vex robots. These battery packs were cheaper than the official version and claimed more than twice the capacity. I was, of course, skeptical of the rating given on the package. I was then given the assignment to find a way to measure the capacity of these batteries and compare which we should buy in the future as replacements.
My solution, while somewhat complex, was to build a circuit to calculate the capacity. My original plans were to discharge the battery through a resistor and measure the voltage of the battery using the analog to digital converter of a PIC microcontroller, using a MOSFET to control current. After building a prototype, I decided there were too many issues with this method including limited storage on the controller, difficulty in retrieving and analyzing the data, and issues with the current changing as the voltage decreased.
My next design, the current version, utilizes a Teensy microcontroller. I had one of these lying around from previous projects, so I decided to use it. The first reason I decided to use it was the simple setup which allowed me to quickly design a prototype. I like the simplicity of the Arduino environment and the USB serial connection. I also found the USB keyboard function to be quite useful, as I will explain.
The next step was to build a loading circuit to discharge the battery. I like the idea of using a MOSFET to control current, but I realized that this wasn’t really necessary and just complicated things for me. Instead, I set up a simple LM317T constant current load. To do this, I set the output voltage of the 317T to 2.5V, significantly lower than the voltage of the batteries that I am testing. Then, I connected the output across a 10 ohm, 10 watt resistor. The 10W power rating is a bit higher than necessary, but it was what I had and it’s better for running the circuit for long periods of time anyway. With this setup, my load current stayed around 250mA, which is an acceptable discharge current for this type of battery.
After setting up the load, all I needed to do was build a resistor divider to measure the voltage of the battery over time. I also added another analog reading to measure the current of the load since it still varies slightly. These were both simple to set up. Due to the tolerances of the resistors, I had to calibrate the setup in software using my multimeter.
After the circuit was complete, I decided to throw in a 16×2 parallel LCD so I could see exactly what was going on. On it, I displayed discharge current, voltage, time running, and calculated capacity. This made the whole setup easier to use.
Now comes the software. As I previously mentioned, I used the Arduino platform to set this up due to its simplicity. Many people don’t like Arduino because it allows beginners to fully bypass the process of interfacing hardware and it’s way too powerful for most the projects it’s used for, but I needed to quickly design this circuit and simplicity was needed. My code collects voltage and current data once a minute, calculates the capacity drained milliamp-hours, displays all the data on the screen, and uses the keyboard function of the Teensy to type it all into a spreadsheet on the connected computer, then saving the file. This makes it easy to read the capacity of the battery on the LCD and have a nice discharge graph to further analyze.
A final touch I added was a heatsink on the 317T which sits nicely on top of the 10W resistor, keeping all of the power components nice and cool.
In the end, I used this circuit to test several different batteries. It seems to work quite well. For a few 2000mAh batteries, my circuit calculated around 1900mAh, which is acceptable since batteries are often slightly over-rated in capacity. The Chinese battery, rated at over 6000mAh came out to be a little over 3000mAh, which was better than the official Vex batteries and cheaper, so that is what we are going to be using in the future. I also got around 800mAh out of a slightly used 900mAh 14500 lithium battery.
TrustFire “14500″ lithium test results:
He is the code that I used. My coding skills aren’t too great, but it does work properly.
So I’m still working on putting stuff here. I now have a new theme, some fancy menus on the side to make the site easier to use, and various other improvements that aren’t particularly obvious.
It’s getting there…
Soon there will be actual content.