After several month working of Bee improvements, new PCBs for Jaluino Bee v2.1 have been ordered from SeeedStudio. Several other PCBs have been ordered as well: some more Mini-Crumboard, and a new shield, Mini-ProtoGrove. I’ll post more about all of this when I get PCBs and build new Bees. In the mean time, you can have more details in forums and pre-order PCBs:

• Jaluino Bee v2.1
• Mini-Crumboard v1.0
• Mini-ProtoGrove v1.0

This is a recurrent issue: “my SD card won’t work, I tried the sample, I triple check hardware, it just won’t work”. The main problem here it’s hard to get feedback and report it to jallib library’s author (namely Matt). Different issues were previously found:

• some brands seem to work better than others. For instance, SanDisk is reported to work nice, whereas there seems to have troubles using Kingston’s.
• some SD cards will require pull-up resistors, some won’t.
• and SDHC, high capacity SD card, aren’t supported.

When experiencing SD card for the first time, it’s hard to understand where the issue comes from. You first have to check hardware, make sure connections are OK, add pullups resistors on at least on /SS pin. I’ve recently experienced a hardware issue, whereas I knew for sure it had previously worked. The problem was coming from a non-working connection on microSD socket. Soldering pins again fixed the issue.

Once hardware is checked, you’ll have to make sure your software is properly written, proved to work. Luckily you’ll find fully tested HEX files for Jaluino Bee board on project’s SVN (see hex files). Check correspoding uncompiled Jal files in order to know what’s expected. If your board is following standards (same MCU, Xtal,…), these HEX samples must work. If not, well, check your hardware. If it’s still doesn’t work, maybe it’s coming from your SD card.

You should now run the reporting sample, named “jaluino_bee_sd_card_report.hex” (click on “View raw file” to download it). This is a Jaluino Bee sample that will print, through serial (9600 1N8), some debugging informations while initializing SD card. While this won’t fix your issue, it’ll at least help understanding where you’re stuck, helping developpers fixing the bug (hopefully).

Following is an example showing a successful SD card init:

Basically, sd_init() is called, it tells the card it’ll use SPI protocol. It resets the card, and the card replies “ok” (0×01). It’ll then wait the card to be ready. This means until the card doesn’t reply “00″, it’s not good. In this case, “00″ was returned after seveteen “01″. So far so good, the init is done. More subsequent information is then displayed. Typically, in this case, it’s been reported by Matt that when the card replies “FF” instead of “01″ after resetting the card, it’s mostly a hardware issue. I can confirm this from my last experiment

On the other hand, using the same program with a SDHC card gives:

Unfortunately in this case, we’re getting stuck while waiting for the card to be ready. We’re constantly reading “01″ as a response, while we should have “00″. (careful, don’t mess up with “reply” and “response” terms here. “reply” is the first returned value after reset, while “response” are the returned values while waiting for the card to be ready).

If you’re experiencing SD card problems, please run this sample on your Jaluino Bee board and report your results. Let’s hope with enough data, from different brands & card types, we’ll find how to handle them all !

When I designed first versions of Bee, I mostly used Sparkfun Eagle library, as an habit, and browsed eBay on the other side in order to choose components: one that’s available in Eagle and cheap enough on eBay. By this time, I selected a microSD socket Push-Push type:

These were easily found on eBay, at a decent price, I ordered 5pcs (~$5). Since then, these aren’t available anymore, alternatives sources are much more expensive, something like $3 to $4 per socket. This somewhat kills my low cost approach… Another drawback is pins are under the case, which make this part hard to solder, probably the most difficult one.

Now I have few PCBs left, but no more microSD socket and only half complete kits.

Maybe another socket could be used ?

I recently bought this type: microSD socket with hinge (hinged typed). Price is even lower: ~0.5$/socket.

Good news: this kind of socket can be adapted to Bee v2.0 layout, with minimal changes. Here how it goes…

This is mostly about the two GND pins at the bottom. If you try to place this connector on the PCB, you’ll see these GND pins are very closed to the shield connector’s hole:

But…

