Touching Conversations: Email Snippets Scroll By on Electro-Embroidery Piece

electroembroidery

[Wei Chieh Shih] really moves the needle when it comes to wearable technology. His textile design project entitled I Am Very Happy I Hope You Are Too is a striking marriage of masterful hand embroidery, delicate circuitry, and careful programming.

[Wei] is using an Arduino micro to drive a matrix of surface-mount LEDs in the Hello, World video, which is a ramp-up to the scrolling text version that’s in progress now finished. That full version is part of his residency project at Arquetopia in Oaxaca, Mexico and displays snippets of emails from his past relationships. It’s huge, with multiple matrices as large as 8×25 pixels!

No build notes could be found for this or any of [Wei]‘s similar projects, like this awesomely dangerous 200 laser diode jacket or this eerily beautiful light installation on Taiwan’s north beach. Based on the pictures, our speculation is that he is using ordinary 6-strand embroidery floss to make stem or half cross-stitches on all the paths. He then runs very thin, flexible conductor underneath the channel of stitches and solders the wires to the component pads.

If [Wei] wants another way to wear his heart on his sleeve, he could investigate these dynamic LED clothing hacks.

Update: [Wei] has completed this project, and has more information available at his Behance site.

Continue reading “Touching Conversations: Email Snippets Scroll By on Electro-Embroidery Piece”

New Contest: Win One of 20 Microchip Fubarino SD Boards

We had a blast with the Trinket Contest in October and November and can’t wait to see what you can come up with for this month’s competition. Microchip Technology is one of our advertisers and they offered us 20 Fubarino SD boards to give away as prizes. The challenge for you is to add our URL as an Easter Egg in your own microcontroller project. Rise to the top of our seemingly arbitrary system for picking winners and one will be delivered to your door for your future hacking pleasure.

Obviously we mean http://hackaday.com when we say URL, but what constitutes an Easter Egg? We figure it’s anything that is not apparently obvious in a piece of hardware. We built a quick example to get you thinking. Shown off in the clip after the break is a clock that displays our web address every day at 1:37pm. What did we pick that time? Because our clock displays in 24-hour time format and 13:37 is leet. See the code we used in our repo.

We thought of a few others, like making an embedded gaming that uses the Konami Code to reveal the Easter Egg, or a man-in-the-middle device that attaches to your keyboard and redirects your feeble attempts to load Facebook by closing the tab and opening Hackaday. The sky’s the limit with how creative these things can be!

Follow these rules to submit your qualifying entry:

  • You must somehow hide http://hackaday.com in your microcontroller project (embedded Linux doesn’t count unless you do some type of bare-metal programming)
  • Preference will be given to projects that are both clever and well documented. Notice we made a video, and posted code and an explanation of our project.
  • Write an email that has “[Fubarino]” in the title, includes the information on your documented entry, and lists your name and mailing address. Your name and mailing address will be used for shipping only and NOT for anything else. Emails should be sent to: contests@hackaday.com
  • Entries must be received before 12:00am Pacific time on 12/19/2013.
  • Employees and their families of Hackaday, SupplyFrame, and Microchip Technology are not eligible to win.

What are you waiting for? Dust off those chips and get hacking!

Continue reading “New Contest: Win One of 20 Microchip Fubarino SD Boards”

Turbot is a Beam/Picaxe Hybrid

BeamBot

[James] wanted to build a BEAM turbot. He ran into some problems with the BEAM circuitry though, and ended up with a BEAM/Picaxe hybrid.
Beam robotics are the brainchild of Mark Tilden. The acronym stands for Biology, Electronics, Aesthetics, and Mechanics. BEAM based bots were very popular with hobbyists in the 90’s and early 2000’s, but popularity has since died down. BEAM robots tend not to use microcontrollers, instead attempting to simplify things down to the lowest number of elements.

[James’] turbot uses a miller solar engine. The original design used the engine to drive a Solar Turbot Latch. [James’] problem was that the photodiode “eyes” of the robot were not properly enabling the 74AC245 to pass current to the motor. Since the robot was built in a tiny space, debugging the circuit was extremely hard. After struggling with the ‘245 for some time, [James] decided to swich out the BEAM circuit for a Picaxe microcontroller.

The Picaxe can only sink or source about 20ma per pin, which is slightly less than the no load current of [James’] motors. To make up for this, he ganged up four pins per motor. There was some risk in the motors blowing up the Picaxe. However between the lightly loaded gearmotors and low current solar panels it seems to be working just fine.  Overall the bot is a very clean, compact build. Jump past the break to check out its really smooth crablike walking action.

Continue reading “Turbot is a Beam/Picaxe Hybrid”

Explaining the low level stuff you don’t know about ARM programming

