DIYtronics

Epson emp-s4 Projector LED Mod

2013-03-27T10:19:00.001-07:00

Recently during one of my Ebay window shopping sessions I came across a listing for an 'as is' Epson projector missing a lamp. It was sold as is because it would turn on and then simply flash a lamp error and since the lamp is much more expensive than the projector as a whole, the seller undoubtedly decided to sell just the projector rather than purchase a new bulb. The best part was that he was willing to part with it for $25 with free shipping. As far as I could tell nothing else was wrong with the projector so I took the plunge.

While waiting for it to ship I read up on the control systems that these projectors use in order to control the ballast and lamp assembly. It looked like nothing more complicated than tricking an input to the main board to make the projector think a real lamp was inserted while in reality I would use a high power LED but more on that later.

A week later it arrived in a huge box and as I hurried back to my dorm room I tore it open in excitement. It has three lcds, one for red, blue, and green. These three images are added together with the help of a lens to create the final image. The next step was to remove the ballast and figure out how which two wires from its control cable sent the lamp ok indication. I noticed that the ballast (the circuit board on the bottom left in the picture below), had a digital control circuit mounted vertically with three optoisolators near the i/o cable. These chips are necessary to insure that the digital low voltage i/o dont mix with the high voltages present in the rest of the ballast or else this projector might release its magic smoke. In addition two of the optos were facing left while only one was facing right. This hinted to me that the one lone opto was the output sent to the main board pictured in the upper right below to tell it that the lamp was operating perfectly fine so that the projector would stay on instead of shutting off and giving an error like it would without a lamp inserted.

So my solution was to short out the two wires that led to this opto (found with the help of my multimeter). I also needed to tape down the lamp door safety open switch so it could operate with the cover off. Now when I shone a flashlight into the lens input on the upper left of the image above I could faintly see an image being projected from the projection lens on the bottom right. Bingo, now I was getting somewhere. Now I needed more POWER!

I had bought a 30W 2000 lumen LED and 2A ac/dc driver in anticipation of this exact purpose a while ago so I dug that out of my parts bin along with some optical lenses to focus the light. I drilled into an old pentium cpu heatsink and attached it to the LED because after a few seconds it got rather hot. The fan came with the heatsink so I just wired it up in parallel with the exhaust fan seen below to the upper right of the picture. Then I used some framing wire to attached the glass lens to the assembly. This ensures that the light is concentrated and evenly dispersed into the small window to the left.

Next I need a way to turn on and off the led because having the light on all the time when the projector was plugged in was no fun. I could have gotten fancy and dug into the buck control circuitry of my LED driver and done it that way but I opted for a more universal approach in case I wanted to upgrade the light source in the future. I patched a ac cable into the power input of the projector's main power supply board to gain access to 120V AC. Then I used a beefy relay pulled from an old computer battery backed ups (uninterpretable power supply). This small beast could handle 5A at 125V so it should be sufficient for the task. I placed out of the way it in a crevice in the bottom left of the projector as seen in the picture below. Normally when the coil is unenergized it opens the circuit so the LED is off. When it receives the signal from one of the other optos (I carefully tested with the projector open to see which control line to the ballast changed when the projector was turned on and off) it sends current through the relay switching the AC voltage into the LED driver thus turning the LED on. This way the hacked on LED would behave exactly like the original lamp: it turns on and off with the projector with no user intervention.

The LED driver in the protective plastic shield on top of the main power supply can be seen above in addition to the small optoisolator and flyback diode circuit I built to handle automatic relay control to allow the projector to turn on and off the LED itself.

I pulled ground and +12V for the relay coil from these two spots on the main board.

Finally a picture of the entire device fully modded to my liking. Its a thing of beauty.

Now for a test I played some video games on it for an hour and measured the internal temperatures to make sure that it would be fine. Here is a projected screen size of about 30" in pitch black room for your enjoyment.

And what game did I test I hear you ask. Only one of my favorites of all time ;-)

These images were about 30-35" diagonal. Not too bad. They look better in person its just that I had to use my phone cameras as I forgot to bring home my nice Sony camera for spring break. I can push the image to 45-50" and still be viewable in a pitch dark room but brightness degrades quickly. I'll see if I can get my hands on a 8000 lumen 100W LED and make this almost as bright as it originally would be with the stock lamp. Here is a quick video of the internals and it operating for those who are interested.

For now I will go ahead and call this hack a success. Now let me get back to beating Castlevania Symphony of the Night for the millionth time ...

If you have any questions feel free to comment below and I will do what I can to help.

Yet Another POV Clock Project!

2013-01-04T15:40:00.002-08:00

Yep. I'm at it again. Yet another POV display (my third iteration in fact). I'm a sucker for things that move and blink rapidly. You can see my past POV projects in the Projects tab above.

This time instead of using a rotating disc or arm like I've done in the past I've opted to use a wand that oscillates back and forth to write out the image. I got the idea after seeing a commercial clock that uses the same mechanism. But you know it's no fun buying something ........ you have to make it to fully enjoy it!

So I stated off by testing out several methods to generate the oscillations. I took apart several harddrives to harvest the armature coils and magnets only to find that they couldn't bear the load of a long wand and still oscillate quick enough and with large enough magnitude to be useful. So I dug into my junk bin to see if I could find an idea.

I found a stiff yet springy piece of metal, a 'U' shaped plastic cut from a DIP tube, some coils from the brushless spindle motor in an old VCR I took apart ages ago, and two neodymium magnets from an old name tag. These would be the main components that would make up the armature and electromagnetic assembly. The springy metal is secured to the end of the plastic tube and the magnets are fitted on either side of the tube an inch or two above the metal. It looks something like this:

The leds are soldered to a little piece of perfboard and connected down the length of the tube with magnet wire. Here is a few pics of mechanism and leds working:

