Raspberry Pi Walkie Talkie Mumbles To Friends

His kids wanted walkie talkies, so [Daniel Chote] built one. The TalkiePi is a neat project built around a Raspberry Pi running Mumble, the open-source voice chat system that his kids can share with their siblings and friends.

It’s easy enough to choose the Raspberry Pi, and Mumble is pretty well known. But what’s the easiest way you can think of to add microphone and speakers to the RPi? We applaud [Daniel’s] choice to equip it with the guts of a USB speakerphone. Mumble lets you choose voice activation or keyboard input — in this case an added button makes it push-to-talk, as you would expect in a traditional walkie talkie.

He put all of this into a nicely designed 3D case with a few LEDs, so it is easy to tell that it is ready to transmit. [Daniel] isn’t quite finished yet, though: he’s now working on a new version that is portable, battery powered and uses a Raspberry Pi Zero for the ultimate walkie talkie. We can’t wait to see someone take this to the extreme and include a cellular-modem. But then again, anywhere you can get on WiFi this rig should work, it’s not relegated to a single LAN, and that already far outperforms walkie talkies of yore.

Run a RepRap on an ESP8266

What can’t the little $5 WiFi module do? Now that [lhartmann] has got an ESP8266 controlling the motors of a 3D printer, that’s one more item to check off the list.

What’s coolest about this project is the way that [lhartmann] does it. The tiny ESP8266 has nowhere near the required number of GPIO pins, the primary SPI is connected to the onboard flash memory, and the secondary SPI is poorly documented and almost nobody uses it. So, [lhartmann] chose to use the I2S outputs.

I2S is most often an audio protocol, so this might at first seem like a strange choice. Although I2S sounds like I2C, it’s really essentially an SPI protocol with a fourth wire that alternates to designate the right or left channel. It’s actually just perfect for sending 16×2 bits of data at high data rates.

[lhartmann] takes these 32 bits and feeds them into four shift registers, producing 32 outputs from just the four I2S data lines. That’s more than enough signals to run the stepper motors. And since it updates at 192 kHz sample rate, it’s plenty fast enough to drive them.

The other side benefit of this technique is that it can work on single-board computers with just a little bit of software. Programming very complicated stepper movements then becomes just a matter of generating the right “audio” file and playing it out. [lhartmann] demonstrated this earlier with an Orange Pi. That’s pretty cool, too.

The code for turning the ESP8266 and a short handful of 74HC595s into a 3D printer controller are up on GitHub, so go check it out.

Thanks [CNLohr] for the tip!

Software USB On the ESP8266

A while back, [cnlohr] needed a USB keyboard and mouse. His box ‘o junk didn’t hold this particular treasure, and instead of hopping on Amazon like a normal geek or venturing into the outside realm on a mid-level ‘store’ quest like a normal person, [cnlohr] decided to turn an ESP8266 into a USB keyboard and mouse. How hard could it be? The ESP doesn’t support USB, but bitbanging hasn’t stopped him before. The end result is a USB stack running on the ESP8266 WiFI module.

[cnlohr] has been working for about a month on this USB implementation for the ESP, beginning with a logic analyzer, Wireshark, Xtensa assembly, and a lot of iteration. The end result of this hardware hacking is a board based on the ESP8285 – an 8286 with integrated Flash – that fits snugly inside a USB socket.

This tiny board emulates low-speed USB (1.5 Mbps), and isn’t really fast enough for storage, serial, or any of the fancier things USB does, but it is good enough for a keyboard and mouse. Right now, [cnlohr]’s ESP USB device is hosting a webpage, and by loading this webpage on his phone, he has a virtual keyboard and mouse on a handheld touchscreen.

If you’re keeping track, [cnlohr] has now brought Ethernet and USB to a tiny microcontroller that can be bought for a few bucks through the usual online outlets. If you’d like to build your own ESP USB stick, all the files are over on the Gits.

Thanks [lageos] for the tip.

Continue reading “Software USB On the ESP8266”

Nerd-Bait: ESP8266 + ILI9341 Screen

In honor of my-own-damn-self, we’re going to call it Elliot’s Law: “When any two interesting parts get cheap enough on eBay, someone will make an interface PCB for them.”


And so it is with [Johan Kanflo]’s latest bit of work: a PCB that mounts an ESP8266 module onto the back of an ILI9341 color display, with user button, power supply, and an auxiliary MOSFET. Four bucks for the screen, four bucks for the ESP8266 module, and a few bucks here and there on parts and PCB, and you’ve got an Internet-enabled, full-color, 320×240 graphical display. That’s pretty awesome, and it’s entirely consistent with Elliot’s Law.

