Tiny Cheap ARM Boards Get WiFi

January 28, 2019 by Brian Benchoff 35 Comments

Over the last few years, we’ve seen the value of putting tiny WIFi-enabled microcontrollers on a module that costs a dollar or two. Those smart light bulbs in your house probably have an ESP8266 in them, and you can build a WiFi-enabled anything with one of these chips for next to no money. Now there’s a new module that takes the design philosophy of, ‘a reasonably powerful microcontroller, on a module, that does WiFi’ to its logical conclusion. It’s the W600 module from Seeed Studios. It’s got an ARM Cortex-M3, it’s FCC and CE certified, it’s got WiFi, and it’s cheap. This is what the people want, so somebody’s got to give it to them.

This product seems to be the followup and/or refinement of the Air602 WiFi Development board released by Seeed late last year. While the module itself grew a few more castellated pins and an RF can, the other specs look to be the same. Compared to the ESP-8266, which this module is obviously competing against, the Air600 is more than capable of pulling its own weight with five GPIO pins that do PWM, a decent amount of Flash, and all the WiFi support you could want.

The W600 is part of an entire family of boards, with the module itself readily available, but there’s also a few breakout boards that add connections for power and serial, a bigger breakout board that’s trying really hard to forget the pin misalignment of the Arduino Uno, and since this is Seeed, a board that connects to everything via Grove connectors. What’s a Grove connector? It’s power, ground, and either I2C or serial over a connector I couldn’t buy the last time I checked.

The W600 and its family of boards will be shipping shortly — China is shutting down for two weeks soon, after all — and there are plans for support for the Arduino IDE, Micropython, and an SDK for the tool chain of your choice.

Is the ESP8266 still the go-to for putting WiFi? Probably. But here’s some more competition.

Open Source Fader Bank Modulates Our Hearts

January 27, 2019 by Kerry Scharfglass 9 Comments

Here at Hackaday, we love knobs and buttons. So what could be better than one button? How about 16! No deep philosophy about the true nature of Making here; [infovore], [tehn], and [shellfritsch] put together a very slick, very adaptable bank of 16 analog faders for controlling music synthesis. If you don’t recognize those names it might help to mention that [tehn] is one of the folks behind monome, a company built on their iconic grid controller. Monome now produces a variety of lovingly crafted music creation tools.

Over the years we’ve written about some of the many clones and DIY versions of the monome grid controller, so it’s exciting to see an open source hardware release by the creators themselves!

The unambiguously named 16n follows in the footsteps of the monome grid in the sense that it’s not really for something specific. The grid is a musical instrument insofar as it can be connected to a computer (or a modular synth, etc) and used as a control input for another tool that creates sound. Likewise, the 16n is designed to be easily integrated into a music creation workflow. It can speak a variety of interfaces, like purely analog control voltage (it has one jack per fader), or i2c to connect to certain other monome devices like Ansible and Teletype. Under the hood, the 16n is actually a Teensy, so it’s fluent in MIDI over USB and nearly anything else you can imagine.

Continue reading “Open Source Fader Bank Modulates Our Hearts” →

WiFi Controlled Finger Dims Lights Over UDP

January 26, 2019 by Eric Evenchick 10 Comments

While WiFi controlled lights are readily available, replacing your lighting fixtures or switches isn’t always an option. [Thomas] ran into this issue with his office lights. For the developers in the office, these lights always seemed to run a little too bright. The solution? A 3D printed, WiFi controlled finger to poke the dimmer switch.

This little hack consists of a servo, a 3D printed arm and finger assembly, and a Wemos D1 Mini development board. The Wemos is a low cost, Arduino compatible development board based on the ESP8266. We’ve seen it used for a wide variety of hacks here on Hackaday.

For this device, the Wemos is used to listen for UDP packets on the company’s WiFi network. When it receives a packet, it tells the servo to push the dimming button for a specified amount of time. [Thomas] wrote a Slack bot to automatically send these packets. Now, when the lights are too bright, a simple message to the bot allows anyone to dim the lights without ever leaving the comfort of their desk. Sure, it’s not the most secure or reliable method of controlling lights, but if something goes wrong, the user can always get up and flip the switch the old fashioned way.

Pocket Forth Invades Your TI Calculator

January 25, 2019 by Al Williams 7 Comments

TI certainly have certainly seen off rivals such as HP or Casio to capture the lion’s share of the calculator market. The TI-84 is a real staple, and with as many units as there are out there, hacking them is a given. However, selecting an operating system for the machine can be a hassle. TI-OS is proprietary and doesn’t really want to let you do everything you’d like to. There are alternatives, but many of them won’t let you easily use your calculator to be — well — a calculator.