Warning!!! Physics lecture incoming: so here is the general concept of how the mechanism works. The springy metal is secured to the base, and the coils are mounted on either side of the two magnets on the arm. A microcontroller with an adjustable oscillator drives a transistor which switches the coils which are wired in parallel. This kicks the magnets and the armature every once and a while inserting kinetic energy into the system (it's essentially a forcing function and a mass spring system which can be described by a simple differential equation). By tuning the rate of the driving electromagnetic pulse to the resonant frequency of the spring and mass armature you can get it to sustain a large amplitude oscillation. I knew Physics would come in handy one day!

So, now I have a reliable oscillating mechanism as seen in this video:

And I have managed to get the leds all wired and working with a simple demo going:

So all I need to do now is add a photointurrupter to sense when the arm is at the starting position so that I can sync up the display and then code software for a character set and animations as well as add a real time clock chip. Oh and finish the case and solder the circuit. Don't worry I'll keep you all updated in the next upcoming steps for this project and I'm planning on releasing all of the code and schematics just because you guys are awesome. Stay tuned for the next thrilling installment of POV Clock!

UPDATE!!! I've used the electromagnetic pulse controller's led output as a sync signal to varying degree to display the ceremonious "HELLO" message as a first text demo as seen below.

Note that I am seeing some problems with the low refresh rate manifesting itself as an annoying flickering. I'll have to think something up to fix this problem. Until then!

TeardownTube - episode 14 - Nintendo DS

2012-12-20T12:22:00.002-08:00

Here's the 14th episode of TeardownTube. Subscribe, comment, and like if you want to see a different device dismantled every week. The videos are not detailed instructions for repair but rather just for entertainment. Enjoy.

In this episode I explore inside a vintage 2004 Nintendo DS, the first in the line of the current gen dual screen portable game consoles. How did Nintendo manage to squeeze two 3" LCDs into your pocket? Find out in the video above.

Link: TeardownTube - episode 14 - Nintendo DS

TeardownTube - episode 13 - PSP Go

2012-12-04T21:43:00.000-08:00

Here's the 13th episode of TeardownTube. Subscribe, comment, and like if you want to see a different device dismantled every week. The videos are not detailed instructions for repair but rather just for entertainment. Enjoy.

In this episode I tear into a sexy PSP Go I managed to score "broken" on Ebay for only $30. A stupidly easy fix. How did Sony manage to fit all of the goodness (well except for the UMD drive) of the psp down into the miniscule PSP Go? Find out as I explore and delve headfirst and have a "Go" at the PSP Go ... see what I did there?!!

Link: TeardownTube - episode 13 - PSP Go

Wanna read my repair experience for this device? Read the writeup HERE!

Broken PSP Go repair

2012-12-03T20:55:00.003-08:00

I was crawling around Ebay about two weeks ago looking for good deals on broken but repairable electronics like I normally do. I've bought up countless iPods in the past to repair and resell. In fact just over Thanksgiving break I found a Nintendo DS that works perfectly but has a broken hinge for $5, but that is a story for another day. So begins a tale of an adventure on my most recent excursion.

This time I found a PSP Go (the full sized PSP's little digital media only cousin) that was listed by the seller, who was a reseller likely with no specialized knowledge about hardware, as "not turning on" and "unable to test without a charger". The description and the price ($30) piqued my interest. The photos posted showed that the unit was in good physical condition (with the exception of some scratches on the lcd). I wagered on the unit not having any water or electrical damage. It takes some experience and intuition to be able to tell what is repairable and what is too far gone. I just felt it in my gut that this would all work out in the end. So I took a gamble and quickly bought the device. I just hoped I hadn't thrown $30 away on a expensive paper weight. After all that has happened in the past.

It just arrived today and I excitedly returned with the small package to my dorm room to begin operation. I was so excited that I slammed my knee into my desk twice and winced in pain as I attempted to diagnose the device. Just as the seller said the device did absolutely squat when the power switch was pressed. No surprises there!

So I opened her up. Thanks Sony for using standard Phillips screws! If only they wouldn't use proprietary hardware ... but I digress. I was inside in under a minute. The only thing that was keeping me from the battery was an annoying warranty void sticker. Hah like I care. RIPPPPP! Well there goes the likely long gone warranty. I measured the voltage on the lithium ion battery and unsurprisingly it was completely dead. Oh well. Like the seller I didn't have the charging cable ... cough cough .. proprietary hardware ... so I was seemingly out of luck.

But I'm an engineer and engineers are stubborn but more importantly they are resourceful. I had a familiar max1555 (lithium ion/polymer battery charge controller) wired up on a breadboard. Of course another problem popped up, the battery used an annoying tiny connector but all was not lost. I'm up at college so all I had was some twisty ties so I cut off the insulation and just poked the wires into the connector, dirty and ugly but it'll work. Now I just needed 5-8V preferably without sacrificing a USB cable or power cord. I had a USB to USART bridge module on hand and luckily it has a 5V output so I just tapped into that. I plugged it into a USB wallwart and waited for the battery to charge a bit. I hooked up a meter to keep an eye on the battery's voltage.

Well after the battery sat there for a while I grew impatient so I measured the battery to make sure it had some charge and threw it back into the device. I waited with bated breath as I flipped the power switch ... big fat NOTHING!!! Of course it wouldn't be that simple. Oh well ... save me Google! A few minutes of research netted me with the hint that holding left on the D-pad while pressing power may yet resurrect my unit. I had nothing to lose so tried it ...

... and the PSP rose from its slumber to greet me with the XMB. Yeah. Now we are cooking. I thoroughly tested the unit and everything works. I ended up getting a device which used goes for around $80-100 online for only $30. All I needed was some patience, perseverence, and a huge pair of ... engineering skills!

Every device I fix or take apart gives me experience and knowledge. I highly recommend going to thrift stores or surfing Ebay and picking up cheap old electronics to mess around with. There is no guarantee that everything will work out as well this experience, but the skills I have gained from not just my successes but also my failures work to further my capabilities as well as my confidence. Every little lesson is invaluable.

Sorry I rambled on for a bit, but I just felt like trying to inspire other fellow engineers just starting out to take the plunge and mess around with some otherwise "broken" electronics and possibly save them from ending up in a landfill. Engineering and life are about being fearless and resourceful when conditions are not optimal. In the end I will be happy if my writeup was marginally entertaining and inspired others to do something similar.

As always comment below if you have any questions or are in need of advice. I always try my best to help. See you at my next electronics hacking or repair escapade!

TeardownTube - episode 12 - External DVD Burner Drive

2012-11-20T15:14:00.003-08:00

Here's the 12th episode of TeardownTube. Subscribe, comment, and like if you want to see a different device dismantled every week. The videos are not detailed instructions for repair but rather just for entertainment. Enjoy.

In this episode I take a peek at the inner construction of a standard laptop DVD burner drive inside of a usb to pata enclosure. How do they make these small enough to fit into the slimmest of laptops? Find out now.

Link: TeardownTube - episode 12 - External DVD Burner Drive

TeardownTube - episode 11 - Western Digital Passport External Drives

2012-11-10T13:10:00.000-08:00

Here's the 11th episode of TeardownTube. Subscribe, comment, and like if you want to see a different device dismantled every week. The videos are not detailed instructions for repair but rather just for entertainment. Enjoy.

In this episode I look inside two of my Western Digital Passport series drives. Is WD pulling a fast one on consumers? How did they manage to make the usb 3.0 drives even smaller than their older usb 2.0 variants? Watch to find out.

Link: TeardownTube - episode 11 - Western Digital Passport External Drives

TeardownTube - episode 10 - AAXA Technologies P1 Jr Pocket Projector

2012-10-27T12:56:00.001-07:00

Here's the 10th episode of TeardownTube. Subscribe, comment, and like if you want to see a different device dismantled every week. The videos are not detailed instructions for repair but rather just for entertainment. Enjoy.

In this episode I tear into my recent purchase. I've finally jumped on the bandwagon and bought a pocket pico projector. See what sorcery allows such a tiny device to project up to a 40 inch image.

Link: TeardownTube - episode 10 - AAXA Technologies P1 Jr Pocket Projector

TeardownTube - episode 9 - Gameboy Color and Game Cartridges

2012-10-27T12:52:00.002-07:00

Here's the 9th episode of TeardownTube. Subscribe, comment, and like if you want to see a different device dismantled every week. The videos are not detailed instructions for repair but rather just for entertainment. Enjoy.

In this episode I take a look at the first Nintendo portable system to sport a color screen. Just how similar is it to its monochrome cousin, the gameboy pocket? Also as a special treat I explore the insides of a few gameboy and advance cartridges as well as a flashcart I had sitting around. Enjoy.

Link: TeardownTube - episode 9 - Gameboy Color and Game Cartridges

TeardownTube - episode 8 - Gameboy Advance SP+

2012-10-27T12:46:00.002-07:00

Here's the 8th episode of TeardownTube. Subscribe, comment, and like if you want to see a different device dismantled every week. The videos are not detailed instructions for repair but rather just for entertainment. Enjoy.

In this episode I continue on with portable video game hardware history. What magic did the engineers at Nintendo squeeze into the foldable gba sp+? Watch to find out.

Link: TeardownTube - episode 8 - Gameboy Advance SP+

Nokia LCD PIC driver revamp

2012-09-17T15:49:00.000-07:00

It's been quite some time since I've published my last post on interfacing a Nokia 84x48 monochromatic LCD to a PIC microcontroller but I recently got the itch to port the driver code from its original assembler to the language I use most now, C. Once again I opted to write the SPI interface in software since it gives greater flexibility although at the cost of speed. I've upgraded from my paltry pic16f84a to the pic16f887 which offers several improvements including more memory, gpio, and an internal oscillator as well as many useful peripherals.

I've also picked up many useful programming tricks up my sleeve since then. This time I've made the driver faster as well as added direct support for drawing full 84x48 black and white images that can be drawn in Microsoft paint. If anyone wants I can write up a tutorial on drawing an image in paint and exporting it to another program to generate the hex array that my PIC uses to draw. But for now enjoy the pretty pictures.

This software will make it much easier to develop user interfaces and graphics for future devices. I realize that the display I am using is a bit outdated, but the practice is useful towards someday interfacing to much higher resolution color displays. Anyway, I think I've rambled on for long enough. Here are the source and image files. Feel free to ask for any help should you wish to integrate this display into your own project. Stay tuned because I have many cool projects and videos planned.

Files up on MediaFire

TeardownTube - episode 7 - Gameboy Pocket

2012-09-07T11:03:00.002-07:00

Here's the 7th episode of TeardownTube. Subscribe, comment, and like if you want to see a different device dismantled every week. The videos are not detailed instructions for repair but rather just for entertainment. Enjoy.

In this episode I venture into the past of portable video gaming when I lurk inside an old gameboy pocket. Find out what makes up the device which provided many children hours of joy in the 90's.

Link: TeardownTube - episode 7 - Gameboy Pocket

TeardownTube - episode 6 - Hard Drive

2012-08-28T13:11:00.002-07:00

Here's the #th episode of TeardownTube. Subscribe, comment, and like if you want to see a different device dismantled every week. The videos are not detailed instructions for repair but rather just for entertainment. Enjoy.

In this episode I venture past the warranty stickers and torx screws in order to get a peek inside an old 40GB pata 3.5" disk drive I had collecting dust in a drawer. I will be going back to college soon so I will have to put off uploading episodes until I get settled. I will definitely be back and I have some cool surprises planned. Stay tuned!

Link: TeardownTube - episode 6 - Hard Drive

TeardownTube - episode 5 - Gemei 4GB MP4 Player

2012-08-09T06:01:00.004-07:00

Here's the 5th episode of TeardownTube. Subscribe, comment, and like if you want to see a different device dismantled every week. The videos are not detailed instructions for repair but rather just for entertainment. Enjoy.

In this episode I reveal what cost cutting measures Chinese companies use to make the cheapest devices possible. Is it possible that I found a cheap MP4 player which isn't doomed for the trash and is worth more than the sum of its parts? Watch to find out.

Link: TeardownTube - episode 5 - Gemei 4GB MP4 Player

TeardownTube episode 4 - Palm Tungsten T2

2012-07-31T13:22:00.003-07:00

Here's the fourth episode of TeardownTube. Subscribe, comment, and like if you want to see a different device dismantled every week. The videos are not detailed instructions for repair but rather just for entertainment. Enjoy.

In this episode I take a look at an old Palm computer I found at a local thrift store for a few dollars. Have I finally met my match: a device which I cannot dissect? Watch to find out.

Link: TeardownTube - episode 4 - Palm Tungsten T2

TeardownTube episode 3 - PSone

2012-07-26T14:25:00.005-07:00

Here's the third episode of TeardownTube. Subscribe, comment, and like if you want to see a different device dismantled every week. The videos are not detailed instructions for repair but rather just for entertainment. Enjoy.

In this episode I crack open an old playstation one I scored at a thrift store a few years back. Its modchipped and awesome when paired with the 4" screen attachment.

Link: TeardownTube - episode 3 - PSone

TeardownTube episode 2 - Gamecube

2012-07-23T07:14:00.002-07:00

Here's the second episode of TeardownTube. Subscribe, comment, and like if you want to see a different device dismantled every week. The videos are not detailed instructions for repair but rather just for entertainment. Enjoy.

In this episode I take a look inside an old Gamecube that was collecting dust in my closet. And then I put it all back together.

Link: TeardownTube - episode 2 - Gamecube

TeardownTube episode 1 - Floppy Drive

2012-07-13T05:39:00.001-07:00

I've started a new show on Youtube called TeardownTube and just posted the first episode. Join me as I tear apart and comment on various devices for your entertainment. Subscribe, comment, and like if you want to see a different device dismantled every week. The videos are not detailed instructions for repair but rather just for entertainment. Enjoy.

In this episode I dismantle an old 3.5" floppy drive I pulled from an old tower PC. Ahh ... the smell of vintage computer hardware.

Link: TeardownTube - episode 1 - Floppy Drive

Fixing a PS3 Controller that Wont Charge

2012-06-22T11:39:00.001-07:00

Recently I found a cheap used PS3 at a local Game and Trade that was closing its doors. It's the older "fat" 80GB model. Everything was in pretty good condition except for the controller. It was obviously the store demo controller and thus was unbelievably disgusting. I had to handle it with gloves on. I entirely disassembled it and disinfected every part of it. There were a few things wrong with it:

1) I never eat or drink while playing for good reason (there was dried soda and chip fragments inside) along with mass amounts of gunk amassed from every hand that touched it.
2) There was a screw missing and the bottom tab snapped off so it was obviously opened before.
3) The analog nubs were missing their rubber tops.
4) I didn't realize it until the controller had low battery, but it refuses to charge.