However, we almost can’t forgive [Johan] for the extreme geek-baiting. Posting the cuuuute little screen next to a Stormtrooper Lego figure is already hitting below the belt, but displaying a Commodore-64 startup screen, in what’s got to be exactly the right font and color combo, borders on being pathologically emotionally manipulative. You’re playing with our hearts, [Kanflo]!

We love projects like his ESP8266-and-RFM69 mashup and his gutted-Macintosh-planespotter-gizmo, so we’re inclined to forgive. And besides, we’re still on a high from naming our first law and we’re wondering which two eBay parts are up next.

Google Unveils Their Experimental Plan For Wireless Broadband Service

Two years ago, the FCC, with interested parties in Microsoft, Google, and many startups, created the Citizens Band Radio Service (CBRS), a rule that would open up the 3550-3650 MHz band  to anyone, or any company, to create their own wireless backbone between WiFi access points. It is the wireless solution to the last-mile problem, and last year the FCC enthusiastically endorsed the creation of the CBRS.

In a recently released FCC filing, Google has announced their experimental protocol for testing the new CBRS. This isn’t fast Internet to a lamp pole on the corner of the street yet, but it lays the groundwork for how the CBRS will function, and how well it will perform.

Google will be testing the propagation and interference of transmissions in the 3.5 GHz band in places around the US. Most of the Bay Area will be covered in the tests, as well as Boulder, CO, Kansas City, Omaha, Raleigh, NC, Provo, UT, and Reston, VA. Tests will consist of a simple CW tone broadcast in the 3.5 GHz band.

The 3.5 GHz band is already allocated to shipborne navigation and military radar systems, posing an obvious problem to any wireless broadband system using this spectrum. To this end, the FCC is proposing a novel solution to the problem of coexistence between the CBRS and the military. Instead of simply banning transmissions in the spectrum, FCC Chairman Wheeler proposes, “computer systems can act like spectrum traffic cops.” A computer is able to direct the wireless traffic much more effectively than a blanket ban, and will allow better utilization of limited spectrum.

Google’s FCC filing is just for testing propagation and interference, and we have yet to hear anything about how a network built on 3.5 GHz spectrum will be laid out. One thing is for certain, though: you will not have a 3.5 GHz USB networking dongle for the same reason you don’t have a Google Fiber input on your desktop.

We’re Fans of Dave’s Fans

Hackaday.io contributor extraordinaire [davedarko] gets hot in the summer. We all do. But what separates him from the casual hacker is that he beat the heat by ordering four 120 mm case fans. He then 3D printed a minimalistic tower frame for the fans, and tied them all together with a ULN2004 and an ESP8266. The whole thing is controlled over the network via MQTT. That’s dedication to staying cool.

We really like the aesthetics of this design. A fan made up of fans! But from personal experience, we also know that these large case fans can push a lot of air fairly quietly. That’s important if you’re going to stand something like this up on your desk. While we’re not sure that a desk fan really needs networked individual PWM speed control, we can see the temptation.

Now that they’re individually controlled, nothing stops [davedarko] from turning this into a musical instrument, or even using the fans to transmit data. The only thing we wouldn’t do, despite the temptation to stick our fingers in the blades, is to complicate the design visually. Maybe that would finally teach the cat not to walk around on our desk.

[CNLohr], ESP8266, USB…

“Round up the usual suspects…”

[CNLohr] just can’t get enough of the ESP8266 these days — now he’s working on getting a version of V-USB software low-speed USB device emulation working on the thing. (GitHub link here, video also embedded below.) That’s not likely to be an afternoon project, and we should warn you that it’s still a project in progress, but he’s made some in-progress material available, and if you’re interested either in USB or the way the mind of [CNLohr] works, it’s worth a watch.

In this video, he leans heavily on the logic analyzer. He’s not a USB expert, and couldn’t find the right resources online to implement a USB driver, so he taught himself by looking at the signals coming across as he wiggled a mouse on his desk. Using the ever-popular Wireshark helped him out a lot with this task as well. Then it was time to dig into Xtensa assembly language, because timing was critical.

Speaking of timing, one of the first things that he did was write some profiling routines so that he could figure out how long everything was taking. And did we mention that [CNLohr] didn’t know Xtensa assembly? So he wrote routines in C, compiled them using the Xtensa GCC compiler, and backed out the assembly. The end result is a mix of the two: assembly when speed counts, and C when it’s more comfortable.

Continue reading “[CNLohr], ESP8266, USB…”