Most of us don’t realize how spoiled we are with the different development environments available on the internet. If someone wants to start a blank project on a new [ARM/DSP/...] platform, he usually fires up the dedicated Integrated Development Environment (IDE) and starts coding a C/C++ program. However, there are many initialization routines and scripts required with your program before it can run correctly. In his great article, [Andrew] explains to us what these are by starting a blank project without using any IDE.

As you can see in the above picture, [Andrew]‘s project is made around an Atmel SAM4E microcontroller. The chosen toolchain is the arm-none-eabi-gcc from GNU Tools for ARM Embedded Processors. The first part of the article starts with a simplified explanation on how/why your code and variables are split into different memory sections (.bss, .data, .rodata, .text), then [Andrew] details how the linker script will put these sections at different physical addresses depending on your microcontroller’s memory layout. He also shows us how to take care of the stack placement, vector table, variable (non)initialization, and C Runtime. For information, the latter is executed when your processor starts, it is in charge of setting up the stack pointer, initializing the RAM, setting up the standard library and calling the main().

A very nice introduction on the very low level routines running on most processors out there.

Using 30 year old microcontrollers

chips

Like a lot of electronic tinkerers, [Andrew] has a lot of ancient components floating around his parts bin. His latest rediscovery in his cornucopia of components are a few Intel MCS-48 microcontrollers, dating back to 1977. Along with a few old EPROMs, [Andrew] decided it was worth getting these chips running again, if only for a historical curiosity.

[Andrew]‘s had a few Intel 8035L microcontrollers on his hands, but this particular model of MCS-48 micros lacks any way to store code. This is where the EPROMs come in. With a modern EPROM programmer, [Andrew] was able to write some code to the extremely common for their vintage 27256 EPROMs. Erasing them, though, does require a UV lamp.

With the ROM programmed and the chips connected, [Andrew] was able to make a simple blinking LED circuit. Sure, it’s the simplest thing you can do with a microcontroller, but [Andrew]‘s off to a great start in his explorations of older hardware.

Wireless microcontroller/PC interface for $3

uc

Sending data from a microcontroller to a PC usually requires some sort of serial connection, either through fiddly on-chip USB, FTDI chips, or expensive radio ICs. [Scott] didn’t want to deal with this when creating a network of wireless temperature sensors, so he hacked up a few cheap 433 MHz radio transmitters and receivers to transmit data to a PC for about $3.

After sensor data is collected on a microcontroller and sent over radio, there’s still the issue of getting it into a PC. For this, [Scott] piped the data into the microphone port of a cheap USB sound card. We’ve seen this trick before both in the world of microcontrollers and loading programs onto a Commodore 64 via a cassette interface.

Once the data is sent into the sound card, it’s decoded with a a small Python app. Given the range and quality of the RF transmitters and receivers  [Scott] says it’s not an extremely reliable way to send data to a PC. It is cheap, though, and if you need to read sensors wirelessly on a budget, it’s hard to do much better.

Check out [Scott]‘s demo of his creation below.

Another salvo in the PIC vs. AVR holy war

Ah, PIC vs. AVR, the never-ending battle of electronic design supremacy. Some people swear by Atmel’s AVR microcontrollers, while others are wrong. [majenko] is firmly planted in Microchip’s PIC camp, so he wrote up a nice comparison of Atmel’s AVR versus Microchip’s PIC family of microcontrollers. The results aren’t that surprising; PIC microcontrollers come out as a better product that no hobbyist uses because no hobbyist uses them.

Atmel and their series of AVR microcontrollers has seen a huge increase in popularity in the hobbyist market in the last few years, no doubt thanks to the Arduino and other AVR-powered dev boards. This isn’t to say Microchip and PIC haven’t seen their time in the lime light; there was a time when you could actually buy electronic components at Radio Shack, including kits containing Microchip’s very popular but somewhat outdated Basic Stamp.

After going over the capabilities of the Atmel AVR ATMega328p, the similarly equipped Microchip’s PIC PIC18F25K80, and TI’s MSP430G2533, [majenko] found the perennial favorite, the AVR, lacked in some very important categories. The AVR has a lower resolution ADC, fewer PWM pins, fewer 16-bit timers, while costing about $0.75 more.

Of course [majenko]‘s analysis doesn’t take into account the intangibles of choosing a PIC over an AVR. Thanks to the Arduino’s adoption of the AVR, there are many, many more code and schematic examples floating around on the Internet for just about every project imaginable. The development tools for PIC are a bit more expensive than their AVR equivalents; A PICkit2 runs about $50 while AVR ISP programmers can be found just about everywhere for pocket change.

It’s a lazy Sunday, so all ‘yall can go on and argue in the comments.