• interestingly, the bottom left pin is near GND connector ! Since socket case must be tied to GND, this pin can be soldered with GND hole without harm.
• the bottom right pin is near C5 pin. Using PIC18F27J53, this pin is a USB pin and isn’t exposed to shield connector. Again, it can be soldered without harm. If using PIC18F25K22 (this is my case here), this pin is exposed as this MCU isn’t USB-capable. So the microSD GND pin must be cut in order to make sure it won’t touch to the shield connector.
• on the upper side, another socket’s GND pin is near a GND pad. Can be soldered to it.

If you’re about trying this, don’t trust me and double check connections Give feedback as well.

And in the end, Push-Push socket will have to be replaced in another PCB batch.

You may have heard about “Internet Of Things”, platforms mixing hardware and software projects to publish and share data accross the web. The idea is to have some hardware collecting data, and publishing it on a website. One successful example, open source & free, is ThingSpeak, used here in this post.

So, Jaluino Bee is cheap (~$10 if you build your kit yourself) and that was one main goal while designing it. A reason is the cheaper it is, the more you can put Bees as things in the internet. This is the idea here: collecting electrical consumption from a power device and publish it on ThingSpeak.

Flashing LED (between the two blue buttons)

How does it work ? My electrical counter device had a LED flashing every 1W/h. A photo transistor is used to detect and count these flashes, using interrupts. RTCC peripheral collects timestamps and an alarm triggers another interrupt type every minute. Data is sent over serial, through a bluetooth module.

Photo transistor mounter on power device (ok, quick & dirty)

Photo transistor with small plastic cylinder to focus light from LED.

Bluetooth module plugged on Bee

Application shield, from a Crumboard shield (prototyping area on which you can solder components)

The whole solution: Bee + Bluetooth + Shield, powered by USB

On a server, a python script is receiving data through serial, format it and publish it to ThingSpeak using its API. Python script also initializes RTC date & time on Bee’s side.

Results: on this video, white LED is triggered by flashing LED on electrical counter device. Blue lights are coming from bluetooth module, meaning it’s alive.

Data published to ThingSpeak can be viewed thanks to a very nice web API:

One data point every minute

Does it work ? More or less. The main problem here is the bluetooth link. Server often lost connection, definitely loosing data collecting, mainly due to the distance. Even if few meters away, signal doesn’t seem to be strong enough. A true Xbee module should be tested in order to check performances. As improvement, in order to fully exploit Bee’s capabilities, SD-card should be used to store data in case server isn’t available, then publish them when back. On the previous graph, there seems to be two bad data point showing an extreme consumption, probably not realistic. This probably means flash detection needs some kind of debounce logic (interrupts can be triggered multiple time for one flash…). Finally, features should be added to firmware in order to better configure Bee’s behavior.

More later, for sure…

This is a quick & dirty recipe to build Jaluino Bee v2.0 from a kit. Build your kit at your own risk, I’m not responsible for any damages, you’ve been warned. Twice.

