TV Stick Out-Raspberries Raspberry Pi

Android-based TV sticks should be in more projects. They are readily available and inexpensive. They have a lot of horsepower for the price, and they can even boot a mainline Linux kernel, unlike some single-board computers we know. They’re smaller than the Pi Zero, so they’ll fit almost anywhere.

The one thing they don’t have, though, is I/O. Sure, it’s got a USB port, but that’s just about it. [Necromant] considered these problems and created a carrier board that fixes all that.

  • On-board 3A DC-DC. You can power the whole thing with anything from 7 to 24 volts DC
  • A 4-Port USB hub
  • An ATtiny 2313, connected to the hub via the V-USB stack
  • 2 USB ports on the back, with power control via GPIO lines
  • One USB port on the front (with power always on)
  • 3 relays
  • Fits a common anodized aluminum enclosure

The ATtiny code is on GitHub and allows for full I/O control, saving the state of the pins in EEPROM, and providing up to eight channels of servo control. The device connects through the USB port (consuming one port on the hub).

Repurposing consumer gear for embedded service is nothing new. We’ve seen it with phones. We’ve even seen remotes used as a mouse. But this is such a nice template for adding cheap and easy computing power to your projects that we’re surprised we don’t see it more often. Why aren’t you hacking a TV stick into your projects?

24 thoughts on “TV Stick Out-Raspberries Raspberry Pi

  1. Executed very well! I agree with his comments about the poor form factor of the RPi, but would have to say it was due to cost/size as it originated as an educational tool. However, you would think by now that there would be an RPi equivalent that fits off the shelf extruded enclosures properly as he has done.

    1. “Something out there tells me, that if this post ends up on HaD – most will come here for the girl, and not the PCB or the code.”

      Curious enough to click the link after you posted, saw what you referenced, and then read that. I am amused.

      1. Thanks for the reply. So I guess that on the Linux host, your application would have to use libusb to communicate with the ATTiny? Do you have that code in your github? Just trying to understand the whole picture. Thanks

        1. Yep, libusb, but not directly. I use my own RPC library that has a ‘simpleusb’ backend: https://github.com/nekromant/aura . It simplifies the task, since it has lua bindings.

          Basically, these are the 2 files you need besides libaura:
          https://github.com/nekromant/aura/blob/master/examples/shard-ctl (The script that does the job)
          https://github.com/nekromant/aura/blob/master/simpleusbconfigs/iceshard.conf (The configuration file for aura simpleusb transport)

          I’m also making a web interface for that using jquery-mobile and aura-httpd: https://github.com/nekromant/aura-httpd

  2. Very nicely done! But I’m starting to recoil when I see V-USB in a polished project, or worse, a commercial product. V-USB is a cool hack for non-critical applications. But a couple of bucks more for an ATmega8u2 with free LUFA, and you get a much more capable (and standards-compliant) USB peripheral for the same effort.

    1. Well, so far v-usb has been proven to be VERY reliable to me for most of my projects. The board in the picture above has been sitting connected to the usb bus with no problem in dmesg for over 6 months (!) already and counting, sometimes switching a few times an hour.

      As for the 8-channel servo control, this was an optional feature – I just wanted to test if attiny2313 would be enough to handle it. Since it has only 2 hw output compares, I use hw timer for counting and the whole output-compare logic done in software. The result is crappy at 12Mhz, and working awesome at 20Mhz.

      As for spec compliance, AFAIK if you don’t break them by adding bulk endpoints to your low-speed device, don’t screw up when routing usb data lines, you’re good.

Leave a Reply

This site uses Akismet to reduce spam. Learn how your comment data is processed.