[Siraben] has zkeme80 which is essentially ANS Forth (mostly) with extensions for the TI hardware. You can easily extend the system, of course, because it is Forth. You can also use the machine for its intended purpose easily.

Continue reading “Pocket Forth Invades Your TI Calculator” →

Cool Tools: A Little Filesystem That Keeps Your Bits On Lock

January 24, 2019 by Kerry Scharfglass 52 Comments

Filesystems for computers are not the best bet for embedded systems. Even those who know this fragment of truth still fall into the trap and pay for it later on while surrounded by the rubble that once was a functioning project. Here’s how it happens.

The project starts small, with modest storage needs. It’s just a temperature logger and you want to store that data, so you stick on a little EEPROM. That works pretty well! But you need to store a little more data so the EEPROM gets paired with a small blob of NOR flash which is much larger but still pretty easy to work with. Device settings go to EEPROM, data logs go to NOR. That works for a time but then you remember that people on the Internet are all about the Internet of Things so it’s time to add WiFi. You start serving a few static pages with that surprisingly capable processor and bump into storage problems again so the NOR flash gets replaced with an SD card and now the logs go there too. Suddenly you’re dealing with multiple files and want access on a computer so a real filesystem is in order. FAT is easy, so the card grows a FAT filesystem. Everything is great, but you start to notice patches missing from the logs. Then the SD card gets totally corrupted. What’s going on? Let’s take a look at the problem, and how to reach embedded file nirvana.

Continue reading “Cool Tools: A Little Filesystem That Keeps Your Bits On Lock” →

Ben Heck Can Program The Smallest Microcontroller

January 18, 2019 by Brian Benchoff 57 Comments

Microcontrollers are small, no one is arguing that. On a silicon wafer the size of a grain of rice, you can connect a GPS tracker to the Internet. Put that in a package, and you can put the Internet of Things into something the size of a postage stamp. There’s one microcontroller that’s smaller than all the others. It’s the ATtiny10, and its brethren the ATtiny4, 5, and 9. It comes in an SOT-23-6 package, a size that’s more often seen in packages for single transistors. It’s not very capable, but it is very small. It’s also very weird, with a programming scheme that’s not found in other chips from the Atmel/Microchip motherbrain. Now, finally, we have a great tutorial on using the ATtiny10, and it comes from none other than [Ben Heck].

The key difference between the ATtiny10 and other AVRs is that the tiny10 doesn’t use the standard AVR ISP protocol for programming. Instead of six pins for power, ground, MISO, MOSI, SCK, and RST, this is a high-voltage programming scheme that needs 12 Volts. The normal AVR programmer can do it, but you need to build an adapter. That’s exactly what [Ben] did, using a single-sided perf board, a lot of solder, and some headers. It looks like a lot, but there’s really not much to this programmer board. There’s a transistor and an optocoupler. The only thing that could make this programmer better is an SOT-23 ZIF socket. This would allow bare tiny10s to be programmed without first soldering them to a breakout board, but ZIF sockets are expensive to begin with, and the prices on SOT-23 sockets are absurd.

Programming the device was a matter of loading Atmel Studio and going through the usual AVR rigamarole, but Ben was eventually able to connect a light sensor to the tiny10 and have it output a value over serial. This was all done on a device with only 32 Bytes of RAM. That’s impressive, and one of the cool things about the smallest microcontroller you can buy.

Continue reading “Ben Heck Can Program The Smallest Microcontroller” →

Do Other Things Besides Output Video

January 15, 2019 by Bryan Cockfield 18 Comments

Small microcontrollers and tiny systems-on-chips are getting more and more popular these days as the price comes down and the ease of programming goes up. A Raspberry Pi is relatively inexpensive and can do pretty much everything you need, but not every chip out there can do something most of us take for granted like output video. For a lot of platforms, it’s next to impossible to do while saving any processor or memory for other tasks besides the video output itself.

[Dave] aka [Mubes] has been working on the Blue Pill platform which is a STM32F103C8 board. While they don’t natively output video, it’s a feature that provides a handy tool to have for debugging in order to see what’s going on in your code. However, if the video code takes up all of the processor power and memory there’s not much point. [Dave]’s video output program, on the other hand, takes up only 1200 bytes of RAM and 24% of the processor for a 50×18 text display over VGA, leaving a lot of room left for whatever else you need the tiny board to do.

Video output on a device this small and lightweight is an impressive feat, especially while saving room for other tasks. This brings it firmly out of the realm of novelty and into the space of useful tools to keep around. If you want to try the same thing on an ATtiny, though, you might have to come up with some more impressive tricks.

Continue reading “Do Other Things Besides Output Video” →