Allright, I was playing Skyrim most of the day, and didn’t really have my brain firing at it’s highest level when I sat down and decided to try to put something together. We’ve all been there, right? I realized that I had some of this cool RGB LED strip that I ordered from Tayda Electronics, and it was just lying there, mocking me. So, I embarked upon quite easily the simplest things that I have ever done: cross fading RGB LEDs. Going boldly where everyone has gone before: it’s my motto.

First of all, complete credit must go to Lady Ada and her terrific tutorial on this very subject. I shamelessly copied what she did, and it worked out great. So go there, and read everything she had to say. I’ll just add a few comments:

• The RGB strip cuts very easy, and strips pretty easy too. Be careful to use good ventilation when soldering leads onto this stuff though, as the plastic/rubbery stuff residue doesn’t smell very nice when heat is applied.
• I went ahead and ordered the STP16NF06 MOSFETs that she recommended when I placed my last Digikey order. Price was about $.85 each, which is quite reasonable.
• Tayda’s RGB strip seems like a very good deal, and you could easily use this trip for a wide variety of craft, art, or electronics projects.

To experiment, I cut off four segments (a little under a foot) and soldered on some leads, and wrapped them with electrical tape. Rather than swipe Lady Ada’s code, I quickly penned this up:

[sourcecode lang=”cpp”]
const int rPin = 3 ;
const int gPin = 5 ;
const int bPin = 6 ;

void
ramp(int pin, int from, int to)
{
int i ;

if (from < to) {
for (i=from; i<= to; i++) {
analogWrite(pin, i) ;
delay(5) ;
}
} else {
for (i=from; i>= to; i–) {
analogWrite(pin, i) ;
delay(5) ;
}
}
}

void
setup()
{
pinMode(rPin, OUTPUT) ;
pinMode(gPin, OUTPUT) ;
pinMode(bPin, OUTPUT) ;

analogWrite(rPin, 0) ;
analogWrite(gPin, 0) ;
analogWrite(bPin, 0) ;

ramp(rPin, 0, 255) ;
}

void
loop()
{

ramp(gPin, 0, 255) ;
ramp(rPin, 255, 0) ;
ramp(bPin, 0, 255) ;
ramp(gPin, 255, 0) ;
ramp(rPin, 0, 255) ;
ramp(bPin, 255, 0) ;
}
[/sourcecode]

And it worked the first time! Here’s the YouTube video:

It’s really easy to get the electronics working, and the Arduino and it’s software environment make it so simple. Too simple. I’m sorry to have embarrassed you with this, but perhaps you’ve had a craft or art project that could use some LEDs kicking around in your head, but you haven’t been kicked into action. Perhaps the easiness of this will inspire. If so, my work is done!

Have a good one.

I’ve received a couple of requests for my own Arduino Basic modifications. They are pretty straightforward and small, but might be of some use, and I probably won’t have a chance to do any significant work for a couple of more weeks, so I thought I’d just toss them out there for consumption. This is all based upon Mike Field’s Tiny BASIC, and all the real credit should go to him. I added a few new commands to allow you to do some simple digital and analog I/O, and added a couple of added functions, including one that could be used to figure out how much free space you have left for BASIC programs.

My lightly modified Tiny BASIC source code, for Arduino 1.0

Changes include:

• MODE PIN,[0|1] works like pinMode(pin, INPUT|OUTPUT). Note: to specify analog pins, you need to add 14 to the analog pin number (for the traditional Arduino, I have no idea what the MEGA does).
• DWR pin,value and AWR pin, value act like digitalWrite and analogWrite.
• Two additional functions (ARD(pin) and RD(pin), which should really have been DRD to match DWR) act like digitalRead and analogRead.
• DELAY ms works like, well, delay(ms), duh.
• The FREE(0) function returns how many bytes of program storage are left.
• For reasons which aren’t clear to me, I modified the code to convert all lower case letters to upper case. Change it back if you like.

If you swipe this code and use it for something, let me know below: if someone makes use of my work, it gives me incentive to work on it harder. 🙂

Well, to test my nanode‘s Ethernet capability, I put it on the web! Check it out by clicking this link. Hurrah! Not too impressive, but consider: it is dynamically generated on an eight bit microcontroller that costs about $35, Ethernet included. Perhaps not as cool as the Raspberry Pi, but unlike the Raspberry Pi, you can get a nanode.

But all is not well in the nanode/Ethernet universe either. There appears to be a veritable Pandora’s box of different libraries for Ethernet on the Arduino. This appears to have happened in part because the “official” Ethernet shield is based upon Wiznet W5100, while the nanode (and other inexpensive shields) appear to be based upon the Microchip ENC28J60. I can understand that to a certain degree (the Microchip part is less than $4 in unit quantities from Digikey, and is available in a through-hole PDIP package) but there appears to have been a bit of fragmentation of development even within the ENC28J60 code development. The nanode folks appear to be working with Jeelabs, so I used their EtherCard library which was available via git, and that seems to work pretty well (no changes, worked straight out of the box). The TCP/IP implementation limits HTTP responses to a single packet, so pages have to be small, but is probably sufficient to web-enable a great deal.