Here we go.

	So, this is typically how a home-made kit looks like…
	Here are the big parts composing the kit: PCB, pin headers, crystals, SD card holder, USB, jumpers, and PIC18F27J53.As opposed to…
	… small, very small SMD components Those are stuck on a paper showing the Bill Of Material (BOM). Make sure to get components, one by one. You won’t be able to identify them (eg. capacitors) once they’re far away from their label.(Thanks to Trev for this great idea)Note: you can access the full BOM in PDF following this link
	Make sure to have the full Jaluino Bee v2.0 schematic somewhere, you’ll have to refer to it quite frequently.
	Here’s the top side of PCB. Refer to this image if you have trouble reading PCB labels.
	Same for the bottom side.
	OK, here we go. You’ll need to thin soldering iron, and ideally a hot air station, particularly useful when soldering the SD card holder.But for now, we’ll build the power supply part. Start to solder micro USB connector. Make sure there’s no shorcut between pins. On this photo, the two most left pins are shorcut, no good…
	Congrats, soldering USB connector isn’t that easy. Let’s continue.Solder C7 tantalum caps (yellow), D2 Schottky diode, AMS117 3V3 voltage regulator, D1 protection diode.Note: tantalum have a bold line showing their anode. It’s not the cathode, as with diodes for instance. Silkscreen for tantalums shows a curved end, this is where the bold line side should go. Zoom the photo as needed.
	Don’t forget to solder 250mA resettable fuse on the bottom side.
	Solder LED1 (power supply LED) with its resistor R5.Solder both 1×3 pin headers, and put jumpers on them, like on the photo. Be careful.The first jumper on the left is to select whether you want the board to be powered using a battery (using the two big pads, refer to top side image), or USB. Putting the jumper as shown on the photo will select USB as power source. This is what we want The second jumper is critical. It selects whether you want to bypass voltage regulation or not. In our case, since USB powered, we have to, we must use voltage regulation, so we put jumper as shown. If we had powered the board using 2xAAA 1.5V barrery, we could bypass regulation as 3V would be enough to power the PIC. Don’t touch this jumper unless you’re sure about what you’re doing, you can burn your board otherwise.
	LEDs are polarized, make sure to respect polarity. LEDs show a small green dot reprenting the cathode (the bar at the top of triangle/arrow).(zoom the photo, you’ll see the green dot…)
	Are you sure everything is good ? Great, let’s give a try. Red LED should light. Make sure you have 3V3 across the board (point pin headers bottom, using GND and Vdd. Also check on PIC’s pads).
	Celebrate this momentum, and admire your red LED. Have a break, breathe gently and deeply.Let’s continue.Solder R1, R6, C13 and push button. This is the reset circuitry. Add decoupling cap C4, LED4 and R20.Then solder C3, C6, C12, onboard LED2 and R2. Then C1, C2, C9, C10, C5.About C12: this is 1µF cap, 0805 form factor, but pads are greater. Just make sure to add enough solder to create connection.
	OK, drink some water, relax yourself, we now have to solder PIC18F27J53. Not that hard, much more esier than USB connector for instance. As usual, make sure there’s no shortcuts, and make sure pins are exposed to pin headers. Careful: no all pins are connected to headers, for instance, USB pins and Xtal aren’t exposed by default.
	The hardest part: SD card holder. Hard because pins are below the component itself. This is where a hot air station is very helpful. But you can still doing this using a soldering iron, and approach the tip below the holder.You can postpone this step if you like. You won’t be able to use SD card (obviously) but you’ll be able to check everything else is ok.
	SD card holder soldered, good job (or not…)You can also solder pullups resistors. These are for SD-card. Sometimes they are useful, sometimes not. Start on the safe side and solder R11 and R12, these are /SS pins for SPI/SD-card and SPI/extra memory chip (if you want to add it later)
	Now solder crystals Q1 and Q2. Make sure Q2 won’t touch surrounding C9/C10 caps
	Almost done !Solder C11 on the bottom side.
	Now configure your board with solder jumper. Solder SJ7 and SJ1. Here were connecting Vusb to Vdd, and select pin A5 as SCK pin in SPI protocol.You can also see on this photo how C12, the 1µF cap, is soldered on big pads.
	If you have a Xbee (and something using the same form factor), make sure to first plug Xbee pin headers before soldering them. Those headers aren’t symmetrical, so if you solder them “randomly” your Xbee may fit as well as it could.So plug your header on your Xbee, position the whole on the board, solder 2 or 3 pins on each pin header, remove your Xbee, and finish soldering.If you don’t have any Xbee modules on the like, I suggest to postpone this step, until you really need it. These pin headers are also very hard to unsolder without damages.
	OK, done ! Celebrate again !Top side should look like this.
	Bottom side should look like this.
	Board is ready to be tested. It can be programmed with PicKit2 for instance, but it needs to be upgraded (dat files).

Where to go now ? You can check Hex files on Jaluino Google Code SVN repository. I’ve been succesfully tested them: http://code.google.com/p/jaluino/source/browse/#svn%2Ftrunk%2Fsamples%2Fhex

Please also give feedback, on Jaluino Group: http://groups.google.com/group/jaluino

I hope you’ll have as much fun as I have designing and using this board.

Jaluino Bee gets listed on Dangerous Prototypes, post your best & fun project and win a Jaluino Bee board !

(but where is v1.0 ?…)

