Binary Division When Your Processor Lacks Hardware Division

[Hamster] wanted to take a look at division operations when the chip you’re using doesn’t have a divide instruction. He makes the point that the divide instruction takes a lot of space on the die, and that’s why it’s sometimes excluded from a chip’s instruction set. For instance, he tells us the ARM processor used on the Raspberry Pi doesn’t have a divide instruction.

Without hardware division you’re left to implement a binary division algorithm. Eventually [Hamster] plans to do this in an FPGA, but started researching the project by comparing division algorithms in C on an AMD processor.

His test uses all 16-bit possibilities for dividend and divisor. He was shocked to find that binary division doesn’t take much longer than using the hardware instruction for the same tests. A bit of poking around in his code and he manages to beat the AMD hardware divide instruciton by 175%. When testing with an Intel chip the hardware beats his code by about 62%.

He’s got some theories on why he’s seeing these performance differences which we’ll let you check out on your own.

Lamp Fading And Remote Control For The Lazy

[Dmitry Grinberg] has to walk all the way across his bedroom to switch the lamp on and off. The drudgery of this finally became too much, so he built a remote control and added dimming for good measure. Above you can see the circuitry for the remote and the receiver, as well as the finished remote housed in what he calls a ‘Chinese Altoids tin’.

After the break you’ll find [Dmitry’s] demo video. The remote control is quite responsive, and the dimming has great resolution. That’s thanks to a power N-channel MOSFET which switches the AC with the help of a full wave rectifier. The PIC 12F617 that controls the MOSFET is powered separately, and [Dmitry] mentions that you must use a transformer and not a switch-mode power supply to avoid a fire. We’d like to know more about this, so leave a comment if you are able to explain further.

The remote and receiver communicate via Infrared. The protocol is operating with 38 kHz signals using an easily sourced receiver tuned to that frequency. [Dmitry] shares all the details about the encoding scheme that he uses. Recreating this communications pairing is a great way to test your understanding of this technique. But if you need a refresher, here’s a tutorial to push you in the right direction. Continue reading “Lamp Fading And Remote Control For The Lazy” →

Adding Sound And Light To Your Radio Controlled Vehicles

[Nicholas] wanted to add some flair to his RC car. In addition to the headlights that you see above, there’s brake lights, and a horn that plays “Dixie” like the General Lee in the Dukes of Hazard. All of this is triggered by the wireless controller, but he figured out a way to monitor the servo signals in order to add the additional features.

The hack is driven by a Propeller chip. [Nicholas] patches into the servo lines by adding a servo-in and servo-out header to his prototyping shield. With that in place he’s able to tap into the voltage and ground pins to power the microcontroller. By attaching a 4k7 resistor to the control line, he can listen in on the servo signals using the Propeller.

This RC car has a throttle servo. So when the throttle is opened all the way up the Propeller chip flashes some white LEDs in the headlights, and uses an LM386 audio amplifier to play a tune. When the throttle is pulled all the way back the brake lights are activated. Don’t miss the test footage of this which is embedded after the break.

Continue reading “Adding Sound And Light To Your Radio Controlled Vehicles” →

ANT+ Networks Using An MSP430 Chip And Android Phone

[Jbremnant] wanted to try his hand with ANT+ wireless networks. This protocol is designed for light-weight and low-power consumer electronics, like heart rate chest straps and bicycle computers (Garmin brand devices for example). There are already libraries out there for Arduino, but [Jbremnant] found that most of them were written as slave-only code. He set out to use an MSP430 to drive a fully functioning ANT network including a computer and an Android phone.

The TI Launchpad is used as the master node in the network. [Jbremnant] chose the smaller of the two MSP430 processors that came with the dev platform. After starting down this road he realized that chip didn’t have a hardware UART needed to communicate with the SparkFun ANT board (based on the nRF24AP1 radio chip). Rolling with the punches, he used a software UART he had previously worked with. Now he’s able to transmit test data from the Launchpad. It is picked up by both a USB dongle on his computer and the Android phone seen above. Check out his demo video after the break.

Continue reading “ANT+ Networks Using An MSP430 Chip And Android Phone” →

ARM Programming Primer; Getting The USART Running

We find it interesting that PIC and AVR programming is very common in hobby electronics but ARM doesn’t have nearly the same foothold. This is partly because there’s a knowledge barrier involved with making the transition (the other part is probably the lack of DIP packaged chips). But if you’ve worked with 8-bit microcontrollers you can certainly make the jump into the 32-bit realm. Here’s a great opportunity to get your feet wet. This guide will show you how to get the USART on an STM32 Discovery Board working, which makes it easy to get feedback about what’s going on in your program.

One difference you’ll notice when moving to ARM microcontrollers is that there is almost always a library bundle available from the manufacturer which includes all of the functions you need for hardware control (USART, USB, Ethernet, ADC, etc.). That’s the case here, so simply including the USART library makes it a snap to finish the rest of the program. Once you hook up your communications hardware (an FTDI cable in this case) just use the library initialization functions, followed by the send and receive commands and you’ll be pushing messages to a computer terminal in no time.

If you’re trying to use the STM32 Discovery Board with a Linux box here’s a shove in the right direction.

Full Featured Security Lock Demonstration

[Arshad Pathan] let us know about his latest project, a modular code lock that can be adapted to many different situations.

The user interface is made up of a character LCD screen and a 3×4 keypad. For this example [Arshad] is using a stepper motor as the locking mechanism. When the board is first powered up it runs the stepper in one direction until receiving input from a limiting switch. In this way, the microcontroller calibrates itself to ensure the lock is in a known position. From there it waits for user input. An unlocked door can be locked at any time by pressing the * key. Unlocking requires entry of the correct password. And a password can be changed by entering 9999 (followed by the old password when prompted).

In the video after the break [Arshad] does a great job of demonstrating the various modes which he has programmed. This stands on its own, but we always love to have more details so we’ve asked if [Arshad] is willing to share a schematic and the source code. We’ll update this post if we hear back from him.

Update: [Arshad] sent in a couple of schematics which can be found after the break.

Continue reading “Full Featured Security Lock Demonstration” →

Reading Inputs From Shift Registers Using Just One Single Pin

Here’s an interesting article about reading data from shift registers using less than three pins. 74HC165 shift registers are a popular choice for adding inputs to a microcontroller. They have a parallel input register which can be read using the latch, then shifted into a microcontroller via the data and clock pins. For those counting, that’s the three pins normally associated with driving these devices.

This hack first does away with the latch pin. The addition of a carefully trimmed RC circuit (capacitor is charged by the clock pin, then the resistor lets that cap slowly discharge) means that the device will not latch until after the clock stops toggling. This technique drops the control down to just two pins (data and clock). You can still use hardware SPI to read the data using this method. It’s the same as using SPI to drive 595 shift registers except the microcontroller reads data instead of writing it.

But wait, there’s more! The diagram above actually shows a way of reading this shift register with just one pin. Notice that the clock and data pins are now connected to just one of the microcontroller pins. The data pin has an added resistor, which keeps the current low enough that it will not compete with the clock signal coming from the microcontroller. In between clock pulses, the microcontroller switches from output to input to read the data pin on each cycle. Give it a try, it’s a fun experiment!