I easily remedied the first two with a thorough cleaning and a screw from my screw collection. The third will be repaired with some help from my friend EBAY. Finally the last one was a little tricky. I think the charging issue might be due to some liquid damage. I measure the voltage when plugged into a USB adapter and noticed that instead of a nice 5V, I was getting a unstable 2V. This explains why the PS3 complains about too much current being drawn when the controller is plugged in. I figured I had nothing to lose so I went about trying to fix this problem.

Ultimately I figured that it would be far easier and cheaper to add in my own charging circuitry than track down the short circuit culprit and replace parts I likely did not have on hand. I started with a chip I am very familiar with and had in my parts box, the max1555. This tiny five pin smt chip handles safely charging the lithium ion battery and even has an open collector output that is on when charging and off when done. It accepts USB 5V or DC up to 7V or so. I etched my own board and decided to make things difficult for my self by making it tiny (it ended up being not much larger than the sot23 package).

I simply opted for a quick and dirty approach by covering a single sided copper clad pcb with permanent marker and scrapped the areas I wanted etched with a scalpel.

Size comparison to a US quarter.

Man its hard taking pictures of something so small.

All etched and ready to have marker removed with the help of some acetone.

Close ups after soldering in the components with a penny as a reference for size.

I proceeded to test the circuit by hooking her up to a lithium ion battery and measuring voltage and current. Crossed my fingers and held my breath just waiting for a small poof of failure which luckily never came.