I’ve been working for several months by now on a new Jaluino board, Jaluino Bee. I’ve designed a first PCB (v1.0), tested it with more or less success and now have ordered (and received) a second batch of PCBs (v2.0). From all i could test it seems to work “out of the box”, so now is the time to expose this…

By the time I started to design Bee, I had the following constraint: provide a board as cheap as possible, with several options depending on user’s needs. This is one reason why I switched to SMD components and one main different characteristic from Jaluino Medium, for instance.

So Jaluino Bee is a small, 5cm x 5cm, board, using mostly SMD components. I had two microcontrollers in mind when I designed it: PIC18F27J53 and PIC18F25K22. Both are recent Microchip microcontrollers. 18F27J53 is USB capable, amongst many other very interesting features (RTCC for instance), while 18F25K22 isn’t USB capable but can run very fast (16MIPS). Both are supported by Bee though, I must admit, I’ve been playing much more with PIC18F27J53.

Jaluino Bee v2.0, bottom side

So here some more bullet point specifications. Some are common, others depend on select MCU (18F2550 is here just for the comparison with more modern PICs — and also in case you have one in your box –):

In addition to this list, we can add the following common features:

• Micro SD-Card slot (not compatible with PIC18F2550)
• 3V3 power supply (no more 3V3/5V conversion, most nice little chips/module are 3V3)
• Reset-via-RTS feature
• On-board LED
• Powered by USB and external batteries (can skip voltage regulator to use 2×1.5V AAA batteries)
• Optional pullups placeholders on many pins if your application needs it (well, you can add them on all SPI lines for instance if case you’ve troubles with SD-Cards…)
• Resettable fuse (250mA, on the safe side)
• Xbee socket allowing to plug, well, Xbee modules, but RFBee, Bluetooth Bee modules. Xbee socket also comes with optional
• Amazingly sweet, nice, great looking board :)

Jaluino Bee can also have a optional, extra memory chip (not compatible with PIC18F2550). Depending on the needs, this chip can be (same pinout):

I’ve also designed a small shield, mini-Crumboard shield. It comes with a prototyping area (PTH components) as well as several SMD pads (SOIC, SSOP, SOT, etc…). Hopefully this shield can be used either as a prototyping one, or as a final application shield.

So what now ? Well, when I sourced SMD components, this was a real nightmare… And though you get cheap components, you often get hundreds of them. So I may be able to provide kits. Without extra memory chip, and Xbee module of course, I’d expect such a kit to cost ~$10…

To be continued !

Cuckoo birds are brood parasites, they use other birds’ nests to grow their hatchlings. Mother Cuckoo carefully selects existing nests and puts an egg, only one egg per nest. When Baby Cuckoo hatches, most of the time before other eggs, it just pushes them out the nest. This is its very first instinct, probably not the most rewarding one… Adoptive parents are now only focused on Baby Cuckoo and feed it graciously, with profusion.

This gave me an idea for a new Jaluino family board…

What about mimicing  Baby Cuckoo and pushing ATMega chip out of Arduino ? Then plug a tiny board with a Microchip PIC. This is a fast way, even if not the most rewarding one, to get an Arduino clone, isn’t it ? And a nice way to take advantage of existing boards and features.

So, Jaluino Cuckoo is very small board aimed to be plugged instead of original ATMega168, on an Arduino board. Does it exist ? No, not yet, but this post is about designing this board to match as close as possible Arduino features. Because, like Mother Cuckoo, we first need to carefully observe our nest in order to lay down our egg and make sure it’ll hatch with success.

Overview of Arduino features

Arduino Duemilanove or Diecimila will be the victims, the “cuckooed” boards. Both are using Atmel ATmega168 chip (or ATmega328, pin compatible, more memory) with a 16MHz crystal. Both are offering a wide range of features:

• 14 digital inputs and outputs. Amongst them, some can carry special functions:
  • 2 TX/RX pins for serial communications
  • 2 pins for external interrupts
  • 6 pins carrying PWM outputs
  • 4 pins for SPI protocol
  • 1 pin connected to a LED
• 6 analog inputs. 2 pins, out of these six, can also be used for I²C protocol.
• another pin can be used as a voltage reference,
• and a final one is used to reset.

