The Onion Omega Carputer Can be Controlled via WiFi

The Onion Omega, a curiously named ultra-tiny linux-based WiFi board, is a useful little device for everything Internet of Things related. [Daniel] decided to use it to connect his car to the internet.

Most new cars these days have remote start built in, and slowly, manufacturers are catching up to modern technology and including apps to control various features of their vehicles. But for old cars, there’s not much you can do aside from after-market remote start kits and the likes.

Undeterred, [Daniel] wanted to bring his car into the 21st century by manually adding an extra key fob, a remote start protocol, and a data connection to the vehicle’s on board computer.

Continue reading “The Onion Omega Carputer Can be Controlled via WiFi”

Embed with Elliot: ARM Makefile Madness

To wrap up my quick tour through the wonderland of make and makefiles, we’re going to look at a pair of possible makefiles for building ARM projects. Although I’m specifically targeting the STM32F407, the chip on a dev board that I have on my desk, it’s reasonably straightforward to extend these to any of the ST ARM chips, and only a bit more work to extend it to any ARM processor.

If you followed along in the first two installments of this series, I demonstrated some basic usages of make that heavily leveraged the built-in rules. Then, we extended these rules to cross-compile for the AVR series of microcontrollers. Now we’re going to tackle a more complicated chip, and that’s going to mean compiling with support libraries. While not required, it’s a lot easier to get an LED blinking on the ARM platforms with some additional help.

One of the main contributions of an IDE like Arduino or mbed or similar is the ease of including external libraries through pull-down menus. If you’ve never built a makefile-based project before, you might be surprised how it’s not particularly more difficult to add libraries to your project.
Continue reading “Embed with Elliot: ARM Makefile Madness”

Embed with Elliot: Microcontroller Makefiles

Last time on Embed with Elliot, I began my celebration of the make command’s 40th birthday next month. We discussed using the default rules and how to augment them with your own variables defined in a makefile. Next, I’ll walk you through some makefiles that can be used for real-world microcontroller code development. This week, we’ll focus on one for the AVR platform, and later on, I’ll run through a slightly more complicated version for the ST32M series of ARM Cortex micros.

Along the way, we’ll pick up a couple of tricks, but the aim is to keep the makefiles minimal, readable, and easily extensible. Once you get a little taste of the power of writing your own makefiles, you probably won’t be able to stop adding bells and whistles — custom routines for flashing, checking the size of binaries, generating assembly listings, etc. I’ll leave the extras up to you, but you’ll eventually find that anything you do can be automated with a makefile.

Continue reading “Embed with Elliot: Microcontroller Makefiles”

Microchip Publishes USB Mass Storage Loader

Microchip just published their USB-MSD Programmer firmware. This open source project allows a board to enumerate as a USB Mass Storage device. Programming is as simple as copying a .hex file to the “drive”.

This code is what’s running on the $10 Xpress board that they released last month which includes a PIC18F25K50 to serve as a PICkit On Board (PKOB) programmer for the actual target micro; a PIC16F18855. In its stock version, the XPRESS-Loader firmware programs any PIC16F188xx chips that have a row size of 32 words. But it should be possible to tweak this package to program any chips that use the 8-bit LVP-ICSP protocol.

Now, this may seem like small potatoes at first look: it requires two microcontrollers on your board and is capable of programming just a small subset of the vast PIC inventory. But in our minds it’s the USB-MSD that is killer since it doesn’t require any software or drivers on the computer side of things. That’s a big invitation for all kinds of hacks. But there should be even more on the way from the Xpress team before too long.

It turns out the microcontroller [Voja Antonic] chose to use on the Hackaday | Belgrade badge is the 25k50. Since hearing about the Xpress board we’ve been talking to some of the PIC engineers and they are exploring a loader that will program onto the same chip. This means device upgrades without special hardware or drivers – perfect for badge hacking at a conference. This can be done with a precompiled hex, one created on MPLAB X, MPLAB Xpress, or others. We’ll keep you updated if we hear more on that part of the project.

Breadboard Colecovision

The Colecovision was a state-of-the-art game console back in 1983. Based around the Z-80, it was almost a personal computer (and, with the Adam add-on, it could serve that function, complete with a daisy wheel printer for output). [Kernelcrash] set out to recreate the Colecovision on a breadboard and kept notes of the process.

His earlier project was building a Funvision (a rebranded VTech Creativision) on a breadboard, so he started with the parts he had from that project. He did make some design changes (for example, generating separate clocks instead of using the original design’s method for producing the different frequencies needed).

Continue reading “Breadboard Colecovision”

Serial Telemetry To Wi-Fi With An ESP8266

Hackaday.io user [J. M. Hopkins] had a problem with his rocketry. Telemetry from the rockets came down to Earth via a 433MHz serial link, but picking just the bits he needed from a sea of data for later analysis on a laptop screen on bright sunny days was getting a little difficult.

His solution was to bring the serial data from his transceiver module to an ESP8266, and from that both share it over WiFi and display pertinent information via I2C to an LCD for easy reference. And he’s put the whole lot with a power supply in a rather splendid wooden case with an SMA socket on the back to attach his Yagi.

All information received from the telemetry is passed to a client connecting via Telnet over the WiFi, but pertinent information for the LCD is selected by sending it from the rocket enclosed in square brackets. We hope that the source code will be forthcoming in time.

This isn’t the first time we’ve featured rocket telemetry here at Hackaday. And we’d be missing a trick if we didn’t point out that this project is using our own Hackaday-branded Huzzah ESP8266 breakout board from the Hackaday Store.

Breaking Out The ATtiny10

Atmel’s ATtiny10 is the one microcontroller in their portfolio that earns its name. It doesn’t have a lot of Flash – only 1 kilobyte. It doesn’t have a lot of RAM – only thirty two bytes. It is, however, very, very small. Atmel stuffed this tiny microcontroller into an SOT-23 package, more commonly used for surface mount transistors. It’s small, and unless your ideal application is losing this chip in your carpet, you’re going to need a breakout board. [Dan] has just the solution. He could have made this breakout board smaller, but OSHpark has a minimum size limit. Yes, this chip is very, very small.

Because this chip is so small, it doesn’t use the normal in-system programming port of its larger brethren. The ATtiny10 uses the Tiny Programming Interface, or TPI, which only requires power, ground, data, clock, and a reset pin. Connecting these pins to the proper programming header is easy enough, and with a careful layout, [Dan] fit everything into a breakout board that’s a hair smaller than a normal 8-pin DIP.

The board works perfectly, but simply soldering the ATtiny10 to a breakout board and using it as is probably isn’t the best idea. The reason you use such a small microcontroller is to put a microcontroller into something really, really small like ridiculous LED cufflinks. A breakout board is much too large for a project like this, but SOT23 test adapters exist, and they’re only $25 or so.

Either way, [Dan] now has a very, very small microcontroller board that can fit just about anywhere. There’s a lot you can do with one kilobyte of Flash, and with an easy way to program these chips, we can’t wait to see what [Dan] comes up with.