Just shy of 4V, looks good.

Charging at around 100mA looks safe.

Finally I needed to desolder (used a hot air gun, Warning: HOT) the USB female jack from the controller board and lift the V+ power pin so it would no longer power the broken internal charge circuitry and instead hooked into my own charger. I had to be quick but gentle with the hot air so I wouldn't damage anything.

Pulled socket and used desoldering braid and some alcohol to clean up a bit.

Cleaned up the socket as well and lifted the V+ pin.

Replaced and soldered down.

Now all I needed to do was solder three wires: ground, V+ in, and battery+.

Battery+ is orange and ground is brown. I used the gnd pad conveniently silk screened for me and plugged the battery in to find the battery+ (red wire on the battery).

V+ in from USB is white and soldered to the lifted pin

Quick test to make sure everything still works. No magic smoke released here.

Taping wires so they wont interfere with the battery. I used some more tape to attach the charging board to the front under the SONY emblem.

Battery inserted.

All put back together and charging status led visible as an orange glow on the front.

Outcome: Success! Now I just need to replace the nubs and I'll have a good as new controller without having to shell out another fifty or sixty bucks. I already had all the parts so it cost nothing and only took around 2 hours in all. When not charging, the controller looks stock. I feel accomplished and saved a controller from being scrapped. Now I can get back to gaming once it charges up.