I was wondering: is there a more capable implementation that implements multiple packet responses? It seems like it would be helpful for many applications. Any experienced Arduino/Ethernet programmers can respond below. Does the official Ethernet shield provide that capability?

My wife is the best. She listens to me even when I yammer on about the most boring and geeky of topics, and does so with patience and grace. What’s more, she even remembers what I talk about, and I reap the benefits at Christmas time. I mentioned Nanode about a month back, because I thought it was cool: it’s an Arduino compatible kit that sells for about $35. “That’s not so good”, think you. But the cool thing is that it includes Ethernet. It also has a couple of other improvements. It has a double row of pin headers. The inner set are compatible with the (incredibly annoying) irregular Arduino shield spacing, while the outer set are on standard 0.1″ headers which allows you to solder in pins and use it easily on a breadboard. It also includes a space to solder an external SPI memory (SRAM, FRAM, or EEPROM) for additional expansion. Nifty.

Here is my assembled (and functional) nanode:

The instructions say 1.5 hours, it took me a little over two, because I went very slowly and methodically. It’s not difficult, but it’s a fair amount of soldering, and it’s easier to make sure that you do a good job as you go along, rather than spend it debugging later. There were only a couple of minor problems with the instructions: the 22pf ceramic caps shown in the pictorial are actually blue caps in my kit, and the what the instructions showed as blue were in fact little yellow caps. The later required a bit of lead manipulation to get them to fit tidily (their natural spacing was a bit wider than what the PCB has). I didn’t see where they specified to insert the LED’s current limiting 270 ohm resistor, but it was obvious to me at the end where it went. Getting the Ethernet socket in place took a little careful manipulation of the pins. But in the end, it all worked out okay, and when I powered it up, the LED blinked to indicate all was well. I moved my Tiny BASIC interpreter over, and after fixing a minor bug that I introduced the day before but didn’t catch, had it running basic programs to blink LEDS. Huzzah!

It seems like a good kit, really. But there are a few things I thought were odd. The place to solder the SOIC memory expansion is on the bottom. And, in spite of the fact the rest of the kit is entirely through hole, this one is surface mount. That’s not a big deal, but there is something that kind of bugs me: it requires other board modifications to make it work for most of the memory chips I’ve looked at. The problem is that there aren’t any level converters wired to it. The board itself is mixed voltage: 5v for the ATmega328, and 3.3v for the Microchip Ethernet, but this isn’t carried over to the memory expansion. To really make this work, you need to convert the board to run on 3.3V, and that requires hardware mods (replacing the regulators). And frankly, I wish they had. Yes, I understand that some shields need 5v, but the precedent of 3.3v Arduino Pro boards has already been set, and I suspect that much of the complexity of the existing board is in the resistive dividers that it needs. As it is, I think it will actually be simpler to do memory expansion via a small data board that rides on the headers, and includes the necessary level conversion. It also means I can use the PDIP version of the 23K256 chip, which is more breadboard friendly.

I was also surprised that they didn’t include an SD card slot. If you have an Ethernet, one of obvious ideas is to serve webpages, and you need some space to store them. The obvious thing would be a small SD card. I recognize that the board space is at a premium (especially since this kit uses through hole packages for ease of assembly), and this kit is inexpensive, but it still would have been nice. There is a spiffy Arduino-compatible but looks nice: the EtherTen by Freetronics, but to be fair, it costs twice as much and uses surface mount technology.

One other minor gotcha that I encountered was with the “FTDI cable” that came with my order from Wicked Devices. While it is described as an FTDI cable, when I plugged it into my MacBook that I use for Arduino development, it wasn’t recognized, in spite of the fact I’ve used other FTDI cables. It turns out that it’s not actually an FTDI cable: it’s based upon a USB UART converter made by Silicon Labs. Once I dug out the proper drivers, it worked fine, but it might have caused more confusion for beginners.

I will probably use this for more Tiny BASIC experimentation, and/or serving a simple website. If you’d like to get a kit that you can assemble that includes Ethernet, it’s hard to do better at the price point. You can also order them preassembled.

Addendum: I think I see what the problem was, and while I was confused about the specifications: my wife ordered this from Wicked Devices, who are listed as the US distributor for the Nanode. But Wicked Devices only carries the Nanode V5, which is not the most recent revision of the board. The “Nanode Classic” includes most of the changes that I thought the one I have should carry, as well as including an expansion board for RF, but is apparently not available from their US distributors (yet).

As a followup to my post yesterday regarding Arduino BASIC, here’s a contest challenge to extend the Arduino basic to drive the Nanode, an Arduino compatible microcontroller board that extends the conventional Arduino with Ethernet and other cool features. The challenge is to make a good hack using Tiny BASIC: perhaps by extending the BASIC interpreter to include commands for accessing all the additional peripheral devices that the Nanode has. Neat!

Sustainable Suburbia: Tiny Basic running on Nanode – Christmas Challenge

Addendum: It only took me a few minutes of staring at the code to figure out how to add a “DELAY” command that can pause execution. It wouldn’t be hard to add equivalents to the digitalRead, digitalWrite, analogRead and analogWrite. Maybe I’ll give this a try myself over the next few days.