While matching pins, it’s important to keep in mind this distribution. For instance, PICs can bring at most two PWM channels. At first sight, these two precious channels shouldn’t match an Arduino pin with more than one feature. They could be mapped against PD5, PD6 and PB1. But, maybe, the most used one remains PWM0 on pin PD3 (just because this is the first PWM channel), which is also used as external interrupt. Should we use this pin and potentially miss an interrupt ?

ATmega168 pins are dispatched by port (PB, PC and PD). When looking at an Arduino board, pins go like this:

Which Microchip PIC ?

Now that we had a brief overview of the nest, let’s choose our Cuckoo ! We can specify the following requirements:

• 28 pins, PDIP (easy to solder)
• self-writable (for bootloaders)
• 5V operational voltage
• runs as fast as possible with a 16MHz Xtal
• at least 6 ADC channels, independent (ANSEL-like ADC channel selection)
• 2 PWM channels
• USART
• SPI
• I²C

Microchip product matrix tool found few candidates, amongst them, PIC18F25K22 (big brother 18F26K22 is a big fat one, with 64KB memory, but not in production yet).

18F25K22 is an interesting chip, with a lot of features. It provides 32KB memory, 1.5KB RAM, 256B EEPROM. It has a 4xPLL module and can run up to 64MHz (16MIPS, just like ATmega168). This means its max speed is reached using a 64/4 = 16 MHz xtal, the same one that can be found in Arduino! It also has 19 analog inputs, independent, this will help while dispatching and matching Arduino pins. It also has two CCP modules (two PWM channels, seem to be multiplexed over 4 different pins), two MSSP modules to run SPI and I²C at the same time, two USARTmodules, three 8-bits timers and one 16-bits timer. An interesting chip…

How would Jaluino Cuckoo look like ?

Jaluino Cuckoo can’t be as small as a simple 28-pins chip, because some pins must be mapped, a PCB is needed. But there could be enough space to put a “clever” PCB, plugged instead of Atmel chip, yet having enough space to use a shield. As suggestions received from this jallib thread:

• if a PCB is needed, it could also be used as a standalone board (when Baby Cuckoo leaves the nest ?).
• it could have its own external crystal, with jumper selection (Arduino’s or Cuckoo’s). This would allow to plug a 20MHz xtal, instead of just 16MHz. But, 18F25K22 can also run at 16MHz or 64MHz using its internal clock + 4xPLL, so does it worth it ?
• it could have an ICSP connector, to easily program Cuckoo. I don’t know if Arduino’s ICSP could be used though
• it could also use SMD components, 64-pins, etc… but maybe for a future version to cuckoo Arduino Mega…

How would it plug onto Arduino ? Maybe something like this ?

Cuckoo PCB will have to be cut so it won’t be in contact with ICSP connector (or it could plug on it to actually use it ?). Pin headers could be used in place of ATmega chip. PIC18F25K22 certainly won’t be able to be plugged on these headers as it would be too thick when using a shield. But it can be moved away and hopefully this would leave enough space to put required components.

Now it’s time to draw the schematic and decide how to concretely map pins between Arduino and Jaluino Cuckoo. In a major and critical step, we will have to ensure there’s no physical constraints related to plugging shields with acuckooed Arduino (btw, where’s the reset button ?…). Finally, we will have to justify why creating such a useless board.

Feel free to react, either on this jallib thread http://groups.google.fr/group/jallib/browse_thread/thread/ec6324b87c595531 or by commenting this page.

Jaluino PCBs, directly coming from India thanks to Sunish, will soon arrive at destination (my home), from where they’ll soon be dispatched. This is the first batch order for Jaluino boards, very exciting

This order contains 15 units, 10 being already reserved (to be confirmed). If interested, please contact us on Jaluino Group: http://groups.google.com/group/jaluino

Some photos, more to come…

Stay tuned !

Disclaimer, warnings, caution

Don’t do this, don’t read this, close this page, because what is following will break your Arduino board, it will disintegrate it, it won’t work anymore, you’ll just have to throw it away. Unusable. This is extreme Arduino, this is Forbidden Arduino. Do it at your own risk, if you completely and undoubtedly know what you’re doing, because I’m not responsible in anyway for anything that would occur before, while and after, for decades and decades. And much more.