Digital Magic 8 Ball

2012-05-08T19:45:00.002-07:00

Is this one of the coolest projects I've made on the spur of the moment?

The magic 8 ball is always correct!

I remember I used to have a magic 8 ball key-chain as a kid. I loved asking it the stupidest questions and seeing it magically divine the answer. Either that or it just repeatedly responded with an anti-climatic ask again later. One day the magic just dried up ... literally, the purple fluid in the cavity evaporated! Randomly remembering this device, I decided on the spur of the moment, after learning how to seed and use the rand() function in the standard c library, to make my very own digital magic 8 ball (which would be impervious to drying up, but still vulnerable to releasing its magic smoke).

I've moved on up from the pic16f84a to the 16f886. I know it is overkill for most of what I use it for, but it is great for prototyping because of the large program memory, abundance of peripherals, and gpio. Plus I love using the internal oscillator for anything that doesn't require an accurate clock.

This is the prototyping breadboard I use for everything with the icsp header in the middle, a built in li-polymer battery on the back and integrated charge controller at the top. Ignore the 8 pin dip rtc above the pic, I might add a clock feature and make my magic 8 ball a watch.

The pic starts counting on start up until the user presses the button. This count value (which in effect is somewhat random) then seeds the pseudo random number generator. The number that it comes up with then determines which of the 20 replies the magic 8 ball will give. When the button is pressed again, the user is returned to the main screen asking for another question.

I ported the code I wrote is assembly for the 16f84a which handles spi serial communication in software (I know I could have done it in hardware, but this way was more fun). Then I needed a function to initialize and clear the ram of the oled display. In addition, I ended up having to write a function which would handle parsing strings and generate the data necessary to write them to the graphical display. I wrote most of this months ago and reused code but for a different application. I haven't really optimized anything but everything works and I am happy with it.

The only way to cheat the system is to hold the button or hit it immediately after the main screen loads, which ensures that the count value would be zero, which when seeded into rand() would produce the same value, which will always give the same reply.

I plan on using smt components, ditching the oled pcb, using a CR2032, and polling another button via interrupt so that I can put the micro to sleep and wake it for software power control. The entire device should be not much larger than the 3cm oled (aka perfect as a key-chain). I might think of using an accelerometer or tilt switch and put the oled in the window of an actual magic 8 ball. It would look really cool glowing eerily from the surrounding dark window, magically predicting the future. Might add a clock and fit the entire device to a watch strap so I can wear it around, tell time, and make life altering decisions with it. Maybe I'll add some simple games. Who knows? Either way it will be a great gift for my sister.

Ok ... there's one more question I need to ask it ... magic 8 ball ... will I ever become a famous electrical or computer engineer?

.................................................

... fine then if you don't want to answer me, who needs you anyway ...

ps. A friend suggested I also make a miniature 20 questions ... hmmmm interesting ... maybe later ...
pps. Since summer is here expect many more projects :-)
ppps. I might make a digital fortune cookie with hundreds of different fortunes. Not too hard if I reuse most of my current code.

Here are the C and hex files for the project: Magic 8 Ball files.

Update: Added Schematic

If you have any questions feel free to shoot below. Enjoy

POV display v2.0

2012-02-20T14:01:00.000-08:00

Major Update: Its been awhile since I started this rebooted attempt at a POV display. Since then I've moved on up to the pic16f886 and etched a smd pcb for the controller. Here are some pics and a test video with some more explanations. I'm hard at work coding software for it now that the hardware is almost complete. More to come.

Home etched board. I drew the traces with a fine tipped permanent marker.

Another view.

All soldered and ready to program the firmware over the in circuit serial programming header.

Everything secured and wired up. Note the penny I am using to balance the rotor.

First test is a success!

Looks even cooler in the dark.

Update: I've finally gotten around to coding a full character set, string manipulation, and scrolling text animation. Unfortunately I'm heading back to university and wont get to touch this project until winter break. I will keep up churning out software projects though (its the only thing that keeps me sane between classes). Plus when I get settled I will start up TeardownTube episodes again. Don't worry I have a lot planned.

Diy Portable video projector

2011-10-13T07:58:00.000-07:00

My newest project is to build a pocket sized, battery powered portable video projector that accepts a standard composite input. It all started when I received an old jvc (circa 1998) vhs camcorder with a tiny color lcd viewfinder. I took it apart and started hacking it. I quickly found the composite input to the display driver but was unable to get the screen to accept input without tethering it to the camera's main board (which told me that the camera was somehow initializing the driver board for the display). I powered the screen with 12V and 5V but nothing happened without connecting three specific wires to the mainboard. Time went by and I decided to pick up the project again recently. I once again noticed the group of three wires that seemed fishy so the first thing I though was SPI. I looked up all the data sheets and traced these three to the Mitsubishi M62353FP which is a 8 channel DAC and confirmed that they were three wire SPI thanks to the datasheet. The outputs led to some inputs for the display driver (Sony CXA1854AR) which controlled color, contrast, etc. I tried sniffing the data that was coming from the camera's mainboard with my PICKIT2's logic tool, but it didn't make much sense. Instead I measured the analog voltages on each of the DAC's outputs, calculated the binary values using a formula from the datasheet and wrote up a driver for my PIC which sends a four bit address (for each of the 8 outputs) followed by the 8 bit output value. I wired everything up, plugged it in and everything worked like a charm (well colors are a bit washed out but that can be fixed by adjusting the software a little). So now onto making the optics for the projector.

