Coffee, bits and bikes

OpenTherm v2 First Prototype

2012-01-28T22:28:00.004+01:00

I finaly built a prototype of the opentherm interface (version 2) for Alex to test, since he dosen't have all the tools to test it I'm hoping that at least the physical interface works, the other features are powered through the interface and using a supercapacitor to hold the power during radio transmission.

The board has a JeeNode interface so Alex doesn't have to change much, there are two extra jumpers, one connects the opentherm rectified voltage to the PWR input of the jeenode, and the other connects the 3.3V output of the jeenode to a supercap. It is still a bit oversized but... Well it is a prototype... The OpAmp is the LM358 (dual version of the quad LM324), works from 3V to 33V and it is relatively low power. The specification of Opentherm states a open voltage of 40V so I had to protect the OpAmp with a parallel Zener (seen in the picture).

A lot has to be done on the jeenode side, but it is mostly software regarding the power saving modes and saving enough power before the short bursts of radio transmission. The schematics of this circuit is based on the published before, but I'll hold the final one until Alex gives me feedback.

OpenTherm Interface V2

2012-01-16T17:07:00.000+01:00

As I mentioned when the boards arrived, I'm planning a new board/circuit but I just briefly mentioned it.
Alex pointed out that in the OpenTherm specification it is stated that a master unit, i.e. your thermostat in the living room or a controller (in Alex's case), could be powered by the interface (use google to find the specification).

In the OpenTherm specification the boiler is slave (although providing the current loop) and the master is the remote control unit. He asked me if it could be done, and looking at the first schematic I drafted a battle plan:

get rid of the dissipative receiver resistor;
get rid of the dissipative transmission resistor;
get rid of the optocouplers, (isolation is good and desired but CTR isn't very good for cheap opto's... hence more current).
with whatever power is available, use a LDO and power something.
Design a current loop transmitter (4-17mA)for testing that works at 40V.
Design a two level shunt regulator for transmitting from master to slave.
Design a minimal loss current loop receiver with output to 3.3V logic systems.

The mains issues were, the maximum loop voltage of 40V and the low voltage LDO and digital signals (3.3V)... and size since Alex want's a "shield" for his JeeNode. There aren't many IC's that work at 40V...

I have planed a tribute post to Jim Williams and Bob Pease playing around analog computers, but time hasn't allowed it... so this short one goes to them and to Bob Widlar.

First I had to design the current loop transmitter to test the system, the input had to be 40V so that under lower load the output voltage was close to that (part of the OpenTherm specification). I remembered the LM10 (designed by Widlar) had an interesting feature in it's datasheet, it is the only OpAmp I know that has been specified for shunt operation (Dear TI that page says "all national products now are belong to us" in front of the datasheet is .... lame).
It also had a application schematic for a current controller, I modified that schematic to allow a push-button (4-20mA) switch (for those not able to find the LM10 check here for an alternative way to generate the current loop, replace DAC with voltage generator).

Then was the master transmitter, basically a shunt regulator with two levels, inactive 7V and active 15V. I used two diodes in series as the reference to the minimum voltage for the regulator, there's a hell of thermal drift but I don't expect the temperature to move outside the range 16C-40C with a corresponding error of 120mV and respective change of about 600mV, therefore negligible. Also I added the push-button to change from one state to the other. I thought of using the same LM10 but unfortunately the LM10 is too slow even for the 2kHz output waveform (it is 1kHz manchester encoded), so the next big thing in single supply opamps capable of 30V operation is the quad LM324, I've used the double LM358. They have their problems in precision and audio circuits but they're good enough and fast enough for the job.

Finally I designed the receiver, the current loop receiver was a nice exercise. I used a simple linear converter to adapt the current levels at the current sense resistor to voltages of less than 0,7V (4-9mA) for the low level and greater than 2,0V for the high level (20mA). One interesting point one is that even single supply amps can work with negative voltages as long as the output is within specification and the voltage at the pin is not negative.

And that's it, I just need to wire a small pref board and send it to be tested.

New Boards arrived!

2012-01-12T19:32:00.007+01:00

This time is the PCB of the Opentherm Interface (v1.0) for Alex and his JeeNode and my Jam Jar Firefly simulator.

The round ones are the JamJarFirely and the rectangular is the JeeNode interface. We've sent them to be produced by Lean, there were some delays but eventually we got them.

Alex mentioned that the Opentherm interface mentions having a loop powered Master and Alex wanted to try and do it with JeeNode. I thought about a version two.
I think that I have the hardware ready but surely a lot has to be done in the jeenode side in terms of software, there are only about 25mW available permanently (about 5V@5mA).
This is my first attempt, I've still just tested it on the breadboard but I think it will work. Here is my initial schematic, the LED on the input is a receive indicator and correct polarity indicator (lights dimly when correctly connected and blinks when receiving).

The rest of the circuit is a programmable shunt regulator with two voltages (the transmitter 7V and 16V since the loop is a current source) and a current to voltage converter (receiver).

Change bicycle crank

2011-12-05T17:05:00.009+01:00

Last winter during the two month long ice age I fell of the bike. I got stuck with the front wheel on a hiden tram track (under the snow I missed it). The fall was quite hard and one of the pedal crank arms on the Kronan got bent.
Since during the summer I've been taking Luísa on the Batavus and the Kronan was "ridable" I let it linger for a long time... and after much procastination and "planning" I decided to order online and replace the cranks myself.

There are several tutorials on the net (one here), and what is definetely needed in a crank removal tool and special recessed nut wrench, all the other tools are common workshop tools.
First remove the plastic cap hidding the bolt, then use the special recessed bolt wrench and remove this bolt.

The insert the crank removal tool in the crank nut and turn the extractor bolt, this will slowly move the crank arm out of the axel.

Then just remove the crank arm and remove the pedal (just the crank arm was bent, the pedal was unharmed).

Remove the pedal with a wrench.

Put in the new crank arm, screw in the fixing bolt and the old pedal, repeat for the other side and voila!

And now I'm ready for the harsh weather with the Kronan again...

Luísa is two!

2011-12-01T22:01:00.004+01:00

Luísa is two today...

We picked her up early from the daycare... she was not "thrilled" when we woke her up in the middle of her afternoon nap...
Well, we managed her to wave (reluctantly) after a few seconds... (Only after she insisted on getting on the bike :-)

TI Launchpad

2011-11-11T23:11:00.001+01:00

Recently I've been trying to do battery powered devices and I came to the conclusion that there is more to it than you first think.
My experience with the Bird-O-Matic is that it each battery lasted only 25% of what I had planed. There were some options that might have influenced it:

I didn't made an OFF timer, once the PIR detects an warm object it turns ON the MP3 player and the Amplifier for some time (7-10 seconds), placing a forced OFF timer of 20-30 seconds would prevent constant re-triggering every time someone passes by.
Was the use of a CMOS 555 better than a micro-controller? Today's controllers consume almost nothing in standby or power down mode, and a wake up on pin changed could be used with the PIR.
The external MP3 player consumes a lot of power and takes 1-2 seconds to start up. It was the simpler and fastest solution, but not the best for power saving.

Recently I read about the MSP430 ultra low power capabilities and I wanted to try them out. The Texas Instruments Lauchpad let's you do just that at a very low price (about 10EUR) and a big Windows installation (see here). I admit I'm always very reluctant to install windows software but unfortunately these links for installing in Linux didn't work out.

It is a bit sad, but I'm no sysadmin and no I don't know perl and I don't want to lose time learning perl, to correct a script, to install a msp430-gcc, to program devices... I understand the technical difficulties behind maintaining and supplying a gcc distribution (specially if also sell a payed tool), but nowadays it is becoming a "must". Sounds like when AMD started giving away PALASM... suddenly every PLD manufacturer started doing it or... went out of business..
After installing the correct tool (the free version is not the latest version), I followed the start up guide and sure enough I made my first C program.
The tool is simple and powerful (based on eclipse), in Windows everything works mostly out of the box.

The board is "divided" into a emulation tool and the experimenter board where devices of 14 and 16pins can be connected. There's also the option of soldering (an included) SMD low-power crystal oscillator. Instructions are also provided on how to measure the power of the experimenter processor, although it is tempting do not cut the board through the dashed lines.. it will not work as a MSP-ISP... that's another tool. (but I guess removing the jumpers and direct connection is ok :-).
The processor although a 16bit simple RISC architecture does appear to be quite capable, I just tried out a couple of examples in C. This though is not what I want to try out... I want to see if the operating current is as low as "advertised", but that will have to be for a another post.

Christmas Ball (the 11.11.11 post)

2011-11-11T17:09:00.011+01:00

It is a bit late to announce but we won a prize!!!

Huyser bookstore in Delft ran a competition to promote the book from Arne and Carlos "55 Christmas Balls to Knit", see the promotional video here. Just before the deadline (1.11.11) our son Daniel was born, but we managed to find time to finish the Ball and submit it.
Naturally Ana chose a pattern and knitted the ball, I took care of the electronics. We were so late entering the competition that we only have "night shots" before submitting the ball...

It is a simple ATTiny15L powered with 3x AAA alkaline batteries.
There are 4 LEDs connected to the ATTiny, each in one of the reindeer's nose.
I've made a 32bit pseudo random number generator with a LFSR. The ball to lit is randomly picked (1..4) and also the fade-in time (1-2sec), fade-out time (1-2 sec) and off-time (2..4 x 2.5sec i.e. number of watchdog cycles).
The average measured power consumption is 1.5mA so one can expect about 1000 hours of operation from 3 standard cells.
(click on the circuit for a better view)

The schematic is not exactly this one, this is for another project that hopefully will come out before Christmas, just remove the solar charger, the voltage measuring and that's it!
We got the third prize, 100EUR in books!!!

Balcony Crop 2011

2011-10-07T22:43:00.007+02:00

Winter is coming and I almost forgot...
This year crops were not better than last year, and considerably less than the first year, the ground in the vases is getting "worn out" and too compact so vegetables that grow in the ground (carrots and turnips) don't grow that much.

Still we managed one (yes, only one) bowl of steamed vegetables (150g). This year Luísa helped picking up the carrots.
The "top of the crop" goes to the turnip followed by the micro-carrot.

Unfortunately, the beetroot did not survive the very dry and hot spring followed by a damp and lousy summer...
I'm now awaiting for everything in the vases to dye out and then I reinforce the soil or change it all together...

FireFly Jam Jar

2011-09-28T23:33:00.008+02:00

I wanted to build a night-lamp for Luísa, something a bit less "spooky" than a blue IKEA Spöka that she has. I also wanted to be able to charge just by placing it in the sun (even there isn't much of that up here)...
I went back to my stack of old ATTiny15L and designed a circuit with four LEDs connected in a particular way that only used 3 pins to lit each of them. The other two measure external light (light on when it is dark) and battery (low bat... do nothing be very very still).
I got some jam jars and some Yellow/Amber LEDs and started programming, for the battery I selected a 3.6V 50mAh NiCad (i.e. junk hanging around) and the battery charger was a two transistor current limiter but after some tries I settled with a simple schottky diode from the panel to the battery.

The idea of the project is that when night falls (or lights out) the light goes on for about an hour hopping from one light to the other with different ratios of fade-in and fade-out. This hopefully will induce a sleepy feeling (like candles... by the way.. simulating four candles is also possible)
The schematic is the same as for the reindeer ball project, but this time I went "all the way" to a PCB FAB. I still have to wait for it to come but it looks nice in the preview.

It is my first "non-rectangular" board and actually my first milled board. We'll see how this project will look like in the end...

Alex OpenTherm interface for JeeNode

2011-09-28T23:19:00.010+02:00

Alex requested a "quick and dirty prototype" for his Opentherm JeeNode interface. He has more details on the "substance" here and here. I just made the boards, it is all his design (boards plural, the first one was wrongly mirrored, b.t.w. it is the wrong one you see on the pictures).
I followed the usual toner transfer method, and just works, HEMA photo paper is the best! The second board is not so pretty.... but at least it is correct (no photos of this one though).
The schematics are on Alex's site but here's my second try at the schematics also:

Here a detail of the board where you can see some "over etching":

Bird-O-Matic

2011-09-28T23:16:00.012+02:00

Pedro asked me, some time ago, to do a collaboration project with a good friend of his.
The idea for the installation art project was the story "The Nightingale" from H.C. Andersen, the idea was to build/make a talking bird of sorts. Our initial plans had to change somewhat substantially... here's what we did:

My part, was to design and build the electronics that would "make the bird sing", we already had the bird's voice in a mp3 track (a danish Nightingale!!), we just needed something to play it. The original idea was to have a bird (just like in the story), but one of the places was an open air installation, so a bird cage seemed a better option.

The first constrain was time, we had only two months for doing the first "bird-o-matic". We gathered a PIR Sensor, a MP3 Player, and a LM386 amplifier IC from Solarbotics.
We wanted a reasonable sound volume so we chose a 9V battery to power the circuit, this is challenge because these batteries do not have a big capacity (max about 1000mAh) and we still wanted to play for some time without replacing the battery. This also excluded from the start using an Arduino as they consume a lot of current even if you manage to put it in standby.
I decided to use a simple monostable (LMC555) triggered by the PIR sensor that would activate the MP3 player and amplifier for a reasonable time (enough to play the nightingale sound). I used low-power MOSFETs for the power switching and one as inverter.
The first build used a LM78L05 but these have a very high quiescent current (~4mA), 10x more than the PIR sensor alone(~350uA)! The second choice was the LM2950 with only 40uA without load (increases to about the double with load) The LMC555 also has a lower quiescent current when operated at 5V (100uA) when compared to 9V (~160uA), and orders of magnitude lower than his "high power" counterpart the LM555.
Still the total current in standby was lower that 600uA, this would give 2000 hours in standby!
Playing... well "you can't make an omelet without breaking some eggs", the MP3 player consumed about 80mA and the LM386 another 80mA, giving a total play time of about 6 hours, still quite good if you think that the track was only 20 seconds... that is about 1100 times... it also exceeds the LM2950 maximum current by 50% but it works until it is too hot then the thermal shutdown "kills the bird" (battery saving on the cheap).
Here is the schematic:

Here is a close up of the inside of the bird cage:

Here a photo of the first prototype:

New Boards arrived!

2011-09-16T19:29:00.003+02:00

A month or so ago I bought a development kit of GreenPak from Silego. The parts appear to be very powerful for simple control tasks, I have a small Switch Mode Power Supply project but I wanted to try it out on a breadboard before committing to a full PCB.
The parts are tiny tiny and an adapter to DIP 8 was needed. I sent my mini design to lean and my boards are here! Here's the result!

We're back!

2011-08-01T22:09:00.005+02:00

Sorry all, we've been on Holidays and now we're back.

I have a couple of projects going on but one is "secret" and the other is... trash... I'm trying to make art out of trash (or making less valuable trash out of more valuable trash).
The secret is something for my loved one (that's why it is secret), the trash one is a mini-wind generator, another of the projects involves LEDs, batteries, Solar cells and a jam jar and some other bits and pieces... Something like this.

I've noticed that postings are running low, at one per month.. I'll try to increase that this month to two... as any statistician would tell you, "it's a 100% increase"!! (and this one doesn't count, I promise!)

Some other projects in my head are around analog electronics, I've studying a lot of transistor circuits (band-gaps, differential pairs, current sources) and special op-amp circuits (integrators, analog computers). I'll try to post something on the matter later.

I've been unable to stick with the "cult of done" motto, 15 days is almost nothing in my development cycles. I have a lot of "diaper change" in between and it's hard to get some spare time during the week.

Meanwhile I also lost my beloved Rotring Quattro... two months after the blog post! Now I can't get used to the new one... it was my precious... I got a "cheap" (read not cheap) Parker Multi-pen Executive for replacement... The Lamy 4pen only comes with a 0.7mm pencil and I can't write with those, they're just too thick, kind of grocer's pencil...

Well back to work and I'll write soon..

SBC6120 with a teletype

2011-07-02T23:06:00.003+02:00

Recently I bought a Teletype (a Texas Silent 700 model 703), it is special as it uses thermal paper and it is surprisingly silent :-).

I installed the light guides on the SBC6120 indicators, so now they are much more visible.

I had to replace an internal dip-switch and find a power supply for it, unfortunately I could not find a suitable power connector, for now it is connected with a pair of crocodile clips. The power input is AC-Earth-AC and a suitable voltage is from 20V to 26V, the current is about 1.5A.

The serial connection is at 300Baud surprisingly slow... 30 cps... This was how computers were operated before there were VDU (or CRTs as you prefer), it is very interesting. Next I'll try to install the Adventure game... The serial cable that came with the machine had to be tweaked in order to make it work with the SBC6120.

Here is a clip of theSBC6120 booting connected to the TI Silent.

SBC6120 - Project Done!

2011-05-09T21:57:00.010+02:00

It is done! My SBC6120 finally has a case that I am proud of. It still needs some finishing touches (namely some light pipes for the LEDS on the board to the front panel), but that's about it.

Since I haven't used it for quite some time I forgot some of the "intricate" details of working with it:
- I lost an incredible amount of time in a hardware bug that did not exist, simply because I forgot that the communication interface is 9600-7E1 and NO handshakes (hardware or XON-XOFF)... Minicom in linux installs default with hardware handshake, you see the boot message but you cannot write anything...
- and OS/8 only works with CAPITALS... (This is not a MAC OS8!, Mac friends look elsewhere).
To fit everything inside the Hammond box, I built a base in 1.5mm plastic and glued nylon screws upside down, these would fix the SBC on the lower part of the case, I've built a power supply board to convert 12V in the 5V needed for the SBC, finally I designed custom front and back panels.
I've built four prototypes of the front panel (in paper) and glued them to 2mm thick foam to get a look and feel of the panels before committing to fabrication. I used the services of Schaeffer AG for milling the front and rear panel, their (freely distributed) CAD program is actually very nice and it is available for linux! (I had some problems with sending the design but the drawing was actually all done in linux). It isn't cheap, but sure is top-quality.

The reset button does not protrude to the external of the box as intended, but having a "insert pencil here to reset" hole is not so bad (might even be a feature :-). Here you can also see why there's a need for a light pipe.

The slots in the back are enough for cooling the SBC6120 and the 3.5'' IDE drive, it takes about six hours to serially download two disk images, the boards and case never exceeded ambient temp by more than 20C.

The whole case is quite small (for a PDP-8), here's a top view, a fair view of what's inside is in an older post and here. The paper sheet below is A4 size.

The final photo just like in Sparetimegizmos is my the SBC6120 with an HP-16C side-by-side, just like the "inspirational photo" from their site. Yes, the calculator is more expensive than the computer :-).

Next... Install some adventure games... like this one... :-)
what's the use of a computer other than entertainment....

The Calculator is dead, long live the Calculator...

2011-04-10T18:13:00.005+02:00

My eyesight problem triggered a new blog motto... I must stay away from the computer when I'm "dedicated" to my home projects (or at least reduce the time to a minimum).
Here it comes "Never again use a Spreadsheet for designing power electronics"! I must admit that for work it is the best thing available,test scenarios, test components, circuit configurations everything numerical at a touch of a "button". But I don't need that, this is supposed to be for fun. I don't need speed of calculus, I want to keep learning the "Art". From now on calculations will be displayed scanned from the squared paper (I still have to find a scanner though)... And these two will have a bit more work...

Thinking back, how many times did I use a graphics calculator for a graphics problem? I don't remember, but not many...
I did love my HP48 in the last two years of university (before that I had a TI 57 II), I had to work for a while to pay for it and my father helped out with 50%.
Once at an exam, the teacher that saw my Texas classified it as "a Grocer's calculator", that was really embarrassing and this was in 1997!(most of my colleagues had either an 48S, the 48SX or the Casio Computer 850??)...
The HP32S was bought recently in Epay, to get something a bit more "portable" and keep "playing" outside...

Pen Life - Rotring Quattro

2011-04-09T21:10:00.009+02:00

When these pens came out I could not afford them, they costed about 50EUR (in today's money something like 80EUR) and they looked great... Geeky and Engineer like. As soon as I started working and received my first engineering salary I bought one. Recently I found one (new old stock) in Epay... here are the two, side by side, check the differences...

There's another difference that I didn't even remember... when I bought it the finishing was black matte and kind of "rough" or "sand" paint, with 15 years of use that is all gone.
One not so good side of the pen was that the main writing refill would not last long enough (during meetings I tended to write a lot, not anymore though) and the marker pen was "inconsistent" when you wanted it to write. (here's a product review for a product that does not exist)...

New Crops 2011

2011-04-09T19:10:00.005+02:00

Spring is up, time for some new balcony crops! This year, broccoli, turnips and carrots.. They're already sprouting (due to the fantastic weather we've been having in The Hague...
These are my carrots for this year (the clay ball is 1cm diameter).

Just noticed that I need to clean the lens, probably the "little camera devil" touched it...
This is a beetroot that survived the winter.

Hopefully it will grow to "edible" size in these next few months.

SBC6120 - Power Supply Board

2011-04-09T19:09:00.008+02:00

It had been planed for ages, but I never had the time or a technical "consideration" delayed me. I finally decided to just do it (after reading the "cult of done" manifesto), the board with the Laser Toner Transfer and HEMA inkjet photopaper, this was probably the biggest board and with the least detail I've ever done (160x120mm).

The board needed only to fix the connectors, the power switch and a switching power supply. I didn't have much space available on the top side, so I went through my "pile of components" and found a couple of single IC switching power supplies (the National LM2575-5V), I also had a SMD version of it (or so I thought) and some SMD Schottky diodes. The board is also used to mechanically fix the 3.5 inch Harddrive.

The schematic was simple, just the switch, the connectors and the switcher, I added a turn on delay to let everything power up slowly (see the LM2575 datasheet).

The power switch (and the lever) are from C&K, but I had to buy an "old lever" as the new levers are much wider than what I could "afford" in terms of space on the front panel (there's no bezel for this older one though).
For the PCB I had some problems, but mostly mechanical. You can only see them when I show the pictures of the completed unit. I had to fit a 10mm inductor in a 10mm space and a 3.5 inch harddrive in 3.5inch (minus 1mm space, there's a screw on the harddrive I had to remove, otherwise the top would not close.

This is probably the only reason why I'll do boards at home, it must be a big board (>160mmx100mm), few tracks and single side, if it misses one of the tests, I'll go for a Fab. board.
After assembly... it didn't work... A quick trouble shooting revealed the cause... poor eyesight.
I had a LM2595S not the original LM2795 with which I drew the schematic and PCB. The pinout is very different. Then I found out I had no LM2975 SMD version. I had to improvise, a through hole package with bent leads and plenty of flux later...

After that mishap, I mounted everything back up and it worked. I formatted the drive and downloaded a disk image and now my SBC6120 boots!

It was done in two weeks! I'll try to keep this "cult of done" thing going on (but some of the tasks need to be broken in more than a couple of weekends).

Tot Ziens Stuut en Bruin

2011-03-05T20:44:00.005+01:00

Last 26th of February one of the most iconic Electronics shops in the Hague closed its doors after 63 years... Stuut en Bruin you'll be missed. After two months open in 2011 (and some nice IC sales), they finally gave in to modern trends and closed the shop.

The picture above was take on the last Saturday, where the sign "there's still 1 day" was on the window.

Here is the google.maps picture

View Larger Map
We are now left with two other shops that are more focused towards other fields (satelite and consumer electronics and electronic/electric spares).
It is sad... but life goes on...

Chillies in the Wok

2011-02-05T20:46:00.005+01:00

Finally it was time to eat my first chilli of the year! I let my jalapeno/piri-piri hybrid ripe until it was almost all red and then... to the pan with it.

It was not very big nor powerful, but a decent chilli!

Sliced and Wok with it...

Here's the dish next to the little Chilies vase...
Shrimps, Chillies, Peas and Udon noodles in the Wok are always a winning combination... Om nom nom!

SolarLight (9) - Powersaving Software

2011-02-05T20:42:00.005+01:00

"It ain't over till it's over"... After a week of very cloudy days and mostly no charge, I found out that I needed to save more power and provide some late "adjustments".

The findings and solutions were:
- having a status output every watchdog reset was too much, too often (once every 8 seconds). A more reasonable status output is twice every minute. Displaying the status spent about 0.5% of the total battery capacity, but after an almost full discharge the lamp would only operate for another 2 or 3 days without recharging (i.e. a week of cloudy days was "deadly").
- even during the status display the CPU could be put to sleep during the status output (without using a timer but the watchdog).
- the detection of an external supply had to be changed from above 4.2V to above 4.0V, my external adapter would "kneel" to this voltage when the batteries were depleted.
- the output power levels function of the battery voltage also had to be adapted, even at the lowest level (around 200mA output) the battery voltage "kneels" quite deeply. So in order to take the most of the batteries I reduced the power output once the batteries are in the lowest charge (below 1.1V per element).
- another finding (with no solution as of yet) was that with AVRDUDE I cannot program the oscillator calibration value in FLASH (or EEPROM) automatically (as in AVR Studio). I'm not very "experienced" in script programming or makefiles with scripts but it must be possible. I need to program the flash with the code, then read the oscillator value and finally overwrite the flash (or write in a EEPROM) position where the code is getting this value. Since my program depends on this value for the switching power supply, I cannot be too away from the standard frequency of 1.6MHz.
Meanwhile I also updated my system to OpenSUSE 11.3 (yes, I know the new one is out... but I prefer "stability" over "bleeding edge").
The new code is pasted here
Ta Da for now!

SolarLight (8) - Plastic Fixing Rig et altri.

2011-01-15T19:35:00.009+01:00

In the new year I decided to further develop my SolarLight, I had to build a rigid rig to hold the light over my peppers vase. After some thought I decided to use plastic (polystyrol) to keep it lightweight. I used standard PVC glue (used for water/sewage pipes or spudguns) and Polystyrene.
To cut the boards I used standard hand tools (hand saw, metal file and sandpaper), thinking back I would be better off if I had used a table saw... With a good saw and speed setting I think I could do it all in one. I don't have a table saw, nor the space for it, maybe I'll use the Dremel mini-saw adaptor (Dremel 670) or one of the Proxxon mini/micro table saws.
The glueing of the parts was fast and clean, if you do something like this remember to do it out in the open or in a well ventilated place, toxic fumes come out while the parts are being chemically soldered. I found most of the plastic sheets and profiles here.

I started out by trying one of the few available 2D-CAD packages for linux, I used QCAD community edition that had a pre-compiled for my OpenSuse11.3 in the contrib repository. Learning a new tool has always it's steep learning curves, but I got what I wanted. I will try to use it for my future mechanical drawings of cases and front panels.

After the assembly I noticed that I forgot some openings for the LED connector and fixing, so it is just hanging for now. I also changed the battery pack I had for a 3x AA NiMH 2300mAh batteries. This was a mistake, the solar cell was selected based on a battery capacity of around 700mAh (an old NiCd pack I had laying around) and size of the board. Although with the batteries charged I got a good hour and a half of light, the next recharge period was a full week... from this page I would need 40 hours of sunlight to fully charge the battery as the solar panel output current is below the C/40 ratio... Taking into account that the average daily sunlight time of about 8h,(and in my south facing flat it's reduced to 4-5), that in Holland the sky is mostly cloudy for days in a row, that the solar cell outputs roughly 15mA with direct sunlight, I could expect to have a fully charged battery (with the NiMH pack) every two weeks.. With the NiCd I could expect once two sunny days (more or less what I was looking for). So I have to go back to smaller batteries, probably another junk 3x AAA NiCd pack I have around.
I also roughly measured the efficiency of power supply and made some tests. The maximum output current I managed was 700mA, more than that and the battery voltage would hit the under voltage protection I had built in, this is about 50% of the LEDs Power. I also had to add a heatsink to the LED as its temperature was rapidly increasing beyond the "can you touch it" capability (a rule of thumb I learned...). So I used a stable DC power supply and varied the input voltage, input current, output voltage and output current at about 25% LED power level (3.2V@300mA). The results are a bit disappointing, the efficiency is about 50% from the calculated 70%. I don't think the losses are semiconductor related but mostly the passive components (inductor resistance and capacitor inductance and resistance). The good point is that output voltage is mostly independent of input voltage...
I also did some improvements on the code and ordered some new SMD components, I'm planing on building a SMD version and extend the project to a bike light (with the electronics inside the lamp's casing), we'll see how that goes, later I'll publish the updated software.
I included a graceful degradation system to reduce the output power as the battery depletes its charge, the processor now sleeps between ADC conversions both to save power and reduce noise (I cannot disable the Timer as the PWM must run), I changed the charging process but not counting the hours of charge but only by checking the battery voltage as this allows an external charger (not sun) and finally I converted the code to be compile in linux (avr-gcc/gas).
It's a long post and I have some more post hanging in for further editing.. I'll try to keep up with one a week and I'm already falling behind.

New Year's resolutions...

2010-12-31T00:00:00.002+01:00

This year is coming to an end and this will be my last post (this year). I didn't post as many times as I wanted (I planned once a week, I'm close to once every two weeks), but that's the way life goes.
Most projects are "work in progress", so these are in plan for next year:

in the mini68k I wanted to finish a working gdb-stub before advancing to the CP/M-68K code. I finally managed to make it work, but there were some bumps in the way. The way ahead is not without it's perils, to use gdb and CP/M at the same time I might need an extra serial port for which I have no breadboard space. I'll need to draw the schematics, possibly make a PCB, make the SDCard interface work and then port CP/M to it;
in the mini85 I wandered off in some hardware questions (casing, with a floppy or without, processor speed, with DMA, cheap DMA, video, expansion, connectors, front panel, size of RAM, SD Card, SD Card removable, Flash or Eprom, serial ports, parallel port...). I'll need to settle down on the hardware, draw schematics, make PCB, fit in a case and close it;
in the Solarlight project I still want to fit it neatly on top of my Pepper pot and to tune some more code, also add a larger heatsink for the LED. I also plan to do a new SMD PCB and bake the components in a SMD oven. Further, I'd like to build a bike light with the same circuit but no solar charger. I'll need to get the final schematic, draw the SMD PCB for solarlight and bikelight and make the code linux-buildable and downloadable;
in the SBC6120 project I'll need to decide on how to fit everything inside the box and fix the harddisk to the PCB, also design the front panel, back panel and connectors.
in the home monitoring project I'll need to rewrite the code for the new light sensor and adjust the pachube data to it.

I don't think I'll run out of electronics projects for next year, but if just in case I do, I have to change a pedal crank on my Kronan (got bent on a recent fall on the snow) and I'm waiting for some studded tires :-) , read some more books and try to reduce a bit the coffee intake...

gdb-stub for m68k quirks and tricks

2010-12-30T23:30:00.014+01:00

After some investigation I finally realized how most of the gdb-stub works and how you can make it work, I also found out what doesn't work and that there are some things I still don't fully understand.
After having a stub that I could download to the target's ROM (in this case an EPROM Emulator) and would properly communicate to the gdb running on the host, I built a C runtime assembly file (crt0.s) and linker command to place the program in the available RAM. Since I had done a similar work for the stub running in ROM, it was only a question of changing some parameters and some basic code at the start up routine.
The test program was very simple, I didn't want to test any advance feature just a simple program flow with loops.

When I added a coded breakpoint in the code, all would work consistently, I could continue without a worry, control flow would be transferred back to the stub when the breakpoint was hit.
But as soon as I added a gdb break point what I expected to happen was, gdb(host) would read the contents of the instruction at the breakpoint and substitute it by a breakpoint opcode (TRAP). From reading the gdb-stub code and most internet references, a breakpoint should be a TRAP #1 instruction, I had setup the gdb-stub to intercept TRAP #1 instructions and report them as breakpoint to gdb(host), but every time I place a breakpoint I would get a privilege violation at the address following the one of the breakpoint.
The problem was that gdb(host) instead of adding a TRAP #1 (0x4e41) would add a TRAP #F (0x4e4f) (!!!), see it in the below:
I set a break point at line 20 of the code, gdb(host) tries a Z0 command but the stub doesn't implement it, gdb(host) acknowledges it, then it reads the code at the breakpoint position (m4074,2 with reply 2039), then writes a trap instruction at this address (M4074,2:4e4f).

You'll need to click on it to see it ok, sorry couldn't solve this one in the old fashion way..
When after several tries I decided to check "everything" that came in and out of the stub, I check that the instruction is in fact a TRAP #F and not a TRAP #1 as I was made to think, naturally I had not set the gdb-stub to catch these exceptions, then the stub would return to the address following the trap which is not an instruction, hence the privilege violation.
This problem above is probably solve in some gdb configuration line, but I didn't found it yet.. If I do I'll post it back here.
The second problem is only detected when you get these breakpoints to work. After the breakpoint the PC is pointing to breakpoint+2, before you continue you need to roll the PC back by two. This can be done either by the stub or gdb itself. I chose to do it at the stub, but it is possible to do it at the gdb(host) (also some configuration option must be there...). The only problem with any of these is that once a breakpoint is hit, it must be disabled before execution continues.
Gdb(host) just before you continue changes the instruction at the breakpoint address to a trap, then execution continues, when the breakpoint is hit control is given back to the stub and the instruction at the breakpoint is replaced by the previous. If the PC is rolled back by two, at the next continue, the same breakpoint will be hit without further processing... so we are blocked... An option would be to control everything from gdb(host), before continue, single step one instruction (the breakpoint instruction), change the breakpoint by a trap and then continue... I will have to investigate a bit further to see if this is already implemented in gdb but it seems (as Mythbusters would say Plausible).
If you are also curious about why the coded breakpoint (TRAP #0) above is different than the gdb-inserted breakpoint (TRAP #1 or #F) it is because gdb-inserted breakpoints must roll back the PC, coded ones do not.

making gdb-stub work from rom

2010-11-21T20:54:00.006+01:00

Well after some long break I'm back on the m68k... I had time to draw some of the schematics of the circuit, only the CPU and most of the support circuitry. The rest of the circuit is straight forward, I connected my EPROM emulator and a massive 512K bytes SRAM to the bus and finally a MC68901 Multi Function Peripheral (MFP) handling the serial port and SD card interface. The CPU clock is at the moment 4MHz, so I can share it with the MFP, later I intend to clock the CPU at 8MHz.
Since my previous post, I've done/settled on a couple of things:

I'll use gcc and gdb to do get the system up and running. Currently I managed to compile gcc-3.4.6 for target m68k-elf and gdb-6.8;
I've created basic linker scripts for running from ROM and running from RAM. Both have been proven to work with C source (C++ probably won't work). I've also created two CRT0.S for each of these linker scripts;
Compiling the gdb-stub and link it to ROM proved a big challenge, but I managed in the end. The source m68k-stub.c that comes with gdb suffers from severe bit rot, most of the assembly source doesn't compile either because the syntax is no longer supported or because "handling multi line strings has changed in 2001";
Still doesn't work perfect, the first time I load, break main and continue, remote-gdb ends up "somewhere", on the second time I load and continue (no need to break main, this is handled by the server) it works OK and I can even step lines of code. This probably has to do with my "trick" to make gdb-stub work from ROM without referencing any program at all (the frame information is not correct... I think...). On the second run (after the initial crash), this frame is correctly initialized.
I'll add a 3V power supply and a SD Card interface for "disk drive", based on some previous work I did with the Arduino, I don't expect big difficulty.
Placing the vectors in memory was actually quite easy, I needed to learn some m68k assembly and now I do it in CRT0.S. Due to a requirement of the gdb-stub to identify the generated exception, I had to build a two step exception processing. First the vectors 0 to 256 are initialized to unique locations starting at 0x400 in steps of 8. On each of these, 8 bytes there's a NOP and a Jump to Sub Routine long to the exception_handler, this pushes a unique address per exception on to the stack, the exception_handler pops this address and identifies the exception that was generated.

I had a old monitor that I "pop" from storage, to test dual head with openSUSE 11.2 and it works great. I really think it's a great advantage to work with two monitors, one for programming other for debugging or one for drawing the circuit and the other to check the PCB, Bill of Materials, Stocks, vendors, spreadsheet, etc.
Another thing I noticed is that I still can't get away from printouts of the code.. and I wish I had an old matrix printer with form paper... those were the days...

Hardware Single Step for the 8085

2010-11-13T17:21:00.006+01:00

As usual my current developments tend to wander towards all directions, as the ever expanding universe... Although I haven't really finished any of my other "side jobs", I want to further develop the mini85 into a real single board CP/M computer, but more on that later.
This week, I looked for a Hardware Single Stepping circuit for the 8085. Something that proves that "everything is on the internet" is not true (if you didn't already knew), at least until up to now.
The internet came up with nothing, so I had to resort to older methods... Books, applications notes, etc... First of it was the 8080 datasheet, on the description of the READY line it states "Can be used for single stepping the processor" but this sentence is strangely absent from the 8085 datasheet (a nice circuit with one wait state is drawn instead). Then I found something on a great book "Microcomputers and Microprocessors - The 8080, 8085 and Z-80 Programming, Interfacing, and Troubleshooting" by John Uffenbeck. There are caveats, about the same as others and my previous pseudo-DMA circuit for the 8085, doesn't allow the use of dynamic RAM hidden-refresh (end of M1). I've redrawn it with gschem.

It is not exactly what I want. I want a single lever switch with 3 positions RUN, HALT, SingleStep. I found this one on Digikey a nice C&K switch that "has the looks" of a 1980 Computer and could do the job. The problem is that I need to do some adaptation from the schematics above to a single switch with 3 positions, the main problem is halt the computer when the switch is off (centre position) and at the same time set the FF clock low... I might need some magic...

SMD help

2010-10-28T21:39:00.005+02:00

I sometimes boast about my old SMD soldering skills to my "happy hacking" friends... It's quite safe, until someone actually asks you to do _this_! Alex bought some of these JeeNodes from JeeLabs and needed some help. I accepted the challenge...
Before we start, a word of wisdom... Don't try this at home if you don't have the right tools, if you are uncertain about your tools or your ability it is best to send the module to JeeLabs and he'll repair it for you.
Following the site it is easy to understand the problem, Vout and Vin are connected to the wrong sources (this is a linear regulator Vout must be lower than Vin). The solution appears easy but it was not clear from the pictures, once the IC is in the vertical, there are two sides to chose from.
I usually start with the board to repair over a clean sheet of paper, makes easier to see as there's a better contrast, also if some small components come off the board or need to go in they're easy to see.
I then apply a small blob of solder to each side of the IC. The blob keeps liquid for some time and allows you to heat the other side (it must be a quick movement), once both sides have liquid solder slide the IC off the PCB to the paper.
Then using solder-wick clean the excess solder on the pads and on the IC feet.
I then marked the pads and the IC feet with the numbers and visualized what I had to do.
The IC actually is placed in "dead bug" style (but sideways), this means that the IC is "top-to-bottom", it is not so clear in the JeeLabs pictures.The mechanical pencil is 0.3mm for reference.
Finally I used some wire-wrap wire to connect the "floating-pad" to the board.
Since I have no idea how to connected to the JeeNode, connected it to the USB port and checked if the output voltage was around 3V... Some LEDs blinked (like in Arduino's FTDI), no smoke or hot ICs, I suppose it's fine...
SMD reputation intact...hopefully :-)
PS. - google.reader.friends if you have two posts one with pictures and other without pictures, it's just me and my faulty brain...

8-bit single board computers

2010-09-03T19:16:00.016+02:00

Before I build my own single board computer, I wanted to do a study of past and "present" single board computers that "could" run CP/M, focusing in their features and capabilities. Since I like CP/M-80 and I already managed to build a few breadboard computers that could run CP/M from a floppy or memory, I thought could build something more permanent.
Most of the SBCs I've listed below are for the Z80, or derivatives.

SB180 (from Micromint, details published on byte Sep-Oct 85 designed by Steve Ciarcia) uses a HD64180 (or Zilog's Z180) with 2 DMA channels, 2 Serial, floppy interface using FDC9266 (for high density disks) (update, I've changed the picture and here there's even a SB180FX).
P112 uses a Z182 with 2 DMA channels, 2 full serial and a FDC37C665 for floppy interface, extra serial ports, parallel port and possible IDE drive (PC-style super IO, includes high density) (new version was being sold here, apparently there wasn't enough critical mass).
CPU280 uses Z280 with 4 DMA channels, 2 serial ports and a FDC37C65 does the floppy interface (also high density disks), although some details can be found on the internet I was unable to find schematics.
N8VEM (designed by Andrew Lynch) uses a vanilla Z80, serial port with 16C550, huge SRAM 512K (mostly used as a RAM-disk), big Flash Rom 1Mb with operating system (CP/M) included, ECB bus interface, Floppy interface is an external board (new design, several boards and developers here), RTC and parallel interface (i82C55) and it's all open hardware.
YASBEC also uses Z180 but the hardware details are much more elusive in the internet, the disk format suggests 3.5 inch HD drives.
PROF80 uses a Z80, has a floppy interface with the UPD765, high density data separator, bit-bang serial interface, on the webpage there are more details ans schematics of other boards (graphics terminal) and upgraded version with Z180 (with FDC37C68, RTC and other goodies) some more details here.

I think after that review, I can settle on what I want for my CP/M SBC with the 8085. A 3.5 inch floppy (HD), 765 Floppy interface, 8085AH-2 @ 10.24MHz (2% overclocked) a 8256AH, 128K SRAM and 32KB ROM (with a debugger, Forth or Basic and boot). On the optional is a second serial port, a parallel port, a SD Card interface and an expansion port. I think I can skip the RTC as CP/M 2.2 doesn't need it and it's optional for CP/M 3.0 .
Front panel inputs I'd like to have a RUN/HALT/SINGLE STEP switch on the front, a RESET push-button and an interrupt push-button (maybe RST7.5 or TRAP). As for indicators a RUN/WAIT/HALT (green/yellow/red) LED, a INTR/INTA (red/green) and a HOLD/HLDA (only if there's an expansion port).

2010 "balcony carrots" grand cru

2010-09-03T19:13:00.006+02:00

For those of you that just arrived, this blog has nothing to do with wine... today I'm talking about carrots. This year's crop of carrots from the balcony vases was about 200g, slightly less than last year's (300g), but I planted other stuff (some worked out, some didn't). Crops were delayed (about 1 month) this year due to the harsh winter. We also had a new arrival, little Luísa! She loved the carrots as finger-food... extra tasty!

She is now 9 months and moving around, she takes much interest in my books...

But most of the time she's a sweet baby...

Mending Jeans

2010-08-18T21:39:00.007+02:00

I bike to work regularly, even during winter. As a result my jeans wear off often, every time in the same place, let's call it "the saddle area". I used to take the jeans back home and ask mum to do it. She would just go to her "work room" power up her good old sewing machine and get it done in no time.

Since we decided last year to buy a sewing machine, I thought I could try and do it myself. It is very easy and hardly noticeable once the patch is made.
You will need a pair of jeans to fix, a jeans patch a bit bigger than the hole (+2cm, 1 inch) and thread.

There's a trick about the thread (thanks mum), use grey or light grey thread. Using blue thread, even if it's the same colour as the jeans will produce a noticeable patch.

Place the patch on the inside of the jeans and secure it with pins, take care to stretch both the jeans and the patch.

Load the top thread with the grey coloured thread (the under carrier is not so important), select a wide zig-zag stitch (5mm width) and reduce the length (advance) to 1 to 2mm (a bit like the bottom right stitch of figure 2 here).
Lock both fabrics under the zig-zag presser foot starting from 2cm/1 inch outside the hole to cover, sew until 2cm/1 inch the hole end. Repeat in reverse.

When you reach the place where you started, move the needle to the top most position, release the feet, move the fabrics 5mm (about the width of the stitch) to the side, press the feet and repeat until the hole is covered.

Here is the patch finished. The good news are it is hardly noticeable, the bad news are, that usually if you do this in one leg, chances are the other leg's fabric will also fail in a few weeks.

Prototype PCBs with Toner Transfer

2010-07-06T23:43:00.010+02:00

I wanted to redo my old Munny project and build a new versatile PCB that had a minimum ATTiny15L system with in circuit programming (ICP). I planned the RGB LED and the temperature sensor to be soldered on the edge of the board, like having solder tags. The rest would be the CPU, the programming connector and the minimum number of components (a few resistors and a capacitor).
Although I've already managed to use gEDA to design and send a PCB for fabrication, I wanted to try going "DIY" and have a faster "turn around" from project to board. The board would also be very small (about 2cm²) the cost of making a production run wouldn't be cost effective.
Before I've used the UV light transfer with very good results, even for double sided boards. This time I wanted something even more "barebones" only the etchant, no other chemicals (like the extra developer in UV photographic method). I found some sites with the reference to Toner Transfer Method. They used either inkjet glossy photo paper, a specific "Press and Peel" paper ending in common "glossy magazine" paper, there's even a nice page at Make: web discussion . I decided to give it a try!
First I designed the board single side only. I started out with 10mils/10mils/0.8mm (10/10 means 10 mils tracks and 10 mils minimum spacing between copper, a 10 mils is 0.01 inch; the last number is a minimum drill), but soon I had problems connecting the ICP with the defined tolerances. I changed to 6/6/0.8mm and finally managed to connect everything and pass the DRC test. The next step is printing.

My printer is a HP laserjet 4L (its old, 300dpi but it works!), it still has some problems that I didn't quite worked out yet. There is some rendering on the edges of the lines that I didn't managed to "clear out", I think it is the REt setting but I didn't managed to disable it with my linux driver (the printer is network connected), this is something I would like to solve. It might be visually more appealing when printing normal graphics, but for this particular purpose it doesn't work! Here's a picture of the zoomed output.
As you can see the horizontal lines (in the photo above, to the printer they're vertical lines) and edges have a "saw tooth" on both edges. As I said before I think it is a rendering/dithering that the printer "self" does to make the lines more eye appealing or it is a misaligned mirror.
I tried out 3 different types of glossy inkjet photo paper from Dutch shops. Bellow the three different papers ready for cutting and ironing to the board.

I obtained the best toner transfer with the HEMA glossy photo paper, not bad for the cheapest of all the options...

The transfer was clear and sharp... all the rendering artifacts appear in the copper. The paper that doesn't show has peeled off easy, the part that is attached is the one you have to scrape.

The first from the left actually when it transferred to the copper the toner transferred fully but in some areas it got stuck to the paper. It might mean that this paper need more ironing time, temperature or pressure (or all of the above)... I might try it again... the one in the far right is the HEMA paper, needs more scraping but the toner sticks to the copper fully.

This is the view of the most troublesome area, two wires going between two pins of the ICP and one track between pads of a SMD resistor, both around 6/7 mils clearance. I had to puncture the centre of the pins because I forgot to set "drill" in the print out and it helps a lot for drill bit centring.
I actually had to separate the track from the SMD left pad, the etchant didn't go through the little spot of paper (visible on the picture above). The picture bellow I removed the toner and performed an electrical test with the multimeter. I also drilled the connector.

After that stage I soldered the components and had my board running after a couple of minutes. Here's the final result. The power connectors below the board have been soldered for testing and programming, I'll be removing these... I'm also planning some tests and improvements to the board's software.
The connector ICP is a 6 pin female because it has a smaller (in height) footprint than the male connector. I'm quite please with the LM35CZ and RGB LED footprints, for such a small projects edge placement is viable and saves board area.
Getting the 6/8 mils was a bit of an over achievement and it is only viable because the board is small and hasn't got many connections, 10/10 mils should be the standard. I also need to see if I can solve the rendering of the printer problem... maybe (God forbid :-) using a Windows driver?
The soldering was done by hand and normal soldering iron, a "next step" would be an SMD-oven.
Tah Dah!

SBC6120 - Casing (II) and power supply

2010-06-05T23:31:00.009+02:00

I finally got my hands on the power supply of a _DEAD_ External Hard Disk that suited the purpose of powering my SBC6120. Before I was using a Compact Flash to IDE adaptor and I only needed a 5V supply but I wanted a "real deal" IDE drive.
My first try was an old drive I had around, a Seagate 89MB... unfortunately another case of R.T.F.M., disks with CHS addressing (cylinder, head, sector) are not supported, only the (relative) recent LBA (logical block addressing) are. Alex gave me a 3GB drive he had "hanging around" somewhere in a box, probably more than enough to hold all the source code ever produced for the PDP-8... It fit the case, just... probably too "just".
I still need to pack inside the case: a switching power supply (LM2575, two big caps, a diode and a fat inductor), the power connector, the IDE ribbon cable, the serial port connection, the power switch and (if possible) one or two front panel indicators (power on and disk activity).

The Case is a Hammond I bought some time ago for this project, but I never found a suitable power supply. Now with the external 12V supply and (this is a forward reference) the toner transfer PCB method, I can build a middle PCB board holding the hard disk, the CPU board, the switcher power supply (12V to 5V) and a power switch. I'm looking for switches like the one above, but I still haven't found a good right-angle-PCB-mounted... I'm looking at some lever switches from C&K, they look the right "age" for a pdp-8 simile. but will see what I can get my hands on...
Space in the box is tight so I still haven't decided where to put the power switch an a power LED, or if I just make some openings in the front panel and extend the LEDs on the board... I'm also looking for some front and back panel design...
There's a lot of mechanical engineering ahead... I love the smell of a challenge in the morning...

Arduino interface to SD Card

2010-05-28T22:36:00.008+02:00

Finally managed to interface to a SDcard to the Arduino. There are several "tutorials" and even libraries written for the Arduino, but my objective was not to use any Arduino library or specific feature (like the integrated SPI port), otherwise porting the code to the mini68k would be more difficult.

I started with this example (this other seems easier) and then started "removing stuff" in order to fit my purposes. I only need the basic initialize, read sectors and write sectors. In order to boot and run CP/M from an SDcard I don't even need to read/write more than a single sector as CP/M reads/writes only one sector, furthermore deblocking (breaking up a 512 byte sector into 128 byte CP/M sectors) is easily managed by most CP/M flavours (CP/M-80,CP/M-86,CP/M-68k, CP/M-Z8000).
I battled with some Arduino functions, I particular serial.print() functions. I'm suspicious that something doesn't quite add up, some of the lines of text that should be printed are skipped for no apparent reason. It could be by the fact that I directly access the port pins (DDRB and PORTB) but since I don't change the serial pins there shouldn't be a problem...
After several tries I managed to write and read a sector of the flash.

The hardware is at its simplest form, it is a basic resistive divisor by 2 for the card inputs CS, SDI and SCK, the SDO output from the card is connected directly to the Arduino input pin.
Pins CD and WP are also connected directly, the card detect(CD) and write protect(WP) switches use a weak pull up feature from the micro. A low voltage drop regulator provides 3.3V to the card.
I used the Sparkfun SDcard adaptor, but since the "freeday disappointment" I promissed never to buy from them until the EURO is >= 2x the US dollar (from that point on I would be stupid, not stubborn). The circuit used is the one of the first example above, except that I didn't bother to have the correct 3.3V input, I decided to go to 2.5V as it is easier to obtain (two equal resistors) and the input tolerance of the SDcard must accept it correctly. Usual (CMOS) input levels are at 60% (2.2V for High or 1) and 30% (for Low or zero) of Vcc (of the card).
Now I only need to port the code to the 68k...

HDSP-2000LP Arduino

2010-05-01T19:55:00.009+02:00

A few years ago I bought some 4x 5x7 small LED displays in eBay. I though they looked really cool to be used in a front panel display, instead of using a single line LCD. The datasheet was actually easy to find but driving the display...well that's another story.
The initial objective was to incorporate these displays as front panel to the mini68k, as usual I try to prototype it with the Arduino. It ended up as being quite hard, you must compose the characters as "bitmap" graphics, then shift the 24 bits for "column" one of all the displays, then activate column one for 2ms... then repeat to column 2 to 5.

So first you must compose the combined display bitmap from the individual characters, then shift a sequence of bits and activate the respective column. To do it proper you must have in memory a bitmap for each character, compose the "screen" and the shift the bits and activate the columns in sequence.

As you can see from my first program... it didn't go well... unless you're the Predator and your personal nuke is counting down...
A few more head bangs against the wall et voilà...

Finally insanity takes over and I try to do a space invader... (the following photos are so crappy I forgot to get out of the light shade, late night)

inter character spacing is too wide to make multi-characters symbols (like infinity) unreadable... let alone the space invader that got cut in half... probably from a missile F-111...

The code is here, enjoy...

New Pachube Feed

2010-04-17T15:54:00.008+02:00

I finally had the time to create a new pachube feed and add the humidity monitor. It was almost "plug and play", I only had to convert the float values to integers and then scale them for one decimal point. My webpage server program uses the server.print function and it doesn't accept floats as input.
I kept the Light sensor, so one can see the relation between the changes in the values of temperature and humidity with the daylight. Other interesting (and expected) reaction is the increase in humidity once the clothes were out to dry in the living room (as I did this morning) :-).

The sensor is powered by a microcontroller port, and it is not (yet) filtered, I'll add a small capacitor to the power pins. This would allow to power the sensor only "on-demand", but I'm not sure if there are implications on the sensors stability. I know that it needs some time to correct the humidity readings...
The speaker is used only to beep every time the Arduino is queried, it beeps every 15 minutes by pachube.
The code is here, the pachube feed is here, and the picture of the system is bellow.

mini68k adding libraries and serial port

2010-03-22T09:50:00.006+01:00

I admit I haven't been very focused at my hobbies, but that's life. I've been working here and there: getting the Arduino and the SHT11 working together (see here for library), converting a metal-gear servo to continuous rotation (I followed this how-to), trying to design a photodiode amplifier (I'm following this, this and what is available from this), debugging the SolarLight project and working on the schematics of the mini68k and finally getting some code running on it.
I've been feeling a bit more confident with gcc-m68k and I've been increasing the complexity of the programs. I managed to link in the gcc library (libgcc), I tried out the -msoftfloat option (compile, I didn't check the results of a floating operation yet) and I created my own putc and getc functions using the USART of the MC68901 (MFP) in pooled mode.
I want to change my CRT0.S to include some hardware support functions before main() is run. Initialize the interrupt vectors (pointing to a "interrupt error" routine), printing some console message during initialization and doing some hardware test (RAM, MFP).
I'm still unsure of a few things:

An interrupt level 7 is basically a NMI, my system switches from ROM to RAM at the 8th clock, at the 9th clock if a NMI is pending the CPU will jump to an uninitialized vector! I must read the specs again but I think this could be a problem. Or not, if the system is int7 incapable (IPL2/0 or IPL1 permanently to 1) or has a gate enabling interrupts;
the MFP interrupt is physically enabled (i.e. connected to the CPU or gated by self for example)? (see point above), how does gcc link to interrupts (newer gcc versions work well ex. AVR-gcc), how do I place the vectors in memory?;
I want to build a gdb-stub/rom monitor, will it handle the vector allocation/writing? If so, my operating system (loading from somewhere ROM or disk) will also be in supervisor mode? (and also handle these?);
Can/Should I implement some sort of memory protection (writes to first 1K-vectors and last 1K-SupervisorStack of RAM must be made in supervisor mode)?;
For the end project of a CP/M 68k what type of media do I use? Going back to floppies would be definitely cool but I'm sure I would need some sort of DMA as I don't think the 68000 is fast enough (and surely not at the current speed of 4MHz). With SD I'd use only a few I/O pins (from the MFP?) but some SD cards are only 3.3V and my system runs at 5V. Or I could use a Compact Flash card, most can work at 5V, and it is easy to get some old CF cards (64/128MB) or even a IBM microdrive I've found once here; I would need to build two 8bit ports (A output to control the drive, B for bidirectional data) and this is breadboard space...
I would also like to "upgrade" the logic circuits to one of the M4A5-32/32 I've build an adaptor for and change the DTACK circuit to actually drive the line when releasing the bus (until AS goes high).

Well for now that is a still a lot of work in progress, I doubt Spring and/or Summer will allow me more time but I'm trying to keep you posted.

Arduino OpenSuse 11.2 (LED as light sensor)

2010-03-07T10:58:00.026+01:00

I need to use my Arduino-shield-Breadboard for another project, so my Pachube-feed will be offline... for a while...

Next time around I'll add some more sensor that I have, like the relative humidity sensor.
I took the time to upgrade to the new Arduino-0018, here I encountered some old and some new problems.
First I needed to add my user to the dialout group in order to have access to the serial ports, as reported here (see last post). The other problem was an old problem, with the standard avr-gcc distribution of OpenSuse you can't program an ATMega328. I didn't solved it right now but the how to is here. But for now pachube is off-line (correction: is on-line but data is bogus).

Alex has a problem with his home monitoring system, he wants to monitor the amount of Water he uses by counting the turns of the pointer in the meter. He intends to use photo-reflexive sensor like this one.

Trying to help him, I started with using LEDs as sensors, Photodiodes are expensive and photodiode amplifiers difficult to build due to the very low bias current of the amplifier. My best results were using a IR LED as a sensor, but I'm still not sure if it will work with the set, in particular becase the sensor Alex has is a fototransistor not a photodiode, the principle used could be the same but instead of a reverse bias (anode to ground), the foto transistor must be actively biased (emitter to ground), the parasitic capacitor should still be discharged function of the light.

A good source of information is here, and here, I based my code on the Arduino example but I changed the port programming instructions for direct port access instructions (DDRD, PORTD), it is not "elegant" for several reasons but it is a bit faster and gives better results at high light levels.

The available pre-compiled avr-gcc does not allow you to program the Arduino Diecimillia (ATmega328 is only possible to do assembly, no C or C++). So my update of the Temperature monitor will have to wait...

Das Blinklicht with gcc-elf-m68k

2010-02-27T18:04:00.008+01:00

The first program you write when you learn a language is the "hello world" classic, in a embedded system where you don't have a serial port (or you don't know if it is working) you have to use "das blinklicht" example. Er... it's just a blinking LED.
After setting up the cross compiler tool chain you'll need to set up the linker script and the crt0.s files.
The linker script defines where (in physical addresses) is the RAM and ROM of your system, which sections of code go into where and in my case the reset vector and initial stack pointer. There are still some things missing (namely libraries, floating point and multiplication/aritmetic), but I'm a step closer. I must admit that I found these (crt0.s and ldscript) on the net but I don't remember where or who did them. I've just change them a little.
Although the ROM is mapped on reset during the first 8 clocks at 0x00000, after the 8th clock ROM gets mapped at 0x80000. When you are programming a real eprom (or using my "linux-updated" rom emulator) you must move the code to the bottom of the ROM. This is accomplished with the command "AT".

GCC creates a section of code for "initialized data" called .data, this section is put into ROM and at the start it is copied into RAM (at CRT0.S), with the blinklicht program I don't use any .data or .bss or even stack, so for now I will not test if this works.

Without using optimizations -O2 your software loops will not be cleared by the optimizer, and it is pretty easy calculate the time taken for the software loops.

I had calculated an access to the MFP m68901 every 15us with a 4MHz clock and what I had was 30us.. I found the "problem" the next day, the instruction timing sheets are for the m68000 with its 16bit data bus, a 68008 takes two memory cycles for each of m68000, therefore twice as long.
The simple makefile is here

SolarLight (7) - Software, AVR assembly

2010-02-27T18:02:00.015+01:00

Ok, finally google docs supports any type of file so I can post all the project files in one place: code, gerbers, gEDA design files and spreadsheet with the calculations, requirements. It is all here.
I decided to try out pastebin, so I'm updating this post with the code for everyone to take a peek... In this version I'm still working on the "when to turn on" routine, I think it still doesn't work as I initially intended... pastbin doesn't look so good to paste long assembly lines, but here it goes anyway..

The software as it is now is working, it has some problems and "room for improvement" but it is working! You know the motto: Make it work, make it better!, make it faster!

One of the improvements would be to limit the time the light is ON to about 30min-45minutes, this would allow the battery charge to progressively increase during the good sunlight days and progressively decrease on a sequence of bad sunlight days (as in this year for example).
Other improvement could be a full darkness detection and adjust a 12h no light clock from there. It has happened that during the day when a big cloud (and/or heavy rain/heavy snow) the measured light level goes down to the "night" level, then if there's enough battery the light turns on... it shouldn't and I'm sure this winter is exceptional, but the only way to prevent this is to detect the lowest darkness point and count 12 hours from there, and only from then on the light would turn on when it is dark.

In the code I added a debug routine that is included when the two variables are uncommented (DEBUG and DB_CNT), when I wanted to output a value I load it in the DEBUG variable and call dbug. The byte is output in the status LED serially MSB first, there is a long (2 cycles) high pulse followed by clock and MSB data, clock and bit 6 data... clock and LSB data.

Finally my biggest problem was the branch instructions, the AVR has the following:
BRLO - Branch if Lower (UNSIGNED)
BRLT - Branch if Less than (SIGNED)
BRGE - Branch if Greater or Equal (SIGNED)
BRSH - Branch if Same or Higher (UNSIGNED)
I was not used to have these complex branch instructions, I'm used to Zero Flag set, Zero Flag Clear, Carry set, Carry clear... I'm specially not used to having a different branch for signed or unsigned... So I chose wrong.. result the jumps were not taken when they should. The ADC values are unsigned when read (0..255) but if you start calculating with them you can get signed (negative) values and then you have to use signed instructions.
AVR assembly programmer beware!

A final word about the Code, it was assembled with Atmel AVR Studio Assembler (Win), it doesn't output the number of cycles per instruction... a bit of a let down... :-)
And with this post I finish this project.... Woo Hoo!! Project is dead, long live the new Project...

SolarLight (6) - PCB Fabrication and Assembly

2010-02-27T17:31:00.015+01:00

Using gEDA for producing gerbers turned out to be easier than I thought.
Recently the gEDA project has been under fire in slashdot due to its "complicated", "non intuitive interface" and lack of documentation. I really don't think that the documentation is that bad, it is scattered but it is not bad, just look here. I haven't meet an Open Source project that didn't suffer from the same problem, even (and particularly) the GNU tools. As soon as you get out of the mainstream gcc/gas/ld/gdb you're almost on your own, searching bits and pieces in the internet. Some of the best GNU project documents have been written by a commercial enterprise (either redhat, cygnus or other).
I call it Anarchic-Knowledge (or Anarco-Conhecimento in Portuguese), everyone omits to write what he finds trivial, forgetting that what is trivial to him, might not be for the community that will use the product. Then a plurality of tutorials, blog posts and guides show up, each one showing how they did it "their way". A new user has to pick all these pieces, try more than one and finally write a "I did it my way" post... And we all learn from this experience.It is not the lack of documentation, it is just the way that Open Source grows.
Back to the how I did it... :-)
I followed this tutorial, I had a single page schematic so it was easy to generate the netlist. I created a single project file with the schematic libraries, I used my own symbols since not only I wanted to learn how to do them but also I had a MOSFET with two Drain Pins that I could use each in an independent circuit. I used shell scripts to get the job done, I tried once a Makefile but I realized that I would have to change the Makefile for every project (even smaller ones), a shell script can do that at invocation time.
I also created some Footprints for my project (also for educational purposes), I had them in a library directory and used jcl's gnetlist invocation but with my directory instead. PCB must also be configured to have a pointer to your library in the "File-Preferences-Library".
First follow what gschem2pcb tells you to do, open the file, import the parts, spread them and execute the command, then I put in most of the mechanical details, using the outline layer in a place where no components were place, size of the board, cuts, groves and fixing holes. Also check now for the DRC tolerances in the File-Preferences Menu.
Then the fun begins, it is a very iterative process: place, route, looks good? can I do it better? with less vias? other mechanical problems? heat sinks/problems? repeat until satisfied with the design.
Then I place some more information on the silkscreen, plus signs on the connectors, output indication, board reference, moved the references so that all are visible when the components are soldered and facing the same side (so that you don't need to rotate the board to read the references). I also place on the top and bottom layer a square with the layer number inside, so that you can identify the layers on the gerbers and on the boards.
I was going to use Olimex pcb prototype services for my first gEDA boards so I needed to limit the number of drill sizes, they have some drill sizes that are considered standard and any other is considered extra (and you pay more), luckily someone from the gEDA-user group already made a drill mapping file for Olimex after executing the script run DRC again! Here's my final PCB result.

You can also export to png the two sides of the board in a "photo-like" picture, some people claim it gives better reading and it is easier to spot errors.

If you have no errors in the last DRC you're ready to produce your gerbers, and this part is as easy as pressing the correct button in export. Then with gerbv, check if the gerbers look nice and the drill sizes are correct.
Recently a good question came up in the geda-user mailing list, it sums it up nicely but the first reply reminded me of something I didn't do and should have done...

Print out your surface copper layers and put the parts on the printout to make sure they match.

yup, I designed my resistors with a 1/8W in mind and then I couldn't find any I had to use 1/4W.. so the resistors didn't fit in place. My DIP 4 for the MOSFET also didn't had big enough holes, apparently International Rectifier didn't stick to the normal DIP drill sizes, probably due to current capability or thermal conductivity. In that point, with some hindsight, I would increase the copper area connected to the drain, that could be a good heat sink for the MOSFET. I also should have thought a bit more on how to fix the board to the pole, with the new batteries the SolarLight is much heavier, I should have devised other way to fix it. Here's the board in place, note the resistors in two layers.
UPDATE: The resistor that is hanging and has two sockets is the gate resistor of the MOSFET, if you check the spreadsheet with the calculations you can see that the gate current has great influence in the MOSFET power (losses), so I made it low enough to still allow programming easily (now at 100R). When programming the micro the light turns on, but without any damaging effect as long as the frequency (of programming is high enough 250k) and the pattern is sufficiently random (see here for a bigger problem with ISP port sharing).

One last remark, if you buy microcontrollers in ebay and they say "New, Old Stock" it doesn't mean that they are not programmed, they can be factory programmed and that doesn't mean that they are not new! In case of the ATTiny15L, the low voltage programming mode can be disabled by this factory programming, if you solder it to the board you'll not be able to reprogram it. You need to remove it from the board and use a HVProgrammer like AVRDragon for example. Learned the hard way...

CPLD SMD Soldering

2010-02-19T22:46:00.003+01:00

Having received my boards and with my Weller working it was time to solder. I started with the CPLD adaptor, an adaptor I've build for my stack of old MACH211SP... I could also test my SMD soldering skills.
Here is the first step where two opposite pins of the PLCC are soldered into place. Next I'll have to "restart" my DesignDirect program in Windows XP. On a side note here's the schematic of the board.

Weller WTCP-S Repair

2010-02-19T22:44:00.005+01:00

This week as I was about to start soldering my boards my old trusted Weller WTCP-S started to fail, first ocasionally it wouldn't heat up until shaken, lattely not at all.
Wanting to fix it (if possible) I opened it to check the famous "Magnastat", these Soldering Irons operate on the principle of the Curie Temperature, where a magnet loses its magnetic properties at a certain temperature point.
Inside the casing there's a ferromagnetic piston and the tip is also magnet with a predetermined Curie point (the number on the bottom of the tip), when the temperature is reached the magnet losses its properties, the piston is no longer pulled and the contact at the bottom opens, opening the heating circuit.

I had to open the contact casing and clean the contacts, put it back together and test....

While cleaning the contacts the wiring came loose, so now I was facing a chicken'n'egg problem, how to solder a soldering iron?, the local hackerspace was the answer, I meet some really nice people in really nice location and they had a spare soldering iron I could use in their "electronics shack".
Anyway got home, tested it and it works for now... but I expect it to fail again soon... I'm ordering a replacement today...

SolarLight (5) - PCBs!!!

2010-02-17T13:29:00.005+01:00

I finally had the time to pick my PCBs at the mail. I was thrilled to see who it went... My first linux made PCBs!
Everything went ok, except for a few minor point where I'm the only one to blame...
Here are the pics to the solarlight board and the others, the last one is the RFadaptor that didn't go as well as I expected, but I'm the only one to blame....
Here is the one where the wholes are just the size of the pins (just not enough for them to get through)...

I'll post how to get from PCB design to send them to Olimex (for example) for production. It's not that difficult but you need to follow some steps.

Next Project Minimal CP/M 68k

2010-02-10T23:26:00.009+01:00

The Solarlight project has been taking more than normal, but the truth is I haven't had much time lately...so I decided to announce my next project, revive a minimal CP/M-68k system and document the process. The main components are a MC68008 CPU, a MC68901 MPU, 512K of SRAM, 32k EPROM, and a IDE/ATA connector. The MPU (multi-peripheral unit) will serve as UART and probably as basic memory manager, the IDE interface will probably be based in GIDE or something similar. While I'm still working on the schematics, I've already built the base circuit from my hand written schematics... here's a picture.

The sources and documentation of the code are available in Gaby's site. This site used the sources to build a VAX version, so the sources appear not to have suffered from too much of "bit rot".
For cross compiling and debugging I'll try to use binutils/gcc/gdb in remote mode. I'll try to build the cross tools (elf format, coff has been since long time killed) and a remote gdb-stub to download and debug some initial code... we'll see how it goes..
Here I've already built the cross-compiler toolchain for m68k-elf (binutils-2.20, gcc-core-3.4.6, gdb-6.8 and newlib 1.18.0), I didn't use a more recent one because from searching gcc-3.x.x is easier to cross compile with the newlib, and I wanted to use a smaller libraries than libc.
Download the sources from the gnu ftp site (except for newlib that is here), I followed this guide because not only it appeared simpler (no "bootstrap compiler" step) but also it is dedicated to embedded systems. Don't forget to move newlib and libgloss inside the gcc directory and after the binutils compile put them in the path. I also used gnu gdb instead of insight but no other than that.
Finally set the path in your .profile for your convenience, see here for details on OpenSuse.
My first objective after building the system on a breadboard is to download a small m68k assembly program to the EPROM EMULATOR and see it run, then a small C program and finally a gdb-stub. Then I'll have to repeat the process since from that point on there must be a change in the linker file as programs stop being linked to ROM but linked to RAM.
I've successfully assembled a "loop:nop,nop,bra.s loop" but a few problems or "unknowns" remain...
I've created my simple assembly file called test.S

/*
* test.S -- test file for assembler output
*/

#include "asm.h"
.title "test.S - test file for assembler output m68k-elf-as"
#define STACKSIZE 0x4000

.data

.text

.extern __stack

.global SYM (_start)
SYM (_start):
nop
nop
bra.s _start

I assemble it with "m68k-elf-gcc -c test.S -o test.o" then link it still with gcc "m68k-elf-gcc test.o -o test.x -nostartfiles -nostdlib -v -fpic -WL,Ttest.ld"
I had to include the -nostartfiles and -nostdlib to remove the standard crt0 and the global constructors for C++.
My current linker file is very simple and probably some things are missing for a full C program compilation but for now things appear to be ok.

/* ld file for rom programs */
/* for 8 cycles rom is at 0x00000 (fetch SP and PC), from then on 0x80000
/* STARTUP(crt0.o) - no startup file*/
OUTPUT_ARCH(m68k)
OUTPUT_FORMAT(srec)
SEARCH_DIR(.)
/*
*Setup the memory map of mini68k, stack grows down from high memory.
*/
MEMORY {
ram (rwx) : ORIGIN = 0x01000, LENGTH = 0x80000-0x01000
rom : ORIGIN = 0x80000, LENGTH = 64K }
/*
* allocate the stack to be at the top of memory, since the stack
* grows down, also PUSH => -(SP) = xx, i.e. predecrement therefore
* first stack address never gets written
*/

PROVIDE (__stack = 0x80000);

SECTIONS
{
.text :
{
_stext = .;
*(.text .text.*)
. = ALIGN(0x4);
_etext = .;
} > rom

.data :
{
*(.data .data.*)
_edata = .;
} > ram

.bss :
{
. = ALIGN(0x4);
__bss_start = . ;
*(.bss .bss.*)
_end = ALIGN (0x8);
__end = _end;
} > ram
} /* missing in the initial file - causes an error ld does not complain! - beware */

Then I can also successfully convert the object file test.x to a SRECORD file with the command "m68k-elf-objcopy -O srec test.x test.S19" and then revert the intermediate object file test.x to assembler with "m68k-lef-objdump -d -X test.x > test.dis"
After successfully removing all the initialization code gcc attaches to your code (with -nostartfiles -nostdlib(p.s. you only need the first one since you don't add any library function)) I was left with one question, why is my code placed at absolute address 0x80000054?? when I told in the linker file to put it at 0x80000 (less a few zeros in the middle) Here is the disassembly:

test.x: file format elf32-m68k

Disassembly of section .text:

80000054 <_start>:
80000054: 4e71 nop
80000056: 4e71 nop
80000058: 60fa bras 80000054 <_start>

Ok, this was a bug. I forgot a } in the memory definitions of the linker file *.ld... After adding it the code was located at the correct place 0x80000.
Well there are still some hurdles to overcome, namely:
- placing the start SP and start address in vectors 0 and 1;
- place the other vector in ram
- place the code in proper ROM addresses (and the initial SP,PC)
- download the code and see it run...
... the path through cross-gcc appears to be hard ...

Reverse Engineering a EPROM emulator

2010-02-10T17:24:00.000+01:00

While I'm waiting for the SolarLight PCBs to arrive I went on think about other projects...
I had an old EPROM emulator that I bought a long time ago in ePay. It is quite small and it doesn't consume much power but it worked from the parallel port and the old DOS software was reluctant to work even under WinXP.
I had to redone the parallel port interface board, as a soldered IC (74125) blew up when I powered the PC after the target board (note to self: power first PC then target). It was quite simple to draw up the schematic and redo the circuit on a perfboard. When I tried the DOS software with my new board all worked OK, I was sure that the schematic and hardware were correctly reverse engineered.
Of the 5 signals coming out of the parallel port, Reset and Output Enable were easy to spot, the others I suspected downloaded the data serially.

Reverse engineering software, on the other hand is far from trivial. I first tried my two channel xscope, but since there are actually three important variables it was difficult to really discover what was the sequence of events. Furthermore there was a start sequence where transitions where at the millisecond range and a program sequence where things happened at the microsecond range.
Then I remembered I had a PICKIT 2, a tool I bought and used about two years ago to do a short Microchip PIC development (and re-learning since when I first learned about PICs the 16C84 was the craze, obsolete today). PICKit 2 was not only relatively cheap, programmed most of the devices, it also included a logic analyzer and a UART for remote debugging, all connected to a USB port. I must give a note of remark to Microchip that this was a stroke of genius, a scope is a an expensive tool, but by adding this functionality to a device-programmer is a well needed help in many non-working projects.
I created a fixed intel hex file with 3 bytes 0x22,0xAA,0x44 than ran the program in a dosbox in windows (and using a parallel port access - Windows bypass - tool) waited for the signals to come out on the other side. Sometimes it worked, others it didn't but I registered the ones that did.

This in the above waveform the real data download is pictured, in this particular case I shifted the data to position 0x0001. From here it was easier to identify the signals, first is the clock, second data and third advance to next memory address.
Then to capture the initial reset sequence I downloaded bigger programs, just to measure the timings of the sequence.

As you can see the waveforms are very detailed and although one cannot read signals above 500Khz chances are 99% of hobby projects will never need more than that.
The code will be published or given as soon as I finish the other source file interpreters (S-Record, Binary and hex) for now only intel-hex works, I will also try to clean up the code and have it hosted in google code or similar as soon as I understand properly how to use it. I'll try to host all the software produced under a single project otherwise it is a waste of google's space.
So that people that still have a similar eprom emulator, the name of the package was "MicroRom Eprom Emulator" and produced or sold by "Squarewave Electronics". Here is a picture of my test bench, the Eprom emulator is the big fat thing on the left, the top LEDs are the data out, the lower green leds the four LSBits, the selector on the top right corner is a BCD selector and finally the yellow led on its right is the reset signal.

Hackerfruehstueck

2010-01-31T13:19:00.003+01:00

It is really my version of the German Bauernfruehstueck, yesterday the local hackerspace had their new year's party and "official opening event", shame on me but I could not go.... hope I'll be able to meet some of the guys there.
I hope this helps recovering from last night's party... I know it helps after long nights of kernel compilation and cross-toolchain building...(geek thought, sorry)

Start by peeling the potatoes and cut them in slices of about 1cm thick, it is better if you use a type of potato that stays firm after cooking. I usually add in some vegetables, green beans are my favourite but other vegetable that cooks firm is fine (broccoli in small pieces). I usually steam them for about 15 minutes before going for the rest of the recipe.
Start by frying the bacon for a few minutes, turn the bacon slices over, and let it cook for one minute. Add the potatoes and vegetables (and some onion if you want), some pepper and salt and mix gently, let the potatoes cook until they are golden, add some sliced parsley and remove from the fry pan.
Do some scrambled eggs on the same pan (keeping some of the bacon's fat) and serve.
et voilà...
A few after-thoughts:
- remember your cholesterol bacon and eggs are your enemies, "but it tastes so good..";
- the fruit juice is important, use orange or carrot juice, helps digestion :-)

Thinkpad X40 and openSUSE 11.2

2010-01-30T20:56:00.005+01:00

Note to self... and anyone interested... Installing openSUSE 11.2 in a IBM thinkpad X40:
- edit partitions yourself (don't trust a computer to do a man's job), create primary partition, don't format as ext4 use ext3 instead(see update notes below), mount root; create primary partition, format as swap - size must be at least half the memory (just used for hibernating);
- install the languages you want (for OpenOffice dictionaries);
- disable firewall (avoids frustration when playing with toys);
- install development in C and KDE;
- remove Games (although some bastards are hard to kill);
- remove AppArmor, Beagle (optional, but if I don't know what they do, I don' t want them);
- install minicom (to play with serial toys);
- install kate (resonable window editor);
- install zip and other utils;
let it install for an good hour...
let it auto-update... let it fail...reboot...
let it auto-update again... now everything looks green... (the SUSE updater icon);
search for "opensuse 11.2 restricted formats", don't read any warnings and go directly to the one-click install... click yes, accept import keys and "deny any wrong doing" regarding the dvd-read library.
When finished reboot and have some food/coffee. Your system is ready to work... but for curious minds continue....
Search "opensuse 11.2 science" click on opensuse_11.2 and copy the URL, open YAST and add a repository using the URL that you cutted, add and import key...
In YAST go to software management and search for the following:
- gEDA (install all programs);pcb (install pcb); gerbv; ngspice, gspiceui, gwave2;
- AVR (install binutils,gcc, libc, avrdude);

Search "OpenOffice updates stable", install repository as above.

Open Yast and then Software Management, select All in "package groups", in the programs window select "all in this list -> update if newer version is available"
That's it, your laptop is a electronics design workstation and avr cross development computer.
Some things of opensuse need some extra work like SUSPEND and HIBERNATE, I also didn't managed to get dual head working "out of the box" and I'm reluctant to change the Xorg.conf... something I did when I had my first thinkpad a second-hand 340...

And all this because I had a Sony reader for a week and then decided to return it (takes to long to render some PDFs with pictures, and sometimes it hangs), wanting to un-install calibre... I found out there is no such thing... damn!

Update: my old backup software failed first to copy the ext4 partition and then failed to install grub for booting. After battling with it for some time I decided to do a fresh install with ext3. It is a pain in the butt! I hate myself for it, I should have known better, you should never be an early adopter!

SolarLight (4) - gEDA, PCB and first corrections

2010-01-30T19:49:00.004+01:00

It has been a while since my last post, but I've been busy... not so much on electronics projects, but projects of other kind... Nevertheless I've been working a bit on SolarLight.
The prototype was working to light the LED but some other bits of the code were not working. Although the "light-on" function was working, the function checking the battery and checking the charging were not.
After wake-up from reset (power-up or watchdog), the micro checks if the current Solar Panel voltage is >200mV than the battery (a safe assumption it is charging) and if so increments a "charging timer", if this timer is less than 3hours, don't turn the light on. This is to be sure that there is some charging before a discharge. These and other checks were not working.
De-evolution from C to Assembler is always a mess if you have to re-learn the mechanics of each architecture. It is not only the instructions, its how the micro "thinks", only then you really control the machine.
On the hardware side I also had some problems, due to the limited number of pins I had to share some pins with the in circuit programmer, one of them is the MOSFET gate. I forgot to add a gate resistor to the source, in common MOSFETs with 10V gate threshold that is still asking for trouble, I guess that with LL (logic level) gate thresholds of 2V it is just "waiting to happen"... although it did take a couple of weeks...
I guess what hapened was, after programming the AVR-ISP left the pin floating and probably before that the level was high... the MOSFET kept on and finally burned.. I saw smoke coming out...
Here the new schematic with revisions on the lower corner.I also started the PCB design (with PCB part of gEDA suite) and I've now finished the board. It is not as packed as it could be because it has the size of a 3xAA pack. It is marked version 1.1 because I had finished the version 1.0 when the MOSFET blew up. I've mostly followed the tutorials available at the gEDA Documentation site:
- this one for the drawing of schematic and creating the netlist;
- this one for drawing footprints and getting to know PCB;
- and this one for the simulation;
- I also used this one for creating large "box symbols" (cpu, uart, etc)
I used gschem directly to create the new MOSFET symbol (IRLD024), since the original MOSFET symbol was graphic I though it would be better to use it instead of having a 4 pin box. I also wanted to keep both Drain connections separated if needed to use them in separate nets (although they are connected).
Using gEDA is still far from trivial as components, footprints, schematics symbols are all your responsibility, but still, I'm starting to like it. PCB also has a nice feature, you can print "photo mode" version of your PCB (yes, I know other software produces 3D views), here's mine top side.

Happy New Year

2010-01-01T23:24:00.004+01:00

A year has gone by, another year has arrived, hoppefully it will bring more posts and projects.
Happy New Year to all the readers and friends.

Accidents happen... hoppefully only in 2009

2009-12-30T17:58:00.008+01:00

I apparently only write about my bike(s) when something bad happens, well today I was ran over by a car...
I was comming from Pavillonengracht through the Stille Veerkade, night had just fallen, I was returning home after a small "shop tour" looking for agendas for 2010, a small computer mouse and a couple of pen refills.

View Larger Map
I had my lights on, as I remember turning them on when leaving the last shop. I had the priority and I saw the car waiting, I thought he saw me... Unfortunately he did not! The car hit me on the pedals, lost my balance and fell to the floor on my side and hit the head. I was amazed on how fast the general public reacted, immediately someone came to me, told me not to move and called emergency service. They started talking to me too fast for me to understand, I asked if they could speak in English and they all changed to English. They asked the usual questions, "if I had lost conscience?, pain in the neck?, if I thought I had anything broken?", "No,No,No" I said... the police arrived checked how I was, followed in a few minutes by the ambulance. By then I was pretty sure that I had nothing very serious, but I could have a broken rib.
In the ambulance a quick check was made, nothing broken just some bruises... Blood pressure and pulse a bit high (I think I was in shock), but nothing serious apparently.
Coming out of the ambulance, the police was waiting for ID check and note taking of the accident.
The man that hit me was also a bit nervous, I greeted him told him that I was OK, we exchanged addresses and contacts for the insurance and parted ways. I'll have the bike at the repair shop next week.
My sincere thanks to everyone that helped me, the casual people that called the police and came to help me, the Haaglanden politie and the Emergency Service in the ambulance.
The Kronan was not left in a good shape, she had taken most of the hit... we'll see how she'll recover from this one...

.... Update, after taking the bike to the incompetent bike shop under Den Haag Centraal Station, on the first ride I noticed the frame was bent... really bad... I'm not very hopeful that the bike can be repaired :-( ...

SolarLight (3) - First Prototype

2009-12-19T17:27:00.010+01:00

Well after the initial breadboard, I decided to do some extra work on the Solarlight. I built a perfboard/smd board prototype and as usual I had to do some "adjustments".
Since my ATTiny45U in DIP are "precious" I wanted to use instead one of my ATTiny15L that I had around (a previous buy in ebay).

There are some major differences between the Tiny45 and the Tiny15L:
- Software - the Tiny15L does not have RAM and has a fixed length stack (3), programming it using avr-gcc is difficult and involves "tweaking" the code (see more here). The Tiny15L also does not have the debugwire interface, so debugging is a bit more difficult. Therefore I decided to develop the code in AVRStudio in windows (bah!) in assembler, as much as I like linux the simulators available are still far from perfect. One final remark on the simulator in AVRStudio, always read the notes about your processor, in the case of the ATTiny15L the watchdog is not simulated and the noise reduction sleep/wake-up on ADC conversion complete is not simulated!!
- Hardware - the pins and ADC input PB3/PB4 are switched (mentioned here), the ADC converter internal reference is fixed to 2.56V (ATTiny45U has 2.56V and 1.1V), the ATTiny45U has more power saving options and the frequency of the maximum PLL frequency (important for a high speed converter) is higher on the Tiny45 (8x8MHz=64MHz) than on the Tiny15 (16x1.6MHz=25.6MHz), the CPU clock also higher on the Tiny45 (8MHz) against the Tiny15 (16MHz).

The light is working but there are still some software issues to solve. As I mentioned the ATtiny15L does not have the debugwire interface, in order to debug the project I decided to encode data in the status LED as a bit-banged serial port (like this one), when I want to see a value of a conversion or get a check point or value, I change the code and wait for it to show up on the scope.
I also decided that I had to have a way of forcing a full light mode and a half light mode (both independent of the battery and charging) in case I connected the light using an adaptor (no solar light mode). For this I thought of using this same status pin, curiously this pin is placed between VCC and GND in the programming connector, so a simple jumper could activate these modes in the final product.

SolarLight (2) and gEDA simulation

2009-11-27T13:43:00.012+01:00

An update over SolarLight, I finally managed to print waveforms from ngspice in OpenSuse 11.2 . For some reason the interface is not what you would expect and it has become much more complicated to print a waveform than before.
The first time I installed gEDA from the sources (under OpenSuse 10.3), now I'm using a precompiled version from the OpenSuse Science repository, it could be that the precompiled version has the printer interface "disabled" in some way.
Back to waveform printing, under ngspice one would follow the following path to simulate and plot a waveform:

tran 100n 1.5m
plot v(501),v1000#branch

In the case of the SEPIC circuit of a previous post this would run transient simulation until t=1.5ms with a minimum time step of 100ns (try not to have more than a few thousand simulation points), the second line would open a new window with the output voltage and LED current displayed.
Previously when I pressed in the hardcopy button the print interface would appear and I could chose the printer and/or print to file. Now a message appears in the console:

The file "/tmp/hc4803" may be printed with the Unix "plot" command,or by using the '-g' flag to the Unix lpr command.

If you try the "lpr -g" command either the system complains that it is not supported or that no printer is installed.

lpr: Warning - 'g' format modifier not supported - output may not be correct!
lpr: Error - no default destination available.

After installing plotutils I managed to convert the plotted file (hc4803) to almost any known format (for example postscript or png) with the command:

plot --output-format ps hc4803 > hc4803.ps
plot --output-format png hc4803 > hc4803.png

This allows the plots to be printed and included in documents or webpages, the plot looks something like this:

Then I wanted to try out gwave, gwave is a waveform viewer, part of the gEDA package but its use is far from trivial. First in gwave you must run a simulation and then write the data to a file:

tran 100ns 1.5ms
write plotdata.dta

then run gwave with this data.

gwave plotdata.dta

The interface is far from trivial, I was unable to use colours for the plot and I also had error while trying to print a plot, but at least I could see some waveforms. Results may vary depending on your installed system, but here is a screenshot of the program, the waveforms are in gray on black background:

I'm now temped in building the gEDA toolsuite from scratch... but for that I need some more time...

SolarLight

2009-11-22T23:00:00.012+01:00

Some time ago I had the idea of building a LED lamp that was solar powered, harvesting the Sun during the day and charging the battery, while at night deliver some light. The idea was to extend the hours of light of my peppers during the winter, once the vase was inside the house.

For the initial design I wanted to use two old Ni-Cd batteries and for this supply voltage I would need to use a low voltage oscillator circuit as the minimum voltage would be around 2.0V. The converter would be a boost converter since the Luxeon K2 I had were rated for minimum 2.79V. I started by using a general Boost converter design procedure, and then simulate the circuit in gEDA/SPICE/ngspice.

I stumbled in two problems:
- after some tries with simple transistor oscillator circuits, low voltage comparators, and PWM modulators I decided to use a micro-controller. The biggest problem was the low voltage, even the low voltage circuits shut-down at 3.0V. Then I decided to use a low-voltage micro like the ATTiny45U capable of operating from 1.8V.
-The booster wasn't working, the LED was conducting slightly when the oscillator was off, a known problem with boosters, if the load consumes power at the input voltage minus a diode drop the circuit is always draining the battery.

Finally I decided to redesign the circuit using a 3 element battery, this time a scrap battery from a mobilephone Li-Mh with 3.7V, this would ease the micro selection (Attiny15L that I used before) and I had to change the type of converter to a SEPIC, that allows the use of a battery with a voltage close to the LED conduction voltage. The circuit has the advantage of being capable of boosting or dropping the input voltage, this application note and this one are quite useful for the design phase. Since the load is an LED I allowed a bigger fluctuation in the inductor currents and of the output current, then I chose the operating frequency function of inductors I had available.

Again, after calculating the circuit components I drew a circuit in gEDA and simulated the circuit. As a general design procedure the circuit I use to simulate is very different from the one that I'll build in the breadboard/PCB.

I placed some components inside green boxes to simulate real inductors with series resistance and real capacitors with series resistance. The voltage sources with zero voltage in some branches allow measurement of the current in the branch. I could not find the correct MOSFET (IRLD024) model, instead I used the model (IRFD024) of a similar one but with a different Gate Threshold Voltage. Also as a common procedure to minimize size of the files and speed up processing, I create a smaller library file, containing only the models used. I wanted to show a waveform but since I updated my OpenSuse install to 11.2 I'm unable to print ngspice plots...

After verifying that the circuit worked, I designed the final schematic with the micro-controller and the voltage dividers of the various analog inputs.

The software was straight forward, start the high speed oscillator, start the PWM generator, read voltages, take decisions and increase/decrease PWM output. One note worth mentioning is that the ATTiny85 and the ATTiny15 have two input ports exchanged (Port PB4/PB3 - Pins 2/3) although the ADC inputs are the same!
Here is a couple of pictures of the circuit, the first charging and the second working.

SBC6120 Developments - Casing and altri

2009-11-22T18:07:00.007+01:00

After some consideration I decided not to use the plastic casing I had bought for the SBC6120. I thought that a metal casing would be much more appropriate, I found one from Hammond that could fit the SBC and a hard disk.
I want to use the services of these gentleman to design the front and back plane, but at about 20€ per panel, I might go for the front panel only. I found the old digital equipment corporation logo and I'm using Helvetica to do the "pdp-8".
I plan to use the power adaptor and the internal power supply (+5V,+12V) from an old external hard disk casing. The point is to be able to insert in the case any type of IDE hard disk, 3.5' 2.5' or even Compact Flash.
The SBC6120/OS-8 supports a maximum disk size of 2Mbytes, so with 16Mbytes you'd have the equivalent to 8 hard disks of the time and probably be able to fit all the "interesting" software ever compiled/assembled for the PDP-8.
My problem has been finding a IDE 3.5 inch hard disk with a few megabytes, something in the range of 32/64 Mega bytes... it's becoming almost impossible to find hard drives in the Megabyte range...
So to start with something, I went with a old CF of 64 Megabytes and an IDE adaptor, the SBC6120 recognized the drive. These old CFs were bought in a "spare-parts electronics" shop for 1€.I used HyperTerminal (in Windows) and Minicom (linux) to download an disk image, but I had to change the communication protocol is 9600 baud, 7 bits, mark parity, one stop bit (9600 7M1). I also added 100ms delay after each line feed so that the SBC6120 has time to write the sector. I believe this to be a CF problem as it does not have a disk cache, probably with a real hard disk it will work without the delay.
I've downloaded an image provided in the sparetimegizmos site and the next day I checked if it had loaded ok... Boot the SBC6120, type in a DIR and wait for results... Success!! a directory listing appears...
Now I just need to finish the case, find a hard drive and learn how to work with OS-8 :-)

Peppers update

2009-09-27T14:00:00.006+02:00

My chilly crop has had its ups and downs. Some time ago the leaves of most stems where becoming yellowish and falling, latter the cause was known to be over-watering of the plants. Since reducing the water to once every three/four days (from once every day) the leaves started growing again and of a vivid green color.

When the temperatures are forecast to reach below 5 degrees centigrade during the night I bring the vase inside, otherwise most of the time the vase is outside facing southwest/west.

Nevertheless, our strange looking pepper is only now becoming reddish, it is supposed to be a Jalapeño, but it is curlier than most peppers I've ever seen. Most people don't know but before peppers become red and ripe, they go through a stage where they are mostly brown/black. Since the strange pepper is a bit bigger than most the color transition takes more time and you can see the color grading from green to red going through brown.

The leaves of this particular pepper are still yellowish, but at least they're not falling... I hope it recovers soon and reaches maturity A.S.A.P.

Meanwhile a new flower has open... so probably more peppers are expected for Christmas...

Feeding data to Pachube from Arduino

2009-09-27T10:07:00.004+02:00

After having done the Arduino Home monitor I wanted to put data on a webpage and do some graphics. Alex suggested putting it at Pachube, as he also has some of his house data there and he had an invitation "to offer". (Thanks Alex!).
Patcube can be feed with data by your application from time to time or Pachube's server requests data from time to time to your "Web-enabled-application". Since I wanted to keep my arduino serving my "human-readable-webpages", I thought of creating a "virtual file" that would Pachube would fetch to get the data. On their Tutorial pages, Pachube has a sample application for feeding data from an Arduino to Pachube. The Tutorial example posts data to the Pachube server from time to time. Since I still wanted to keep my normal webserver and check the temperature online I decided to go the other way and create a comma separated values (csv) page that Pachube would fetch.

This was a bit more difficult than I expected. Before to any access to port 80, the Arduino would reply with my info webpage, but now I had to determine which webpage was accessed. I had to parse the GET command from the browser/server and provide the requested page.
After implementing this "virtual file system" I had another hurdle to overcome, Pachube was always complaining that my CSV page didn't have the correct format. After reading the quickstart a few more times and the http/html specification I added the correct header and an empty line at the end, and it finally Pachube started collecting data correctly.

Finally I wanted to increase the precision of the analog to digital converter (ADC) of the Arduino, specially when reading the LM35 temperature. The LM35 outputs 10mV per degree Centigrade so it will output a full volt at 100 degrees Centigrade, in order to increase the resolution of the ADC the reference voltage must be lowered to close the value in range.
The Arduino provides the option of using either an internal reference (of 1.1V), an external reference (selected externaly) or the default supply voltage (5V in the Arduino Duemilanove). The internal reference is 1.1V so it would beter to use it for the LM35, but for the Light sensor the best is the 5V reference.
So I needed to change reference between conversions, there are a couple of problems when trying to change reference. When default is selected there is a low impedance connection between the reference and the ADC, so when the reference is changed the ATMega168 datasheet says that at least one measurement will be incorrect (I do two for safety). The problem with the internal reference is that it has a high impedance connection to the ADC, so any change takes more time to charge referece input of the ADC, the problem is that the datasheet does not say how much... so I change the reference to internal first and wait for the next webpage request and do the temperature conversion first, this increases the precision of the measurements if the webpage requests are not too frequent.


/*
* Web Server
* based on the original webserver example.
* processes the GET command from the http client.
* supports two pages, one readable for humans /info.html other in CSV for computers /csv.html
*/
/*
*==== Typical HTTP request ====
*GET / HTTP/1.0[CRLF]
*Host: www.google.com[CRLF]
*Connection: close[CRLF]
*User-Agent: Web-sniffer/1.0.29 (+http://web-sniffer.net/)[CRLF]
*Accept-Charset: ISO-8859-1,UTF-8;q=0.7,*;q=0.7[CRLF]
*Cache-Control: no[CRLF]
*Accept-Language: de,en;q=0.7,en-us;q=0.3[CRLF]
*Referer: http://web-sniffer.net/[CRLF]
*[CRLF]
*==== Typical HTTP request ====
*/

#include <ethernet.h>
#define DEBUG

byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
byte ip[] = { 192, 168, 2, 253 };
//These were not needed, i.e. without them the ethernet shield works ok with my router
//byte gateway[] = { 192, 168, 2, 254 };
//byte subnet[] = { 255, 255, 255, 0 };

// handle requests at port 80
Server server(80);

// values of temperature and light
long tmprtr,lght;   

char cmmnd;  /* received command = {G|P} for GET or PUT */
char args[20];  /* requested file,arguments */
char host[20];  /* host ip address*/

void setup()
{
  Ethernet.begin(mac, ip);
  server.begin();
  #ifdef DEBUG
  Serial.begin(9600);      // serial port for debug
  #endif
}

//
// Get and convert analog input values
//
void get_values(void)
{
  tmprtr=((long)analogRead(0)*1100)/1024;
  analogReference(DEFAULT);
  analogRead(1); /* discard value */
  analogRead(1); /* discard value */
  lght=(long)analogRead(1)*1000/1024;
  analogReference(INTERNAL);
  analogRead(0); /* discard value - see ATMEGA168 datasheet on change reference */
  analogRead(0); /* discard value - for safety*/
}

//
// Begin of HTML page, fixed page title
//
void http_head(Client & client)
{
  client.println("HTTP/1.1 200 OK");
  client.println("Content-Type: text/html");
  client.println();
  client.println("<html>");
  client.println("<title>Arduino Home monitor</title>");
  client.println("<body>");
}

//
// End of HTML page
//
void http_end(Client & client)
{
  client.println("</html>");
  client.println("</body>");
}
//
// reply to root request or /info.html
//
void http_root(Client & client)
{
  http_head(client);
  client.print("Temperature is ");
  client.print(tmprtr / 10);
  client.print(".");
  client.print(tmprtr % 10);
  client.println("<br />");
  client.print("Light at home is ");
  client.print(lght/10);
  client.print("%");
  client.println("<br />");
  http_end(client);
}
//
// reply to /csv.html
//
void http_csv(Client & client)
{
  client.println("HTTP/1.1 200 OK");
  client.println("Content-Type: text/csv");
  client.println();
  client.print(tmprtr / 10);
  client.print(".");
  client.print(tmprtr % 10);
  client.print(",");
  client.println(lght/10);
  client.println();
}
//
// Work on a http reply, check request file, produce output
//
void http_reply(Client & client)
{
  #ifdef DEBUG
  Serial.println("==== debug out ===");
  Serial.println(cmmnd);
  Serial.println(args);
  Serial.println(host);
  Serial.println("==== debug eot ===");
  #endif
  get_values();
  if ((args[1]=='c') && (args[2]=='s') && (args[3]=='v')) http_csv(client);
  else http_root(client);
}

void loop()
{
  Client client = server.available();
  #define LN_BUF 40
  char inp_ln[LN_BUF]; /* input line, crop at 40 chars */
  char chr;        /* input char */
  byte inp_ln_ptr,i;

  if (client) {
  inp_ln_ptr=0; /* line is empty */

  while (client.connected()) { /* while client is connected process lines */
   if (client.available()) { /* is there a char available */
     chr = client.read(); /* get it */
       if (chr == '\n' && inp_ln_ptr<2) {
          http_reply(client); /* received a blank line, create return page */
          break;        /* exit while, !! find a more logical way to do this */
        }
        if (chr == '\n') { /* end of line */
          inp_ln[inp_ln_ptr]=0; /* end of line */
          Serial.println(inp_ln);
          if ((inp_ln[0]=='G') && (inp_ln[1]=='E') && (inp_ln[2]=='T')) {
            cmmnd='G';
            // get arguments           
            for (i=0;i<sizeof(args);i++) {
              args[i]=inp_ln[4+i];
              if (args[i] == ' ') break;
            }
          }
          
          if ((inp_ln[0]=='P') && (inp_ln[1]=='U') && (inp_ln[2]=='T')) {
            cmmnd='P';
            // get arguments           
            for (i=0;i<sizeof(args);i++) {
              args[i]=inp_ln[4+i];
              if (args[i] == ' ') break;
            }
          }
          if ((inp_ln[0]=='H') && (inp_ln[1]=='o') && (inp_ln[2]=='s') && (inp_ln[3]=='t')) {
            // get arguments           
            for (i=0;i<sizeof(host);i++) {
              host[i]=inp_ln[5+i];
              if ((host[i] == ' ') || (host[i] =='\n') ||(host[i] =='\r')) {
                host[i]='\0';
                break;
              }
            }
          }
          inp_ln_ptr=0;  /* ptr ready for next line */
        } 
        else if (inp_ln_ptr<LN_BUF-1) inp_ln[inp_ln_ptr++]=chr;
      }
    }
    // give the web browser time to receive the data
    delay(1);
    client.stop();
  }
}

When mounted horizontally the Ethernet shield and the voltage regulator produce enough heat to raise the temperature in the sensor to about 30 degrees Centigrade. When placed vertically convection keeps the heat away and the sensor reads more "normal" temperatures.
The Power supply of the Arduino is supplied by the router that has a USB port, this way an extra wall-adapter is not needed.
The pachube feed is here, where you can see both graphics light and temperature. It is also possible to embed the sensor readings in the blog layout...

Building GCC toolchain for AVR

2009-09-15T17:35:00.009+02:00

Recently, along with my Arduino-ethernet-shield I bought a Arduino-Diecimilia fitted with a ATMega328, only to find out that my compiler set-up wouldn't work. A quick investigation (here and here) showed me that my current gcc toolchain (4.2.2) didn't support the '328.
OpenSuse repositories provide an avr-gcc toolchain that can be used with the Arduino IDE for Arduinos fitted with the ATMega8 (very old) to the ATMega168 (old), for the ATMega328 you must build the toolchain yourself (at least for now).
I tried to follow general cross gcc building instructions (more on this on another day), but it didn't work. Using gcc bleeding edge of technology sometimes has its problems. Also there are some patches that must be applied to the source.
So I decided to follow the build script provided by the AVR-Freaks forum. You must become a member in order to download the script. It is still not the latest version of GCC 4.4.1, but it is recent enough (4.3.3) for ATMega328.
The pre-requisites are quite important, you can install binutils-devel (BFD support) from the Opensuse repositories and download the mpfr from here. Compile and install mpfr.

$./configure
$make
$su
#make install
#exit
$

Then run the scripts in order:

$ ./getfiles.sh
$ ./get-patches.sh
$ su
# ./buildavr-no-insight.sh
# ./buildinsight.sh
# exit
$

The build scripts ask you a couple of questions and in the end suggest some clean-up, once it starts you have time for few coffees...
Finally test your configuration:

$ avr-ld -v
GNU ld (GNU Binutils) 2.19.1 + coff-avr-patch (20050630)
$ avr-gcc -v
Using built-in specs.
Target: avr
Configured with: ../../source/gcc-4.3.3/configure -v --target=avr --disable-nls --prefix=/usr/local/avr --with-gnu-ld --with-gnu-as --enable-languages=c,c++ --disable-libssp --with-dwarf2
Thread model: single
gcc version 4.3.3 (GCC)

And you're good to go...

UPDATE: 2011.03.13
I recently installed OpenSUSE 11.3 and redid the installation. It works very well but you still need to do the following (these changes are, or may not be OpenSUSE specific):
- as su create and edit a /etc/bash.bashrc.local, add the following lines:

# User specific environment and startup programs
PREFIX=/usr/local/avr
export PREFIX

PATH=$PATH:$HOME/bin:$PREFIX/bin
export PATH

This will enable all users to access the build tools.
Then you need to do the following:

# chmod 777 /var/lock
# chmod 777 /dev/ttyUSB0
# chmod 777 /dev/ttyS0
# chmod 777 /dev/ttyS1

these last two are for my serialports.. I need to remind myself of doing it for minicom.
and finally create a udev rule for avrisp mk ii.
created a file 89-usbprog.rules in the rules.d directory (as su) and add the lines:

# udev rules file for some usb connected mcu programmers

# Atmel devices
#
ATTR{idVendor}=="03eb", ATTR{idProduct}=="2104", MODE="0666", GROUP="users", SYMLINK+="avrispmkII"
ATTR{idVendor}=="03eb", ATTR{idProduct}=="2103", MODE="0666", GROUP="users", SYMLINK+="avrunknown-%n"
ATTR{idVendor}=="03eb", ATTR{idProduct}=="2107", MODE="0666", GROUP="users", SYMLINK+="avrdragon-%n"

# Microchip devices
#
ATTR{idVendor}=="04d8", ATTR{idProduct}=="0033", MODE="0666", GROUP="users", SYMLINK+="pickit2"

as seen here with minor adaptations and your done...
test it with the arduino-IDE, compile and download the blink example.
test avrisp with a simple command:
avrdude -p t15 -c avrisp2 -P usb

PS. this solution also works

Arduino Home Monitor

2009-09-13T22:20:00.006+02:00

Last week I received my Arduino-Ethernet-shield, although I couldn't use my Decimillia with it (due to a compiler problem), I went ahead with my old NG in order to try it out.
I've build a simple system with a LM35 temperature sensor connected to analog input 0(zero) through a low pass filter (100K/ 100nF) , to measure the ambient temperature.
To measure the ambient lighting I connected to the analog input 1 to the middle point of a simple LDR circuit (LDR in series with a 10K resistor, middle point connected to analog input).

The ethernet shield was the first one issued, based on the W5100 ethernet TCP adaptor. Some of the TCP stack is processed in the W5100 so the Arduino spends less time processing the packets and has some more time to do what you want him to do. Also the libraries included in the Arduino IDE work "out of the box". I added my "breadboard" shield on top of the ethernet shield plug in and went on to try it out.

My program is based on the original "ethernet/analog input" example but I had to do some calibration and conversion from the sensors.
I also tried to change the analogReference during runtime, but I didn't get good results. The LM35CZ output will change from 200mV to 300mV, for 20 degrees centigrade to 30 C respectively, therefore I would get the best of the ADC resolution if I used the INTERNAL reference of 1.1V. For some reason the values were not stable, so I abandoned it and used the 5V reference (DEFAULT) for both measures.
I also tried to "correct" the HTML output so that it could be read by a friend's Freecom MusicPal, but we never made it. I need to learn a bit more of HTML parsing and building the page.
Here is the code:

/*
* Web Server
*
* A simple web server that shows the value of the analog input pins.
*/

#include <ethernet.h>

byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
byte ip[] = { 192, 168, 2, 253 };
//byte gateway[] = { 192, 168, 2, 254 };
//byte subnet[] = { 255, 255, 255, 0 };

Server server(80);

void setup()
{
Ethernet.begin(mac, ip);
server.begin();
}

void loop()
{
long tmp;

Client client = server.available();
if (client) {
// an http request ends with a blank line
boolean current_line_is_blank = true;
while (client.connected()) {
if (client.available()) {
char c = client.read();
// if we've gotten to the end of the line (received a newline
// character) and the line is blank, the http request has ended,
// so we can send a reply
if (c == '\n' && current_line_is_blank) {
// send a standard http response header
client.println("HTTP/1.1 200 OK");
client.println("Content-Type: text/html");
client.println();
client.println("<HTML>");
client.println("<title>Arduino Home monitor</title>");
client.println("<BODY>");
// output the value of each analog input pin

client.print("Temperature is ");
analogReference(DEFAULT);
delay(10);
tmp=((long)analogRead(0)*5000)/1024;
client.print(tmp / 10);
client.print(".");
client.print(tmp % 10);
client.println("
");

analogReference(DEFAULT);
delay(10);
client.print("Light at home is ");
tmp=(long)analogRead(1)*1000/1024;
client.print(tmp/10);
client.print("%");
client.println("
");

client.println("<BODY>");
client.println("<HTML>");
break;
}
if (c == '\n') {
// we're starting a new line
current_line_is_blank = true;
} else if (c != '\r') {
// we've gotten a character on the current line
current_line_is_blank = false;
}
}
}
// give the web browser time to receive the data
delay(1);
client.stop();
}
}

P.S. I had to change the > and < by the html code & g t ; and & l t ; so I don't know if the above code will cut/paste correctly.
Most of my problems were in fact related to the my provider's ADSL access box, it has only one fixed IP address available x.x.x.253 (it must be outside the DHCP range, which I cannot change), and then enabling the routing of port 80 from the outside world to the Arduino in the inside network.
With my IP address I can check the temperature and light levels (?) at home from any computer!(possibly later I could use a free dynamicdns)...
All this in the same weekend we place a new kitchen floor...
Uf... I though it never ended...

The Origin of Species

2009-09-08T17:21:00.005+02:00

Finally I had the time and patience to finish it... It was hard but I got to the end at last! To all those future readers of Darwin's book a few words of advice:
- spare a couple of months, it is not easy ready as there is no action, it is basically a Ph.D. thesis presenting the Hypothesis of evolution and rebating some old (or still existing in revised form) different points of view.
- Naturally the book is biased towards the concept of evolution, when reading try to have an open mind and place yourself in Victorian times.

It was hard but fun, I must admit that I am surprised not only on how our knowledge has evolved (pun intended) but also how some things we now know for sure, were still unexplained at the time.
In the book Darwin suspects that earth started as continuous continent and only later the continents have separated, in order to explain the same species in different continents or in distant islands, we now call it the plate tectonics theory.
The markings in the book are to avoid dog ears in the pages, I try to mark important passages as I go through the book and later revise them..

Arduino NG rev. c

2009-08-06T15:13:00.006+02:00

About a year and a half ago I bought my first Arduino, it was a Arduino NG. At the time it was quite new by the fact that it had a USB port. I did a lot of experiments with it, borrowed it a couple of times and now it is back home.
I never used it with external power until one day I wanted to do an autonomous robot. I programmed some test code, removed it from the USB port, powered the auxiliary power supply (a.k.a 9v battery) and nothing...
The usual debugging technique followed:
- test program with USB, it worked.
- remove from USB, change switch to external, power external and wait...wait..nothing.
- check the web... I found here that the problem existed and already had a solution.
- while browsing "problem Arduino NG" I also found here that the "autoreset" feature of the diecimila had been implemented.
So I picked up the soldering iron, my pack of SMD components and went on to hack the board. So I changed the 3rd resistor from the top and I placed the capacitor just below the RX Led (a reader told me it was very clear what I had really done to the board...)
Here is the final result:

Harvesting the Carrots

2009-08-03T21:56:00.006+02:00

Last Weekend we decided to Harvest my carrots from the vase. When we came back from a week away we noticed that they were not growing that much. We thought that they must have reached their limit in the vase so...it was harvest time... and we were in for some surprises...

The first one out of the vase was "Quasimodo", because we transplanted the carrots some of them had grown into strange forms. Lesson learned.... do not transplant carrots...

This one we really don't know what to call it... or... we do but it's not nice...they are actually two carrots that started in the same yogurt cup and ended up knotted together.Here's a picture of the whole crop, not bad for a single vase. Last but not the least:
This is the way the world ends,
this is the way the world ends,
this is the way the world ends,
not with a bang but with a chicken stew (at least for our carrots).

Back from Holidays - Frappé

2009-07-25T20:03:00.031+02:00

This year we went to Greece, Crete in particular, for our summer get away. It was fantastic, great beaches, great landscapes, great food, great weather, all this and you still can visit some impressive archaeological sites.

It has been some time since I posted about coffee, probably because other than being "surprised" by the excessive price of an expresso, nothing of notice happens outside...
Well in Crete I've found what is probably the only good use of instant coffee... meet the Frappé!.
This is how I do mine, I've talked to some Greek friends and they do it a bit differently...
Put the instant coffee (one or two spoons) and some sugar (with sugar you can do more foam) in a glass and add a few drops (or a table spoon of water).

Use the an electric whisk until you a get a foamy cream.

Whisk until the foam starts getting white in colour.

Add water and ice, a straw and you're done... Instant frappé!

Summer Solstice

2009-07-07T16:50:00.004+02:00

According to Wikipedia this year's solstice was on the 21st of June and it was the "official" begin of the summer. My peppers finally blossomed and I was waiting to get more peppers and earlier than last year. I still hand pollinate them as on this high floors bees or the like are very scarce, on the other hand, Ana's tomatoes just need some wind...

We were having some bugs attacking our crops, specially the parsley, celeriac and the peppers. I took a picture of them and then tried to find something similar on the web. I was also looking for advice on how to biologically get rid of it, since we actually intend to eat our products we didn't want to used any harsh chemicals. The appeared to be an Aphid, but I was not sure it looked more like this one. Here's a picture of a celeriac leaf with the pest.

As with all my plants problems I called mum and dad, experienced "farmers and plant growers", for a cure.... And they delivered, mix the ash of a full ashtray with water, mix it well, filter it through a cloth, put it in the sprayer and "splash them all".
As we are not smokers, I asked Tiago to collect his cigarette ash.. He definitely is not smoking that much (which is very good for him!), this was what he collected in two weeks.

I mixed it with water, filtered it through the cloth, then place it in the sprayer and off I went... A lean, mean, bug killing machine.

Two weeks after, the plant is alive (although the leaf in question has almost dried) and the bugs are gone!
Just great! Many thanks to Tiago, "without whom none of this would be possible" (sort off :-).

Meanwhile my carrots are also growing steadily, some of the tops are popping out... can't wait to get them out... but I need to leave them by one more month...

My DRAM circuit works!

2009-06-02T21:59:00.007+02:00

Well, after some tests I'm confident that my 8085 DRAM interface is working properly!
My first test executed from EPROM and at the end of every instruction fetch cycle does a CAS-before-RAS (C-B-R) refresh.
The second test wrote a value to the DRAM and latter read it back, still executing from EPROM, a C-B-R refresh was done at every instruction fetch.
The third test I tried writing once and read many times, and if at some point the values differed halt the processor (this would terminate refreshing). It worked, no Halts!
On the fourth test I decided to go a bit more ambitious, not only I initialized the stack to the DRAM I also placed a RET instruction in the DRAM. The program in the EPROM would then call the RET instruction and return to EPROM. This would trigger an instruction fetch in the DRAM and respective hidden refresh.
Here's a picture of the execution of the RET instruction and respective hidden refresh, top signal is RAS bottom is CAS.

Done, my "home-made"dynamic ram refresh circuit works, now I'll have to try with other microprocessors...

Solar Cells testing

2009-05-24T19:06:00.003+02:00

This Sunday the sky was clear and the Sun strong, so I decided to check some of the solar cells I had in my components box. I have two types from solarbotics (this one and this other one) and other from pagermotors (this one).

All the cells are up to specification although I only tested them on open circuit voltage, it was too hot and too bright to do a test load. I also have no reason to believe the cells won't perform as specified.
I have two ideas for them:

use one or two white bright LEDs and a couple of batteries to build a "light hours" extender for my chili peppers. I haven't decided yet if I'll use a micro-processor or I try to build a fully analog control system. Either way it will be quite complex as it involves two switching power supplies (charge batteries and supply LEDs) and some operation decision. I'll call this project the "Solar-Extender".
revise the Mousebot to include a solar panel and a couple of rechargeable batteries, this one will definitely have a micro controller. It should harvest the sun and charge his batteries and when the sun is out it should hide in the darkest and coolest place of the house. Put some "simulated annealing" when it wake's up or goes to sleep in order to let him fool around and find some better places. This project I'll call the "Solar-Bug".

I hope to finish these two projects before the end of the summer, as from then on either the behavior of both the projects will be pushed to the maximum efficiency as light-hours decrease towards the winter-equinox.

8085 DRAM interface (30 pin SIMM)

2009-05-24T13:59:00.016+02:00

After seeing this project on Make (or here) I felt like old DRAMs could have a better use... It is a bit sad that so much technology and development by semiconductor engineers and computer designers goes "wasted" on a light box. The light box looks good, don't get me wrong.. but.. so much engineering wasted in a light box... doesn't look right.

I always thought that using these SIMMs in microprocessor applications would be interesting and with the proper memory management it could be used with old 8 bit microprocessors. The likes of Z80, 8085, 6809, 6502 could go with a simple DRAM interface.
Trying to search for information online or even in books, application notes etc is quite elusive, there are three good sources of information:

This one (or here in pdf) is very specific regarding the Z80, and Z180...[...]

This one with a PIC processor connected directly to a DRAM chip (source code only).

And this one, where a FPGA and a 8051 microcontroller are connected to a 72 pin SIMM.

Most of the microprocessor or microcontroller projects online either use one or more large SRAMs (128K,256K and 512K bytes) are these are nowadays readily available.

Although my projects don't need a large RAM size I wanted to probe the use of old SIMMs with the 8085. The Z80 makes it all a bit more simpler because it has been design to use DRAMs, so at the end of the instruction fetch cycle the RFSH and MREQ signals go low, the problem with this that the instruction fetch cycle is slightly (half cycle) shorter (see here).

It seems logical the one would try to do the same in a different processor, while the processor is decoding and executing the fetched instruction the DRAM controller preforms a DRAM refresh, this way every instruction fetch a refresh is performed which normally is often enough. Except, in the 8085 case, if the processor is halted. The Z80 solved this problem by still performing instruction fetches during HALT (it executes NOPs). I decided to carry on accepting this problem and do not write any programs that halt to processor unless I want to lose the contents of the DRAM.

In the 8085 there's no refresh cycle, but at the end of every instruction fetch, during 1 to 3 cycles (depending on the instruction just fetched), the CPU relinquishes the bus, these are called T4,T5 and T6 states (see here). Although a single cycle for refresh might not seem a lot, one could extend the cycle a bit more until ALE goes high, from then on the address on the bus is valid and a normal fetch should be made.

The 8085 does have an slight advantage when compared to the Z80 (and Z8000), the read signal and write signal (RD and WR) are active for the same time weather in instruction fetch, memory read and or memory write (and even I/O these are extended in the Z80), so there's no need for a early-write signal when using the SIMMs.

I designed the circuit as a combination of two sequential circuits, one generating RAS, CAS and Address inputs during a normal read/write and instruction fetch (accessing), and another circuit for refreshing the RAM on every instruction fetch (refreshing). During a instruction fetch from a non-selected memory the last cycle is used to do a CAS before RAS refresh, if the fetch is done from the DRAM, the access cycle is extended to do a hidden refresh (toggle of RAS line while CAS is low). When ALE goes high all DRAM access activities stop and the circuit waits for RD or WR to go low to start the RAS/Address Mux/ CAS sequence. I use the X2 output from the 8085 because it is at 2 times the CLK output, therefore it allows faster state switching and a longer memory access time.

I've designed and assembled the circuit and I'm about to do extensive testing if it really works or not. Here's the schematic of the CAS/RAS generation, the connection to the SIMM is straight forward, the pin-out of a 30-pin SIMM is here, and some of the history of SIMM development is here.

The 8085 is clocked at 8MHz, and on the oscilloscope RAS appears on top and CAS on the bottom. My only problem has been my EPROM emulator, and I need to do something about that in the future. It is only working in DOS... So now I need to do all the programming in DOS and test the system with the oscilloscope. I'm also using the SOD line to trigger the oscilloscope when the SIM instruction is executed, the current program is the following (beware, 8085 assembly follows):

.title test_program 0
.sbttl testing

.area ram(abs,cseg)

.org 0x0000
reset:
di
lxi h,0xC000
lp000:
mvi a,#0xC0
sim
mov a,m
jmp lp001
lp001:
mvi a,#0x40
sim
mov m,a
jmp lp000

SBC6120 Update

2009-05-24T11:43:00.004+02:00

This weekend I started with the finishing touches to my SBC6120. I found what appears to be a "suitable" casing for the board, a power supply and the disk drive.
I would like to build inside a 12V and a 5V switching power supply from a 16-24V DC input, this power supply would allow the system to support either common 3.5 inch IDE drives or the smaller 2.5 inch laptop IDE drives (5V only).
I also need a power switch, a reset switch, access to the status indicators and a DB9 serial port connection.
For now I'm using a 1.4 inch IBM X40 drive and everything appears to fit. I would rather have a bit more room, but the next available case was too big.
I haven't gave up on finding the "best"case, but for that I still need to find a suitable power supply, a some nice looking panel switches (ON/OFF and RESET) and the serial connector.
An old chopping board is not the best background for an electronics project... but then again.. It's what I had at hand..

Follow up on Balcony garden

2009-05-24T11:24:00.006+02:00

Our vegetables have been growing steadily for the past two weeks. I've been moving some of the sprouts that were born in the yogurt cups to the bigger vases, but now I don't have any more space. On some, instead of removing them from the cup, I just cut the cup bottom and push them into the vase.

I learned that carrots don't like and should not be moved! No wonder now that they took so long to adapt, on the other hand tomatoes, kale and the celeriac don't seem to bother being moved and are developing nicely.
On the "battle of the veggies" I seem to be up front in the kale, celeriac and carrots, unfortunately my tomatoes look like little dwarfs compared to Ana's..

Last week my kale reached some "maturity" and before it became too hot to eat a soup we decided to try doing a caldo-verde.

We used some of the bigger leaves of our kale to do it, with some "chouriço" and bread, hum ... delicious...

SBC6120 Assembly

2009-05-07T21:34:00.008+02:00

Some time ago I started looking at a strange (in today's terms) old mini-computer PDP-8 from DEC. It is 12bit machine with one accumulator and program counter, further allows one level of indirection, some models had some memory positions that could be accessed with auto increment and others still had memory paging capabilities.
This mini-computer was so wide-spread that two Integrated Circuit versions of it were produced (IM6100, IM6120) although they came a bit late to a market that progressed beyond the original design.
The book "The Art of Digital Design - An Introduction to Top-Down Design"from Franklin P. Prosser and David E. Winkel describes how to design your own PDP-8 either using normal logic or using a bit slice components, something I would like to build... both versions... :-)
But would I also like to test drive the CPU before I build one, the easy solution would be to find a IM6100 and build it in a bread board... During my search I found that Sparetimegizmos (a company in the US) was selling a kit that included the very hard to find chip! The first time I visited the site it said there were no more ICs, a month ago they had new kits available, so I bought one. They also have front panels but the price tag is bit over my budget, but still very interesting. Here are two pictures the original and the "original copy":

I finished assembly of all the sockets and all the logic ICs, I had some difficulty in finding the IM6402 UART (it is also not cheap), the half-size oscillators, the interface connector and connector that look good on the board, so for now I have a "wrapped version" that I expect to put to work during this week. At least get something on my terminal window :-)
A great thanks to Bob Amstrong and Sparetimegizmos for having the time to design, build and
sell the kit.

Munny Software

2009-05-05T09:52:00.011+02:00

Finally I had the time and the patience to write a "clean version" of the Munny code.
I wanted to use avr-as instead of AVR-Studio, it was much more difficult than what I expected. Information about using avr-as is scarce and I was unable to find an example of an assembler only project for avr-as. The main problem was that when you use preprocessor commands you must use preprocessor comments!
So remember the following:

#define ADC_SETTLE -32 /* arround 20ms */ GOOD
#define ADC_SETTLE -32 ;arround 20ms WRONG

I'm not a web-wizard but I wanted to post the code "online", I tried using google code. Probably I'm not using correctly and I don't think it was designed for such small projects but here is the link to the download.
Because the project might interest to more than one community I also tried to posted the project at the AVRFreaks site, usually the place to search for information when dealing with avr-gcc toolchain but unfortunately I cannot add a file to the project...
Programming the flash is straight forward with avrdude, but programming the oscillator calibration value and the fuses needs some more work. I used the interactive mode of avrdude ( -t) :

read calibration
write flash 0x3ff calibration_value
read flash 0x3ff 0x10

Here is a picture of the PCB during testing:

The software is a bit difficult to understand, the micro is put to sleep most of the time except once once every 32 times of watchdog resets.

Then a temperature measure is made, a port pin is used to power the temperature sensor and the micro is put to sleep for some 20ms, then a analog to digital conversion is started and the micro put to sleep again until the conversion is finished. Then the value is stored and the sensor is powered down (to save maximum power).

The following step is calculating the colors function of the temperature, according to the temperature one of Red, Green or Blue or a mix of two is calculated. Each color has a value of [0..255].

Finally blinking the LED, a software 3 channel pwm controller is created, a counter is incremented every Timer1 output compare and the calculated color values are compared with this running counter. When the counter value is higher than the set value the corresponding LED color is turn off, otherwise turned on. Timer 1 is set to auto reload every 1/25.6 ms this gives a 256 bit resolution every 10ms, this make the colour mixing invisible to the eye. After 100 repeated counter runs the micro goes to sleep until next Watch dog reset.

Dad at his Workshop

2009-04-19T22:31:00.001+02:00

Dad at his Workshop
Originally uploaded by jcferreiradasilva

This Easter we went back to Portugal for a week. Make:Online had a "competition" about workshops... I immediately thought of my Dad's workshop, the most hectic I've ever seen. It's an all in one, Land Rover garage, metal workshop, wood workshop and electrical workshop. Through out the years I've seen many things coming out (and probably many getting in never to be seen again)... From repairing bikes, doing metal stands, from small cabinets to bookcases, welding and metal cutting to fixing a toaster (the current task).
To my Dad, because he deserves it! For trying to build a Galena radio with me when I was 9 (we didn't finish), for teaching me how to ride a bike, for showing me how to do some woodworking, for letting me see him working with the welding machine, for taking me to a factory shop and teach me to watch carefully the machines and keep my hands away from moving parts, for teaching me so much.
tis first on the internet, maybe one day I can push him to blog on his creations or failures.
Obrigado Pai!

Munny Hardware

2009-03-29T21:39:00.009+02:00

A viewer asked to see the schematic and the BoM of the Munny project and finally had the time to do it. I didn't managed to produce a good schematic print, but I'm learning... I'll try to improve it...

The part list is the following:
U1 ATTiny15L (this part is obsolete)
U2 LM35CZ
U3 RGB LED from Sparkfun
R1,R4 10K
R2,R3,R5 100R
C1 10uF 15V
C2,C3 .1uF

I'll try to automate better the parts list with gEDA I'll post it again (using gnetlist ...something) and then I'll try to edit it to include datasheets and link to supplier.
As soon as I manage to assemble the program in linux with avr-gcc (avr-as) or have a C program compiled for the Attiny15 I'll post the software.

7 Segments LCD Displays

2009-03-29T19:18:00.004+02:00

One can always point out some shortcomings of the Arduino platform, it's odd shape and pin location (not breadboard "enabled"), the size of the board (could be smaller), size of RAM/FLASH, etc.
Nonetheless it is a cheap and fast prototyping platform for any electronics enthusiast with some programming knowledge.
Recently my usual electronics shop had a stock clearance of 7 segment LCD displays, available in two digit (two dots) and four digit (three dots and clock colon). I bought two of each and went home trying to figure out how to use them.

Googling 7 segments LCD display pop-up a link to an AVR application note... Bingo!
Turns out you must drive the segments you want to lit up in AC, for that you must alternate the driving of the common and segments at a reasonable frequency.
I use a array to keep the bit patterns for the display as it makes it easier when you have to output one bit at the time.

/*
driving one 7-seg LCD display
value is incrementing every second
every 10ms display positive 10ms then negative
*/

// Data for digits 0-9 g.f.e.d.c.b.a.: 7 BITS ONLY
byte digs[] = { B0111111, B0000110, B1011011, B1001111, B1100110, B1101101, B1111101, B0000111, B1111111, B1101111 };
long previousMillis = 0; // will store last time LED was updated
long interval = 1000; // interval at which to blink (milliseconds)
byte count;

void setup() // run once, when the sketch starts
{
pinMode(9, OUTPUT); // COMMON DISP 2
pinMode(8, OUTPUT); // DISP2 Seg-G
pinMode(7, OUTPUT); // DISP2 Seg-F
pinMode(6, OUTPUT); // DISP2 Seg-E
pinMode(5, OUTPUT); // DISP2 Seg-D
pinMode(4, OUTPUT); // DISP2 Seg-C
pinMode(3, OUTPUT); // DISP2 Seg-B
pinMode(2, OUTPUT); // DISP2 Seg-A
}

void loop() // run over and over again
{
if (millis() - previousMillis > interval) {
previousMillis = millis(); // remember the last time we blinked the LED
if (++count > 9) count=0;
}

output(count,true);
delay(10);
output(count,false);
delay(10);
}

void output(byte a,boolean inv) {
byte val=digs[a];
if (inv) val = !val; // invert DC current
digitalWrite(9,bitRead(val,7)); // COMMON DSP 2
digitalWrite(8,bitRead(val,6)); // DISP2 Seg-G
digitalWrite(7,bitRead(val,5)); // DISP2 Seg-F
digitalWrite(6,bitRead(val,4)); // DISP2 Seg-E
digitalWrite(5,bitRead(val,3)); // DISP2 Seg-D
digitalWrite(4,bitRead(val,2)); // DISP2 Seg-C
digitalWrite(3,bitRead(val,1)); // DISP2 Seg-B
digitalWrite(2,bitRead(val,0)); // DISP2 Seg-A
}

Arduino Suse 10.3 installation

2009-03-17T20:45:00.013+01:00

I had to reinstall SUSE Linux 10.3 in my Laptop and after installing the Operating System the first thing to install was the Arduino development IDE and the AVR cross toolchain.
If you have added Packman repositories just install the following packages, although most are in the Main OSS repositorie:

cross-avr-gcc
cross-avr-binutils
avr-libc
avrdude

The latter is a command line application that programs AVRs (and other micros), it is also useful if you program AVRs outside the Arduino environment.
The really important steps follow, as superuser do:

#chmod 777 /var/lock
#chmod 777 /dev/ttyUSB0

These are also useful when using minicom (/var/lock) and USB serial port to comunicate with RS232 computers (/dev/ttyUSB0).
These instructions were adapted from here, some of the steps are not necessary, others really important.

To use my AVRISP mk II in SUSE 10.3 I needed to change a udev rules to add the device as accessible to every use, I added the following line at the end of /etc/udev/rules.d/50-udev-default.rules :

# AVRISP mk II
SUBSYSTEM=="usb",SYSFS{idVendor}=="03eb",SYSFS{idProduct}=="2104",MODE="0666"

It turns out that it still doesn't work... when trying to use avrdude with the -P usb option it complaints that it was not compiled with USB support...
Uninstall avrdude (keep uisp, avrlibc needs one of them otherwise yast complains), download the sources then configure and install to /opt/cross..

# gunzip -c avrdude-5.8.tar.gz | tar xf -
# cd avrdude-5.8
# ./configure --prefix=/opt/cross
# make
# su
# make install

Test it connecting the AVRISP mk II to an Arduino with the command:

#avrdude -c avrispmkII -p m168 -P usb

Time Lapse Agriculture

2009-03-16T20:21:00.007+01:00

I always thought the one of the great pleasures of being a farmer was to "see plants grow". Maybe I'm too impatient, but after looking at them for 15 minutes and see nothing I decided to try and do a time lapse video.
Ana tried her film first, she used a regular camera and took pictures every 15 minutes for two days (most of it). Later I ordered the pictures, reduced the size and composed the video. In order to keep the same illumination during the day, she used an halogen lamp over the plants. Naturally it is quite clear that this fakes the results and her plants grow super fast...
I decided to use a computer and a webcam to do the job for me. First I tried a logitech quickcam messenger but the resolution was very coarse, it needs special drivers in linux and it does not auto adjust for the brightness.
Next, Tiago borrowed me a Philips Webcam PCVC830K, it worked out of the box in Suse 10.3, resolution is 640x480 and adjusts for the brightness.
I created two scripts, one to take the pictures every 6 minutes and another to compose the video.
Here is the snapshot script:

#!/bin/bash
## adapted from http://mydebian.blogdns.org/?p=261#more-261
## Takes a picture every (wait) seconds and renames it ${now}

# how long to wait between each download
wait=360

## main endless loop ##
while true
do
now=$(/bin/date '+%Y%m%d%H%M%S')

## fetch new webcam shot ##

ffmpeg -s vga -r 1 -t 1 -f video4linux -i /dev/video0 -y plant.jpg
mv plant.jpg "${now}.jpg"
## echo "${now:8:2}" just the hour
echo "${now}"
/bin/sleep $wait

done

Here is the script to compose the video:

#!/bin/bash
mencoder -ovc copy -mf w=640:h=480:fps=15:type=jpg 'mf://*.jpg' -o time.avi

During the shoot I hit the box with the vacuum cleaner, so there's a small shift... be warned. The shoot takes place from Friday night to Monday morning. The plant box is facing south and is close to the TV, so during the night there's a first level of darkness, then when we turn off the TV the only light is the webcam red led. The red led allows us to see some, although little movement.
Here is the video...

New crops!

2009-03-05T21:54:00.006+01:00

Time has arrived to start growing some more vegetables! Sowing should be done outside when you're certain that will be no more frost. Since in Holland you never know... we decided to start growing inside. Me and Ana also decided to "make a competition" to see who would have the best crop! Last Sunday we started, each of us would have a small wooden box with some yogurt plastic cups, we would sow the same seeds, each responsible for his box.. It is easy to see which one is mine (yes, the dirty one).

I placed yellow tags in each cup to know what was inside each of the yogurt cups, the names are in Portuguese, beware. The seeds are Tomato, Parsley, Celeriac, Rucola, Portuguese Cabbage and Araça.

By Tuesday my rucola was already germinating, Wednesday the cabbage was sprouting, today both are steadily growing.

Manual clock input for a digital circuit

2009-02-22T19:45:00.007+01:00

I wanted to test some more advanced programming (i.e. sequential circuits) of the CPLD, sequential circuits need their inputs to have stable transitions, i.e they need to be debounced.
Sequential circuits (synchronous and asynchronous) need debounced inputs, here is a good guide on how and why should one debouce an manual input.

I used the RS Latch method in Figure 1 of the document above, but since I used standard TTL 74 series, inputs floating are considered as "ONE", so I can do without the input resistors. I also tried out the RC filter approach the circuit is depicted on top.

This is a picture of CPLD, the clock circuit (with 2 inputs) and the 4 push button inputs and 4 LED outputs.

Munny DIY - Valentine's gift

2009-02-18T20:57:00.022+01:00

Me and Ana always exchange "things we've done" for Valentine's, this year I got a knitted cap and a scarf. Since my ability to do anything "pretty" is quite limited, I thought about buying something and modifying it.

I saw a mini-Munny from Kidrobot in a local arts shop (Artifac), and I thought of the possibility of making it a bit more "interactive". The mini-Munny is a small DIY toy (you can paint it anyway you like) and made of transparent Vinyl and is available on various colors. I thought of placing a RGB LED that would sense the environment temperature and would change color accordingly. I though of using a Atmel AVR ATtiny15L driving directly a RGB LED from Sparkfun and using a LM35CZ to read the temperature. The ATtiny15L appeared the best option, I had some in my parts boxes, works from 2.7 Volts up, is programmable in circuit and has a ADC converter, useful when the only temperature sensors I have are analog output.
At this time I decided to use a color code for the temperature, blueish tones to cold temperatures (less than 19C), from 19C to 21C greenish, and from above 21C reddish. I placed 100Ohm resistors in each output to the LED so that programming in circuit was still possible, a better selection of resistors could save power but for now it was just enough. The supply of the temperature sensor is connected directly to an micro output, just turning it on when a measure is in progress, I also placed a RC filter on the output of the temperature. The LM35 was what determined the supply voltage and the number of batteries, its minimum operating voltage is about 4V, so I had to use 3 coin cells (4.5V).

The I built a small circuit board, with a SMD version of the Atmel, the LED, the temperature sensor and the ISP connector. I added a small blob of transparent FIMO to mix the output of the LED.

I was luck, the batteries "just fit" Munny's neck and the circuit also "just fits" the Munny's head.

Finally, the circuit is inserted inside the Munny's head and gives a colorful indication of the temperature every 3 minutes... or about...
Here is cold... blueish...

If you want to see more colors and other pictures, Ana has posted some more photos with other colors.
The original idea was an electronic Valentine's card... but I could not find any suitable carrier for it... you can't just give a breadboard to your Valentine's can you!! It was a ATtiny26L and a Nokia3310 display.

Serralves... Meia de Leite (almost a Cappucino)

2009-02-02T21:16:00.006+01:00

I never miss a chance to visit Serralves, the Portuguese Museum of Modern Art in Porto. If don't like the art, or find it too difficult to digest... This was the floor in one of the rooms... I found it disturbing, I could look at it for hours...

But the best seat in the room was taken...

You can always go to any of the three cafeterias in the compound, good coffee, quality savories... Fantastic...
The top restaurant has a reasonable buffet and a great view over the park, the lower floor level cafeteria has a great window facing the grass, very Zen... but probably the top is the Tee House, so 1920's-1930's a Tee house in front of the gravel Tennis court... The perfect place to read the newspaper weekend edition, if you're watching the rain from the inside... very peaceful... Love it!

In Portugal you can have a "meia de leite", litteraly "half milk" the equivalent in the Netherlands would be half of a "Koffie Verkeerd", I've had some Latte's and Machiattos in my day, but there's nothing like a Meia-de-leite. If you want to try it is a long expresso with the same amount of vapor heated milk, it should look like this..

Humidifier Reloaded (Hacked)

2009-02-02T19:46:00.000+01:00

Pedro had a problem with his Venta Humidifier, although it has a nice "discrete" design it lacks one important feature: an external water level indicator. Pedro drafted a small specification of what he wanted, two indicators, one for "almost empty" and another for "empty", if possible when empty stop the motor i.e. cut the power.
I checked the price of a new one (just in case I ruined it beyond recognition) and after taking note of the 114€ price (and they weren't able to add a simple level indicator... shame on you product designers), I went to work.
My first idea was to use a buoy and a lever to externally indicate the level, but it appeared to be too fragile to store and to align the top of the Humidifier, then I though of building a buoy with a magnet and placing Reed switches on the outside of the case.
Having a small tube glued inside was very easy, I had to use hot glue as special PVC glue (in the picture) did not work with the case (clearly not PVC!!).

My original magnet was too heavy, it weighted about 7g and for that I needed about 7cm² of foam supporting it, too much!Then I tried 3 and 4 smaller magnets, about 1g each. Here is a picture of the magnet with the floater and the REED switch on top.

After having the level system I went out to design the electrical system. Initially I planed on using a normally closed reed switch for the power but a switch capable of cutting 230V 0.35A inductive load is impossible to find.
So I had to resort to an additional battery and a relay to invert the signal, the use of the battery made me use an extra power switch to turn off the detection circuit when the Humidifier is stored away.
Two normally open switches, one lighting a green LED when the level is almost at the bottom and a red LED lighting when the level of water is at the bottom and cutting the motor when this happens. The Relay contact is normally closed so that if the battery runs out or Pedro doesn't want it to operate just remove the battery and let it work as previous.

Here's is the finished "product", with the boxed closed and the LED visible.

Here's another picture, just to show the chaos during the creative process... :-)

Linux on Compact Flash

2009-01-26T21:33:00.002+01:00

Recently I bought an used odd Thinkpad X40 in Ebay, it has a French keyboard (ugh!) and a DIY touchscreen, Bluetooth but no WLAN. Since its hard disk was starting to fail I decided to try out and insert a Compact Flash as hard disk. I ordered a 8GB super fast x133 online, but this weekend I could not wait and since 4GB SanDisk's Ultra II were at 24€, I decided to try it now!
I already had a 1.8 inch IDE to compact flash adapter (bought earlier here), in hardware terms it is really plug and play! The BIOS and the computer think that they have a normal (although not hitachi) 4GB hard drive.

I managed to install Suse 10.3 and perform all the updates, it had to be a small install to fit in 4GB but enough to run the familiar KDE and OpenOffice. The installation goes slower than with the normal hard drive, but once you get to the Network update speed is about the same.
Then I edited the file /etc/fstab as according to this page.
Here's what I did:

su
vi /etc/fstab

Then edited the line with the line

xxxdisk-idxxxxx / ext3 relatime,errors=remount-ro 0 1

adding the noatime option. Normally every time you read a file, the time is written back to the drive. The noatime option disables this.

xxxdisk-idxxxxx / ext3 relatime,errors=remount-ro 0 1

Then added the following lines. They move most temporary files to a ram disk.

tmpfs /tmp tmpfs defaults,noatime 0 0
tmpfs /var/run tmpfs defaults,noatime 0 0
tmpfs /var/log tmpfs defaults,noatime 0 0
tmpfs /var/lock tmpfs defaults,noatime 0 0
tmpfs /var/tmp tmpfs defaults,noatime 0 0
tmpfs /var/lib/dhcp3 tmpfs defaults,noatime 0 0

I did not write the line for Mozilla Firefox because I am not sure if Novell/Suse whatever have changed the temporary directory. Another site that looks like having good information is this one.
After the installation and configuration I tested the hard drives for read speed, and the Compact Flash does not come very far behind! But the big test is endurance rather than speed. Here are the screenshots, the top one reports on the current X40 (with magnetic hard drive), the bottom one the test on the compact flash and the listing of the /etc/fstab.

As SU you must run the command:

# hdparm -t /dev/sda1

/dev/sda1:
Timing buffered disk reads: 56 MB in 3.08 seconds = 18.21 MB/sec

The CF disk reported 14 MB/s, which is 22% less... I still think it is not a big gap as with a bigger investment €€€ one could get better transfer rates (there are 8GB cards on the market advertising 30MB/s and more).

I think a good idea would be to have a mixed system on the same card, a compact flash on one side and a 1Gb dram on the other (for temp files, var, log, etc). One of the adapters that I found has a second connector on the back of the card, maybe it could be used with a small microcontroller, FPGA or CPLD to connect to a cheap SDRAM and provide a second volatile disk for all the changing data.

S620 fan "repair"

2009-01-26T20:26:00.002+01:00

Some years ago (2004) I bought my second computer, at the time I wanted a very small desktop computer with parallel and serial port (for my electronics projects), a reasonable number of USB ports (3), audio line in/out and phones/mic, DVD-CDRW, good amount of RAM 768MB and a Celeron D.

I found the S620, it was small computer with acceptable performance, just what I wanted! The computer is now Ana's computer, she uses it to browse the web, store and edit her photos, update her blog and working from home. The computer has two shortcomings, one is that I have to reboot after a save to BIOS (the computer locks), the other is the fan noise. The really noticeable problem of the computer is the fan noise, maybe if I could fit a bit more RAM and a slower processor this could be solved. After a full day of work one could really feel that casing was warm and the Fan working hard.

When we came back from our Christmas holidays I noticed that the computer's Fan stopped working. Ana reported that the computer would start (very silently) but would never completely boot Windows. I tried booting linux and then the over temperature event was sent to the console and the computer stopped booting, after this "hint" I placed my hand on the Fan exit and noticed that no air was flowing! Surely it is a fan fault!! or so I thought... I rushed to buy one only and waited... After placing the new fan the system still did not work!!

I removed the Fan and examined it, and tried it with an external power supply... it worked!! Tried the old fan and it also worked! Then I measured the fan's output pins on the Motherboard, and the power pin had a voltage increase as temperature of the processor was increasing (checked using the BIOS monitor). When the fan was connected this voltage would drop and the fan would not start.
I suspected that "somehow" the output driver to the fan entered shutdown thinking it had a heavy load.
I decided to create a NPN(BDX33) emitter follower (a.k.a voltage follower), using the hard drive's power supply to supply more current and about the same voltage to the fan. The transistor was "fused" to the fan case using the soldering iron going through the case and the hole in the transistors plate.

Kronan lighting

2009-01-25T22:48:00.000+01:00

My Kronan is a simple bike with simple "extras", the headlamp is a filament bulb powered a dynamo, a simple LED tail light and a Kronan bycicle bell.

Since I installed the front cargo fork I had to reroute the power from the dynamo to the alternative location of the headlamp (on the other fork arm).

I noticed that there is a light sensor and when I leave the bike in a shed or I stop the tail light turns off after some time. But my current problem is that sometimes during a long route the light turns permanently off. I had to open the box and see!!

Apparently there's a transistor, a light sensor (top, back of the PCB), a red LED (transparent), a capacitor (bottom, back of the PCB) and an embedded IC. The IC has a blob of plastic (next to the capacitor) over it so no chance of knowing what it is. My current possible culprits are:
the battery connection that has oxidized or the light sensor is not correctly placed and the sensor is influenced by the LED.
Currently I just opened the box, cleaned the contacts and straightened the sensor but I doubt that was the last time I had this problem.

I also had some time so I decided to check if I had any noticeable chain stretch, I folded a new one over the current one while breaking and checked for any big difference after 10 links... so far, everything looks similar (i.e. no noticeable stretch).
I found more sites (here, here, and even in Wikipedia) giving instructions on how to check for chain stretch.

Pea Soup (Erweten soep)

2009-01-25T19:48:00.010+01:00

We tried out "the famous Dutch pea soup" at one of the few really good places in the Hague "'t Hof van Eten", a small place but excellent food for brunches and breakfasts and a kindness of service that you're just not used to in Holland, then we also found another fantastic place "Le Gourmet" serving homemade pea soup, old style Dutch bistro where they serve the pea soup with two slices of rye bread and ham....
We decided to give it a go and do it ourselves... I found a really simple recipe on the net and we were off...
The ingredients are (for about 5 litres of soup):
- 750g-1kg of dried split peas;
- 1 leek;
- 250g of Bacon;
- a couple of carrots;
- one onion;
- a big "Rookwurst";
- one Celeriac root and some celery leaves;

Get a kilo of dried split peas and soak them in water.

Cut the Celeriac root, carrots and bacon into small cubes. Put the bacon in the pan, add some olive oil and let the bacon cook for 2 minutes. Then put the peas, Celeriac and carrots in a big pan with arround 3 litres of water (yep, soup for a week...), and let it boil for about an hour.

Then add the leek in small pieces, the rookwurst and let cook for about 20 minutes... Et voila... Dutch pea soup.

gEDA, Spice and small circuit simulation

2009-01-10T20:23:00.009+01:00

In my "quest" for a suitable Electronic Design Automation set of tools in Linux, I wanted to test the ngspice in gEDA. I started by reading this tutorial.
I designed a simple single transistor amplifier and draw the basic circuit in gschem. The circuit is a commonly called fixed bias circuit with emitter resistor, for transistor I used a general purpose BC548B.
For drawing the schematic one should use the symbols in the spice library and draw the circuit as usual with the following cares:
- you must remember to place a ground in one of the nodes.
- if you want you can (and should) give numbers to nodes you want to keep track, this is done by editing the netname of node, later it is easy to find and plot the voltages of each node.
- it is better to create a separate file with the models of the semiconductors you use, to use it in gschem edit the model attribute and add a file attribute with the library path and name. I found out that using a big library of models and using only one model is not efficient and prone to errors, and most of the libraries need some adjustment regarding the model parameters. It is better to create a specific library file in the current directory (like models.lib) with only the models needed for the simulation.

For converting the schematic into a spice netlist, one must resort to some trickery. I created the following bash script to create it for me, it does a design rule check and then converts the schematic to a spice netlist, then immediately runs ngspice.

#!/bin/bash
gnetlist -g drc2 $1.sch -o $1.drc
gnetlist -g spice-sdb $1.sch -o $1.net
ngspice $1.net

My bash scripting talent isn't great, but it should give an idea of what you need to do. This script expects one argument, the schematic file name without the extension (.sch).
Once in ngspice you can run the circuit interactively with :

tran 10u 10m
plot v(1),v(103)

I didn't found out how to save a plot, so I used a screen snapshot and cut the edges of the picture in GIMP, but here is the final result.

There is some delay and some distortion in one part of the wave and the gain is quite small. The base appears to saturate during the high side and then appears to take its time coming out of saturation. The delay is introduced by the decoupling capacitors (input and output) and the voltage gain is limited by the Rc/Re to 5, but then further divided by Rc parallel with RL, for a total voltage gain of about 2.5.
The charging of the decoupling capacitors is responsible for the apparent lack of gain in the first half wave.

Porto Free Wi-Fi...

2009-01-02T18:27:00.002+01:00

During this Christmas and New Year's break I went back to Oporto, my home town. I needed to keep connected to the internet in a quasi-regular mode. I found some free-WiFi hotspots that I can recommend, they are located mostly in the city center close to the old universities.
Here is a list of caffees and places were Free Wi-Fi is available:

Café Progresso
Plano B
Centro Comercial Parque Nascente
Café Aviz (ask for the password at the counter)
Café Ceuta (ask for the password at the counter)
Café Praia do Titan
Contagiarte

I know for sure that there are many more, if you read this and know of one, please tell me and give me a link(google-location or website) and I'll update the list.
Another thing when it rains in Porto it really RAINS, beware...

AMD, Vantis, Lattice CPLDs

2008-12-22T23:30:00.008+01:00

Many years ago in a far distant galaxy... I bought from AMD the MACH CPLD starter kit, it was small experiment board and a parallel port ISP programmer. Since then the company changed name once and was bought by Lattice. The software "Design Direct" ran in Microsoft Windows 95, I managed to make it work in XP despite the hard disk serial number protection and I've been using it with a MACH131SP for the USBKeyboard.

The reason I'm using the MACH131SP is because last year I bought a box of about 100 in Ebay, so now I have "stock" for the years to come... I had to buy an adaptor for the TQFP 100 in order to WireWrap a simple circuit, the one in the picture was bought in Japan. I soldered the CPLD by hand, it is not very dificult but you need a good soldering iron, good solder, a clean board and a steady hand.
The circuit included a 78L05 to regulate the supply voltage, but I had to bypass it since the CPLD consumes 75mA and the 78L05 limit is 100mA. With most of the inputs floating the CPLD forces the 78L05 into foldback and quasi-shutdown.
The other connector is the 10 pin In System Programmable connector (JTAG), from it I can program a plurality of devices in a JTAG chain.

For connecting power and the ISP connections I used Wire Wrap technique, while for the USBKeyboard circuit I used a special enameled wire. With the Wire Wrap soldering the pins is not mandatory as long as you use correctly the wrapping tool. With the enameled wire a special pen is used to lay the wire, wrapping around the pins you need to connect and then solder must be applied for some time (and temperature) breaking the enameled protection and soldering to the pins.

Mini85 has left the building...

2008-12-22T23:18:00.006+01:00

I decided to dismantle the Mini85 circuit to gain some desktop area for the next year. It was the biggest and more complex breadboard project I've ever done. I did not manage to build it in three standard breadboards, but I still find it small enough. With a single PAL (maybe a 16V8) I'm pretty sure it could fit the three boards.
The next step is use what I've learned from this Mini85 project add it to the PCB design and USBKeyboard and build a eurocard (100x160mm) CP/M computer.
Here is his last picture in this format...Mini85 "will be back" soon... in PCB format...

Joules thief circuit

2008-12-21T18:28:00.005+01:00

Last weekend I started some experiments with the "Joules thief" circuit. The circuit is very simple to make and it should work first time, if not exchange the connections of one of the windings. It works down to 1.2V but it probably works down to 1V. It should be possible to design this circuit with higher efficiency once some of the circuits components are better defined.
Here's a picture of my Joules Thief circuit with a white LED...Some parameters can be determined experimentally, like saturation of the inductor (max ampere turn), gain of the transistor, the frequency of oscillation can be controlled with a capacitor on the base circuit. I've also experimented with a solar cell powering the circuit, but the it needs to be under a strong light.
One of my project ideas was to build an "daylight extender" with a two or three white LEDs, a Ni-Cd battery and a light sensor, maybe with a microcontroller.

Christmas, Winter Solstice and Chili pepper

2008-12-21T10:07:00.010+01:00

Christmas is coming soon! Yesterday were spent the afternoon baking cookies and looking for some last minute presents. Every present is now wrapped and ready to pack. I still have some important things to do in the run up, like cleaning and a major overhaul of the bike(s), packing, cleaning the house etc., but with decent planning we'll be fine!
Today is the winter solstice, the shortest day (daylight) of the year! It is time to celebrate... From now on the days can only get bigger, although it can still get colder... brrr.... It is also the start of the Winter season! We already had the first snow fall in late November, but with only two centimeters of snow... maybe later it gets more interesting.
And now for something completely different...

Our indoor "three vase garden" has been going on. We planted parsley, basil and chili peppers in three vases before this spring. This year, Spring was actually quite warm but Summer was pretty lame, and although our plants grew and some flourished (basil and chili peppers) they did it quite late in the summer. Mid September I had to take the vases indoor as the conditions outside deteriorated. When inside I tried some hand pollination (as I have no bees or flying insects at home) with a cotton bud and as a result I managed to get some basil seeds and to my surprise, one chili!

This week it changed color! it has gone red! I have some projects to extend the light time and control the moisture in the earth, something similar to the garduino project ... but more autonomous and without a full blown arduino and minimal feedback to the user.

Creating a PCB with gEDA

2008-12-07T21:40:00.008+01:00

I always wanted to try out the gEDA tools for producing PCBs and schematics in the Linux environment.
The ongoing mini85 (8085) project is to big for a first try, there are many packages that are not standard in gEDA, many schematic symbols that also do not come standard, there are many ICs in the schematic, these are too many variables to control for a first time.
I needed something smaller, where I could fully test the tools. I decided to use my USBHID Flight simulator control for this project. I would also try out other things like adding a MACH131SP because it is a SMD component, programmable via a ISP connector (also test the software) and test the package outline of a DB9 connector, the power connector and USB B connector.
I want to send the board for fabrication, most of the PCB fabrication houses need a gerber file (none accepts pcb format), but not many details appear in the official tutorial.

The schematic editor has a reasonable sized library, but if a symbol is needed the procedure is quite fast, I used tragesym and the tutorial is here. I redesigned the symbol for the Atmel AVR AT90S2313 (also ATtiny2313), because I prefer to have direct access to the VCC and GND pins and I don't like the crystal oscillator and the reset input in the bottom. Here is the first page of the schematic.

For converting to PCB I downloaded a library from jluciani, it seems very complete... I still have to understand how to use it properly and in conjunction standard libraries. It needs a small modification of the command line of gsch2pcb.

gsch2pcb --use-files --elements-dir ~/footprints SCHEMATIC_NAME

For now I think the footprints provided are suficient, but I'll probably need to draw new footprints for some older PGA microprocessors (when the time comes)...
Another way will be to try the same system with kicad, it also appears to be a good (free) design tool for linux. It has an extra that for now I don't really need which is the 3D view, but who knows latter...

USB keyboard - Flight simulator control

2008-11-18T22:34:00.015+01:00

I wanted to help friend building control panel for a flight simulator "on the cheap". I'm not much into gaming scene but it sounded a fun project, and I could use it for other projects.

The first idea that came to mind was to "hack" or "cannibalize" keyboard controller and connect it to switches. Guilherme also mentioned some sort of visual feedback when the switch is activated. For switches I thought of rocker switches, they look like made to be "air borne" all the time. I passed the "word" that I needed a keyboard to all my friends, and waited... Alex had a folding keyboard that wasn't working anymore, he gave it to me to be "sacrificed"... "may God have mercy on its soul"...

I opened the keyboard and separated the membrane, I marked lines and columns with letters and numbers respectively.

Then I wrote and identified all the keys in the membrane, so I could build a list of correspondence between key and of column, line.

Then I identified one line and one particular column, line is marked black and column is marked red. I marked the key "Q".
Then I wired a switch to the keyboard on the "Q" contacts, the second contact would be used to power the LED when the switch was activated.

Well, it didn't worked out exactly as expected... I toggled the switch and "W" appeared... connected the black wire on the wrong line...

There was another problem, once the switch is activated it keeps writing Ws, not what I intended. I would need some more electronics to translate a toggle of the switch to a single key press...

Then I decided to try another alternative, build my own USB keyboard controller. I knew of a firmware only implementation with AVR micro controllers here, since I had some AVRs in the components box I decided to give it a try.
I started with the HIDKeys project, but since I didn't have a ATmega8 I had to change the project for the ATtiny2313. I started with a breadboard version of the project once the software started running OK (being recognized by the PC), I build a small prototype board.

Development was done on the PC (SUSE linux platform) with avr-gcc and for the programming I used the AVR-ISP mk 2 USB programmer. The source is not final and there are still no switches and output indicators, as soon as I finish something I'll publish it.