This is not for the faint of heart.

You’ve been warned.

Twice.

Jaluino Cuckoo PCB design

After several trials, Jaluino Cuckoo PCB has been designed. This wasn’t easy, due to the inherent physical constraints of this design: Cuckoo must be plugged flawlessly onto Arduino while still allowing shields connections. There are some spaces between Atmega connector, crystal, push-button, and shield connector, all were used. This is a double-side PCB, here are some pictures of the final result.

Cuckoo PCB, top view

Cuckoo PCB, bottom view

Most components are on the top side, as usual,only a LED is visible on the bottom side, but this PCB will be plugged upside down, so the bottom side will be the visible one (so the LED will be visible too…).

PCB for real

Thanks to Vasile Surducan, I’ve been able to get two Cuckoo PCB units, made on a CNC router.

There are four vias in Cuckoo PCB, linking top and bottom sides. Because used CNC doesn’t provide through-hole technology, I had to solder a small wire in vias to connect sides together. This really challenged my (poor) soldering skills (and reminds me, if ever needed, to stop trying surface soldering)…

Soldering other components is straight forward. Jaluino Cuckoo is almost finished, only PIC 18F25K22 is missing. For now, it’s not needed as I just want to make sure the concept is viable in terms of physical constraints. Now, let me introduce: Cuckoo !

Cuckoo top side. PIC 18F25K22 is missing.. Male connectors will plugged onto Arduino board.

Cuckoo bottom side. This is the visible side when plugged, that’s why a LED is on this face.

Arduino/Cuckoo, step by step surgery guide

Cuckoo’s ready, now let’s “take care” of Arduino, our parasitic host (victim). Look at your Arduino this is the last time you’ll see it like this…
First, decerebrate Arduino by removing Atmega chip. Use a small screwdriver, act on both sides and, be careful, try not bending pins too much. If surgery fails, you may need to go back (if you can).
Let’s try to plug Cuckoo! Well… not good news. Pin headers seem to be too big to fit in Atmega socket. It”s very hard to plug it. ICSP connector will also be problem as it can be in contact with Cuckoo PCB.
More, crystal caps touch Arduino’s crystal.
Not a problem, caps can “safely” be bended.
Now they aren’t in contact with crystal anymore. One problem solved.
Still, when Cuckoo’s plugged, shields can’t be connected anymore, first because of the LED. I initially wanted to use a squared LED and bend it to preserve space above it, but it seems it’s not even possible. LED has to be moved on the other side.   Even without this LED on the bottom side (remeber, the visible one), shields can’t be connected. Cuckoo has to be plugged some more.
I decided to plug pin headers directly on Atmega socket, without PCB, then plug the PCB and solder headers.
Result seems promising, pins are shorter than before. Cutting remaining wire on the side will save some more space for shields.
About ICSP connector, I can’t cut Cuckoo’s PCB as some tracks are present. But… I can unsolder it! Dirty… This will have to be fixed in another version. On Cuckoo, I’ve also removed jumpers, I’ll have to find smaller ones…
So, how is it now ? Much better…
Shields can now be connected…
… though very little space is available
Removing plastic rows helps Cuckoo to be plugged some more.
More space above, but less space under! PIC18F25K22 will probably need to be directly soldered, without any socket…

Conclusions

Main goal was to verify if Cuckoo concept, unplug Atmega and plug a small daughter board instead, is a viableone. That’s not easy, that’s tricky, but it seems possible. Main problem comes from pin headers. They are too big, making Cuckoo very hard to plug. And I think some more space could be saved if using another type of pin headers (any idea ?). Last photo from surgery steps shows Cuckoo when plugged at maximum. LED is blocking as it’s in contact with Arduino’s PCB. If moved somewhere else, when it could be bend, and/or if using a square shaped LED, Cuckoo might be plugged some more. On the other side, PIC18F25K22 won’t any socket, but I think this is an expensive luxury in this kind of constraint design…

Epilogue

Before: Arduino, fresh, innocent, naive.

After: Jaluino Cuckoo parasite slowly eating Arduino host. That’s Forbidden Arduino!