Here's a shot of the tiny LCD (Sony LCX005BK). Pretty low resolution but it was free so I wont complain.

Here is the backlight. High voltage and not so bright so it needs to go.

This is the other side of the backlight. Note the step up transformer and switching mosfet.

Finally here is where I am at right now. I am running it all off of a 12V wallwart, using a LM7805 linear regulator for the 5V line (when I go to make this battery powered I will use a lithium rechargeable battery and a TI step up converter module to get the 12V). My PIC is on the right (with a little development board I made to make things easier) with code to set display values. I plan on adding buttons to allow the user to change brightness, contrast, saturation, etc on the fly. On the left is the display driver. and I attached a 1W white led as a replacement for the original backlight.

Sorry about the blurry display shots, photographing a .5" lcd is a lot more difficult than it would seem.

Full set up with my ipod outputting video. More to come soon.
datasheets available below:
CXA1854AR
M62353FP

Update! Working on optical assembly and took some test photos of video projection.

Here's my test setup with the optical assembly and projection lens in the center.

Picture of projection (about 10" or so) onto a glossy white screen in my room with blinds shut but lots of light seeping in.

Had to drag the setup into my bathroom to get a completely dark background. Once again image is around 10". I noticed that I nicked the lcd's polarizing filter a bit and that there are some dead/stuck pixels in the screen which show up in the image. Oh well, I got all the parts for free and this is merely a proof of concept so I don't really care.

Update: Made tons of progress on this project. Demo video below and pictures and explanation to come.

Sandisk Sansa Clip+

2011-10-13T07:27:00.000-07:00

Controlling a nokia5110 lcd with software SPI on a pic16f84a

2011-05-24T18:29:00.000-07:00

My newest project has been implementing a software SPI routine so that my pic (which lacks hardware SPI) can communicate with a cheap nokia 84x48 graphical lcd (later I will show how I wired it up). I've written subroutines in assembly for setting x,y address of the lcd's ram as well as sending data or commands for initialization (8bit, but could be easily modified to work with 9bit color lcd protocols I've seen). I plan on using a look up table to store standard character hex data so that I can make things easier for myself in upcoming projects. I know that my code is pretty inefficient so I plan on fixing it a little later (but not bad for just reading the datasheet and a few hours of coding). I just have the mcu writing "Hello World!" and drawing a video game character sprite at the bottom (I converted the image by hand, but I could easily write a program to do that for me). This is just the beginning, I plan on using this, as well as everything else I've been working on in my projects to come. I plan on adding the ability to animate/scroll text and images and will update the site with the code once I get the chance. I also plan on describing the SPI protocol and lcd commands in detail. For now I will post the code to just write "Hello World" and draw a sprite.

Start    BSF 03h,5         ;switch from bank 0 to 1

    MOVLW b'00000000' ;Out RB to output
    MOVWF 06h
    MOVLW b'00000'       ;Out RA to output
    MOVWF 05h

    BCF 03h,5          ;switch from bank 1 to 0
;RB0=sclk
;RB1=sda
;RB2=D_C
;RB3=Sce
;RB4=reset
;RB5=disp pwr
Begin
    bsf 06h,3 ;disable serial
    bsf 06h,5 ;power on display
    nop
    bcf 06h,4 ;reset
    nop
    bsf 06h,4 ;release from reset

; sel extended instruction set (h=1)
    movlw b'00100001'
    movwf 0Ch
    call spi_command

; set Vop (Contrast)
    movlw b'10111001'
    movwf 0Ch
    call spi_command

; sel normal instruction set (h=0)
    movlw b'00100000'
    movwf 0Ch
    call spi_command

; display normal mode
    movlw b'00001100'
    movwf 0Ch
    call spi_command

;---------------------------

; draw H
    movlw b'01111111'
    movwf 0Ch
    call spi_data
    movlw b'00001000'
    movwf 0Ch
    call spi_data
    movlw b'00001000'
    movwf 0Ch
    call spi_data
    movlw b'00001000'
    movwf 0Ch
    call spi_data
    movlw b'01111111'
    movwf 0Ch
    call spi_data

call _space

; draw e
    movlw b'00001110'
    movwf 0Ch
    call spi_data
    movlw b'00010101'
    movwf 0Ch
    call spi_data
    movlw b'00010101'
    movwf 0Ch
    call spi_data
    movlw b'00010101'
    movwf 0Ch
    call spi_data
    movlw b'00001100'
    movwf 0Ch
    call spi_data

call _space

; draw l
    movlw b'00000000'
    movwf 0Ch
    call spi_data
    movlw b'01000001'
    movwf 0Ch
    call spi_data
    movlw b'01111111'
    movwf 0Ch
    call spi_data
    movlw b'00000001'
    movwf 0Ch
    call spi_data
    movlw b'00000000'
    movwf 0Ch
    call spi_data

call _space

; draw l
    movlw b'00000000'
    movwf 0Ch
    call spi_data
    movlw b'01000001'
    movwf 0Ch
    call spi_data
    movlw b'01111111'
    movwf 0Ch
    call spi_data
    movlw b'00000001'
    movwf 0Ch
    call spi_data
    movlw b'00000000'
    movwf 0Ch
    call spi_data

call _space

; draw o
    movlw b'00001110'
    movwf 0Ch
    call spi_data
    movlw b'00010001'
    movwf 0Ch
    call spi_data
    movlw b'00010001'
    movwf 0Ch
    call spi_data
    movlw b'00010001'
    movwf 0Ch
    call spi_data
    movlw b'00001110'
    movwf 0Ch
    call spi_data

call _space

; goto y=1,x=0
    movlw b'00000001'
    movwf 0Ch
    movlw b'00000000'
    movwf 0Dh
    call setxy

; draw W
    movlw b'01111110'
    movwf 0Ch
    call spi_data
    movlw b'00000001'
    movwf 0Ch
    call spi_data
    movlw b'00001110'
    movwf 0Ch
    call spi_data
    movlw b'00000001'
    movwf 0Ch
    call spi_data
    movlw b'01111110'
    movwf 0Ch
    call spi_data

call _space

; draw o
    movlw b'00001110'
    movwf 0Ch
    call spi_data
    movlw b'00010001'
    movwf 0Ch
    call spi_data
    movlw b'00010001'
    movwf 0Ch
    call spi_data
    movlw b'00010001'
    movwf 0Ch
    call spi_data
    movlw b'00001110'
    movwf 0Ch
    call spi_data

call _space

; draw r
    movlw b'00011111'
    movwf 0Ch
    call spi_data
    movlw b'00001000'
    movwf 0Ch
    call spi_data
    movlw b'00010000'
    movwf 0Ch
    call spi_data
    movlw b'00010000'
    movwf 0Ch
    call spi_data
    movlw b'00001000'
    movwf 0Ch
    call spi_data

call _space

; draw l
    movlw b'00000000'
    movwf 0Ch
    call spi_data
    movlw b'01000001'
    movwf 0Ch
    call spi_data
    movlw b'01111111'
    movwf 0Ch
    call spi_data
    movlw b'00000001'
    movwf 0Ch
    call spi_data
    movlw b'00000000'
    movwf 0Ch
    call spi_data

call _space

; draw d
    movlw b'00001110'
    movwf 0Ch
    call spi_data
    movlw b'00010001'
    movwf 0Ch
    call spi_data
    movlw b'00010001'
    movwf 0Ch
    call spi_data
    movlw b'00001001'
    movwf 0Ch
    call spi_data
    movlw b'01111111'
    movwf 0Ch
    call spi_data

call _space

; draw !
    movlw b'01111101'
    movwf 0Ch
    call spi_data

;---------------------------
; goto y=5,x=0
    movlw b'00000101'
    movwf 0Ch
    movlw b'00000000'
    movwf 0Dh
    call setxy
;draw image block 4
    movlw b'10000111';1
    movwf 0Ch
    call spi_data
    movlw b'11111101';2
    movwf 0Ch
    call spi_data
    movlw b'10000001';3
    movwf 0Ch
    call spi_data
    movlw b'01100001';4
    movwf 0Ch
    call spi_data
    movlw b'00010001';5
    movwf 0Ch
    call spi_data
    movlw b'11001001';6
    movwf 0Ch
    call spi_data
    movlw b'00100101';7
    movwf 0Ch
    call spi_data
    movlw b'00100101';8
    movwf 0Ch
    call spi_data
    movlw b'11100001';9
    movwf 0Ch
    call spi_data
    movlw b'00011001';10
    movwf 0Ch
    call spi_data
    movlw b'00000101';11
    movwf 0Ch
    call spi_data
    movlw b'00000011';12
    movwf 0Ch
    call spi_data
    movlw b'00000011';13
    movwf 0Ch
    call spi_data
    movlw b'00000001';14
    movwf 0Ch
    call spi_data
    movlw b'00111001';15
    movwf 0Ch
    call spi_data
    movlw b'11101101';16
    movwf 0Ch
    call spi_data
    movlw b'00000111';17
    movwf 0Ch
    call spi_data

; goto y=4,x=0
    movlw b'00000100'
    movwf 0Ch
    movlw b'00000000'
    movwf 0Dh
    call setxy
;draw image block 3
    movlw b'00000111';1
    movwf 0Ch
    call spi_data
    movlw b'00111100';2
    movwf 0Ch
    call spi_data
    movlw b'01100100';3
    movwf 0Ch
    call spi_data
    movlw b'01010011';4
    movwf 0Ch
    call spi_data
    movlw b'11110000';5
    movwf 0Ch
    call spi_data
    movlw b'00111000';6
    movwf 0Ch
    call spi_data
    movlw b'11111001';7
    movwf 0Ch
    call spi_data
    movlw b'11111011';8
    movwf 0Ch
    call spi_data
    movlw b'10010011';9
    movwf 0Ch
    call spi_data
    movlw b'11110100';10
    movwf 0Ch
    call spi_data
    movlw b'11110100';11
    movwf 0Ch
    call spi_data
    movlw b'01110100';12
    movwf 0Ch
    call spi_data
    movlw b'01110000';13
    movwf 0Ch
    call spi_data
    movlw b'00010000';14
    movwf 0Ch
    call spi_data
    movlw b'00100100';15
    movwf 0Ch
    call spi_data
    movlw b'10011111';16
    movwf 0Ch
    call spi_data
    movlw b'11010000';17
    movwf 0Ch
    call spi_data
    movlw b'01110000';18
    movwf 0Ch
    call spi_data

; goto y=3,x=0
    movlw b'00000011'
    movwf 0Ch
    movlw b'00000000'
    movwf 0Dh
    call setxy
;draw image block 2
    movlw b'00011100';1
    movwf 0Ch
    call spi_data
    movlw b'00010110';2
    movwf 0Ch
    call spi_data
    movlw b'00010010';3
    movwf 0Ch
    call spi_data
    movlw b'00010010';4
    movwf 0Ch
    call spi_data
    movlw b'00010011';5
    movwf 0Ch
    call spi_data
    movlw b'00010001';6
    movwf 0Ch
    call spi_data
    movlw b'00110001';7
    movwf 0Ch
    call spi_data
    movlw b'00100000';8
    movwf 0Ch
    call spi_data
    movlw b'01100000';9
    movwf 0Ch
    call spi_data
    movlw b'01000000';10
    movwf 0Ch
    call spi_data
    movlw b'11000000';11
    movwf 0Ch
    call spi_data
    movlw b'10000000';12
    movwf 0Ch
    call spi_data
    movlw b'00000000';13
    movwf 0Ch
    call spi_data
    movlw b'00000010';14
    movwf 0Ch
    call spi_data
    movlw b'00011111';15
    movwf 0Ch
    call spi_data
    movlw b'01110001';16
    movwf 0Ch
    call spi_data
    movlw b'11000000';17
    movwf 0Ch
    call spi_data

; goto y=2,x=12
    movlw b'00000010'
    movwf 0Ch
    movlw b'00001100'
    movwf 0Dh
    call setxy
;draw image block 1
    movlw b'00000001';12
    movwf 0Ch
    call spi_data
    movlw b'00000001';13
    movwf 0Ch
    call spi_data
    movlw b'00000011';14
    movwf 0Ch
    call spi_data
    movlw b'00000010';15
    movwf 0Ch
    call spi_data
    movlw b'00000010';16
    movwf 0Ch
    call spi_data
    movlw b'00000011';17
    movwf 0Ch
    call spi_data

a goto a

;----------------------------

spi_command
    bcf 06h,3 ;start serial transmission
    bcf 06h,2 ;D_C=0
        btfss 0Ch,7
        goto c1
        call one
        goto c1n
    c1    call zero
    c1n    btfss 0Ch,6
        goto c2
        call one
        goto c2n
    c2    call zero
    c2n    btfss 0Ch,5
        goto c3
        call one
        goto c3n
    c3    call zero
    c3n    btfss 0Ch,4
        goto c4
        call one
        goto c4n
    c4    call zero
    c4n    btfss 0Ch,3
        goto c5
        call one
        goto c5n
    c5    call zero
    c5n    btfss 0Ch,2
        goto c6
        call one
        goto c6n
    c6    call zero
    c6n    btfss 0Ch,1
        goto c7
        call one
        goto c7n
    c7    call zero
    c7n    btfss 0Ch,0
        goto cd
        call one
        goto cdn
    cd    call zero
cdn    bcf 06h,0
    bsf 06h,3 ;end serial transmission
return

spi_data
    bcf 06h,3 ;start serial transmission
    bsf 06h,2 ;D_C=1
        btfss 0Ch,0
        goto b1
        call one
        goto b1n
    b1    call zero
    b1n    btfss 0Ch,1
        goto b2
        call one
        goto b2n
    b2    call zero
    b2n    btfss 0Ch,2
        goto b3
        call one
        goto b3n
    b3    call zero
    b3n    btfss 0Ch,3
        goto b4
        call one
        goto b4n
    b4    call zero
    b4n    btfss 0Ch,4
        goto b5
        call one
        goto b5n
    b5    call zero
    b5n    btfss 0Ch,5
        goto b6
        call one
        goto b6n
    b6    call zero
    b6n    btfss 0Ch,6
        goto b7
        call one
        goto b7n
    b7    call zero
    b7n    btfss 0Ch,7
        goto d
        call one
        goto dn
    d    call zero
dn    bcf 06h,0
    bsf 06h,3 ;end serial transmission
return

zero
    bcf 06h,0
    bcf 06h,1 ;0
    bsf 06h,0 ;sclk pulse
return

one
    bcf 06h,0
    bsf 06h,1 ;1
    bsf 06h,0 ;sclk pulse
return

_space ;send byte='00000000', draw space
    movlw b'00000000'
    movwf 0Ch
    call spi_data
return

setxy
    bsf 0Ch,6
    call spi_command
    bsf 0Dh,7
    movf 0Dh,0
    movwf 0Ch
    call spi_command
return

end

Capacitive Touch Sensor for pic16F84A (no special hardware required)

2011-05-10T16:15:00.000-07:00

Here is my newest project I've been working on. I'll get more details up when I have the time. In the mean while enjoy the video.

Update: Sorry its been awhile since my last update. I've been busy with work and my other projects. The capacitive sensing input is really simple because everything is done in software. Here's my hand drawn schematic for the input stage generalized so that any mcu can be used (For some reason I haven't yet installed a schematic program on my netbook and I don't feel like booting up my other laptop).

It's amazing that all you really need is a single gpio and a resistor (the capacitance is provided by the traces on the breadboard). The ten megaohm resistor allows the discharge rate for the stray capacitance to be slowed down enough for the uC to measure. The uC just continually charges up this capacitance, puts the pin into high impedance by making it an input, and then counts until it measures the "capacitor" is discharged. This count can then be analyzed to determine if the pin has been pressed or not (the count increases if the button is pressed because your finger adds to the stray capacitance in parallel which increases the discharge time). That's pretty much all that's necessary other than some fancy algorithms for error proofing detection.

Update 2: I've finally gotten around to porting my capacitive touch sensing code to C. The code should work for most PICs and can be easily modified to change pin assignments and whatnot to work on any other chip you might need. Below you will find the function freqcapsense. All you need to do is call it and it will sense whether RA0 is being touch or not. I've included averaging multiple samples and an adjustable threshold in order to tweak the sensitivity and accuracy for any given setup. You can have it return a 1 or 0 for touch status or by commenting out the if else statement at the end and uncommenting the return current statement it will return the raw period value it is reading from the pin. Enjoy.

int freqcapsense(){
    unsigned int avg;
    unsigned int current=0;
    unsigned int thresh=29;

    unsigned int trials=10;

    while(trials>0){
        TRISA=0b0;
        RA0=1;
        delay();
        TRISA=0b1;
        while(RA0==1){current++;}
        trials--;
        avg=(avg+current)/2;
    }

if((current-avg)>thresh){return 1;}
else{return 0;}

//return current;
}