1 2 3 Previous Next

Open Source Hardware

38 posts
Drew Fustini

Open Hardware Summit 2015

Posted by Drew Fustini Nov 13, 2015

OHS 2015

2015 Summit Session Recordings Now Available!

Videos of Open Hardware Summit 2015 talks are now online:

2015 Summit Early Morning Sessions

2015 Summit Late Morning Sessions

2015 Summit Early Afternoon Sessions


2015 Summit Late Afternoon Sessions

There are photos of OHS 2015 on Flickr:

OHS 2015 group photo



  To draw PCB layout is an essential ability for electronic engineer .

  We could use many tools for PCB Layout , Altium Designer, Kicad, PADS,and so forth .But for a reason that these software are all desktop-based , you need to install it on your PC or may need to pay for the software .EasyEDA provides a feasible way to draw schematic and PCB online ,without installing a software on your PC , and you could also save it on the cloud server and share it to all the internet users in the meantime .You could utilize all the internet components Lib and PCB Lib on the internet , you could edit the Libs and add them to your Part. You could also utilize the accomplished module in the System Design or the User’s Design. That really accelerates your speed to accomplish a Project . Furthermore, you could add the PCB Layout to Your CART and pay for it with low cost for the PCB order . That is an easy way to accomplish your Project from Concept Design ,Schematic Design to PCB Design and PCB order .

  Let me introduce how to make PCB Layout out of an online schematic design on EasyEDA , an free online schematic design Tool ,spice simulation tool, PCB Design tool .

  We need to Firstly create a Schematic .

  Let us create e a DC/DC Converter schematic as followed.

schematic design



      The schematic consists of a power management IC LM2596s-ADJ ,A DC-DC Step-Down Power IC

  A feedback circuit including R2&R1 ,a resistor R2 and an adjustable resistor R1 , Vin and Vout Filter Capacitor C1&C2. A led Indicator circuit of output.

  Choose package for every component .

  Then convert the schematic into PCB by clicking “Convert To PCB ”ICON on the Toolbar.

  Then it will transfer to New PCB file

  Press”Ctrl+S” to save the New PCB and rename it .

  On the external frame , click the arc and delete it . Close the external frame with right angle .

PCB file

  ——Change the arc on the left top side to right angle .


  Click every component and drag them to the inside of the frame .

  Put every component on the proper position .

  Then start to route it as followed .

  1、Auto route

  2、Route manually .

  1、You could choose to auto route the circuit by clicking the auto route .

  After clicking “Auto Router” ICON ,the interface will pop up with Auto Router Config .You could modify the track width , General clearance ,and so on .Click run to execute auto routing .

auto route PCB layout

  ——Auto Router Config dialog.


PCB layout

  ——Effect of Auto Routing .

  2、However , even the tool provides function to auto route, for most of the completed circuits or special circuits , you need to route it manually .

  3、Use the PCB tools and the layers tools and use the track on the PCB Tool to connect every flying line .

  4、Remember to check the DRC Routing Rule and then make the PCB Layout to make sure that it support power integrity .After you route the wire , change the size of Toplayer Silklayer .

  5、Pour the Copper Area through the icon PCB toolon the PCB tool.

  6、Press ”M” or click the “Dimension ”ICON PCB toolon the PCB tool to measure the width and the length of the PCB board.

PCB layout


  ——Result of manual routing and measure the width or length of the circuit board .

  7、Commonly we pour copper on the bottom layer as ground network ,pour the copper to the Top layer as the power network .

  8、After you have route the PCB ,you could click the Designer Manager on the right hand side .

  9、Then it will transfer to Properties .Click DRC Errors and Refresh .There are no DRC Errors in the PCB Layout .Click the components and nets , you could make every components or net bright. For example , choose C2 and The capacitor C2 will become bright .

  10、Let us manually make an error . For Example , move MDC wire and there will be a big bright X and DRC Errors track2pad error.

PCB layout

  Move the track to its previous location and then then big X and the DRC errors will disappear.

  Once you have finished the PCB Layout , Click photo view to produce the Gerber file .

PCB layout

  ——PCB photo preview


  11、If you want to order the PCB board ,Click the Fabrication Output icon in the Toolbar to order the PCB ,Then go to the Add to Cart Interface .

  There are items like Numbers of Layers ,PCB Dimension Width and Height ,PCB Thickness ,PCBQTY,PCB Color,Surface Finish ,Copper Weight ,And Penalized PCB .

  When you fill in all the Items above ,save it to cart. Then go the Network Payment Interface .

  Delete the useless Gerber file .

  Fill in your country ,your name ,your address ,your Post/Zip Code ,your Telephone ,Choose Delivery Method ,Network Payment Items ,and Click to send Request .

PCB order

  OK , then just wait for your PCB Order at home .


Aiming to develop an advanced Linux server for a private network, with reduced size and a relatively small payload, the choice has been focused on the Gizmo2 board hosting a Debian Linux distribution:

  • A reliable board at a reasonable cost with good performances
  • Availability of 1Gb network connection
  • Availability of 2 USB3 ports
  • Internal SSD connector
  • Good power consumption optimization
  • Open source hardware
  • Availability of accessible GPIO ports and possibility to control the hardware behavior


Main features

The Gizmo2 server hardware features should include:

  • Linux boot and root filesystem on 120 Gb SSD
  • N.2 x 2.5" 500 Gb HD configured in RAID1 (full mirroring) connected to the two USB3 ports
  • Headless configuration with SSH remote access


The services distributed over the network will include:

  • Apache2 web server
  • Php 5
  • MySQL server + PhpMyAdmin
  • NFS services


The role of the controller board

An independent controller board to control and continuously monitor the system health status of a device.


Must-have features

  • Power status
  • Server running status
  • External power to the two HDD
  • Power On/Off the server mainboard
  • Server mainboard reset
  • Temperature control
  • Extra fan powering
  • Alarming


Future features

  • Power supply redundancy (two power supplies switched alternatively on failure)
  • Power status and power drain
  • Power battery backup status
  • Programmable system boot and shutdown
  • Network physical connectivity checkup
  • Other sensors for health status control


From idea to design

Server Controller Board Scheme.jpg

As mentioned above the controller board should act as an independent unit. The solution is a microcontroller managing the system including - as shown in the scheme - the user power on/off and reset commands.


This Microcontroller Health Status Controller Board works fine with the Raspberry PI and Arduino, ChipKit and Gizmo2 and almost any circuit board that may need a supervision controller.


MCU choice

There is a wide range of option choosing an MCU for the controller board but in my opinion for this case there are two possible options: a slow and cheap microcontroller available in DIL package (due to the limitations of my prototyping capabilities) or a PSOC device. The idea of using a SOC (i.e. the PSOC5 prototyping kit) is really attracting but unfortunately it is not possible to adopt this solution - that probably remain the best and cheaper - due my limited time resources for the development.

As I have already developed several project with the Atmel AVR microcontrollers series and the AVR Studio development environment, the obliged choice for the first version of the controller has been the use of the AVR328p MCU.

The following image shows the schematic of the board.

Server Control Panel Rev 2 Schematics.png

While the next images shows the PCB layout and the prototype PCB.

PCB Layout.pngIMG_20151010_180657.jpg

A note on the circuit

As you can see in the schematics the board only includes the microcontroller IC and the circuitry control components + discrete components. As it is expected to it the board as an accessory inside a box including also the rest of the circuits (e.g. the electronics that should be controlled) all the components - LCD, FAN, Temperature Sensor, Vibration Sensor, User control buttons etc. are wired separately to fit in any kind of container depending on space and the most useful position.


Board and external components

Board AVR328p-Note.jpg Board AVR328p.jpg

The images above sows the finished board with the actually used connectors and the external components that can be connected to the board.

Board External Components-Note.jpg

The external components used to populate the board.


Logging and external feedback

All where possible the UART connector can used to easily wire the board with the controlled device (e.g. Arduino based project, Raspberry PI, PIC based project etc.) using just the Tx and Rx cables and a serial connection. The same UART can be connected to any device, included a laptop or desktop with a Serial to USB adapter (e.g. the cheap ones based on the FTDI 232 IC) This optional features gives further options to the user for a more complete feedback, data collection or to instruct the controlled board to assume specific behaviour depending on the feedback of the controller.



In the images of this example a small 12 V cooler fan has been used provided with just the two power supply cables. Also using a bigger device in general the PWM-controlled FANs are a lot expensive than the three-wires only devices that does not include this option; the third wire when present is the tachometer for the fan speed control. A PWM Fan (4 wires, 12 V, 20-40 mm diameter) can cost up to 100$ while a simple FAN (2 or three wires) has an average cot of about 5-12$

The temperature control via PWM frequency is managed to a non-PWM fan with s simple circuit based on a sufficient powerful transistor (less than 0,5$) and a couple of discrete components. The details of this part from the schematic are shown in the image below:

PWM Fan.png


Pushbutton simulation (aka Button Output)

Another detail it is the worth to analyse is the way the output buttons has been created in the circuit. In theory it is sufficient to put to low a GPIO Pin normally high to create (almost) the same effect of a physical pushbutton connected to the controlled device. I have verified experimentally that not always this method works properly; in some cases the simple Pin status change is not sufficient to recreate the same conditions of a mechanical pushbutton when pressed. The simulation of the Power and Reset pushbuttons (anyway, two configurable buttons) is strategical to control the behaviour of the external device in many conditions:

  • When the user ask for a manual power-On / power-Off cycle
  • When the user needs a physical reset
  • When the board detect an alarm condition that require the system powered down via a power on/of pushbutton switch
  • When the board detect a condition that requires the system powered on (awaken from a standby status, to be precise)


To solve this problem a simple and already tested solution is setting the GPIO Pin to control a transistor (PN2222 is more than sufficient) acting just like a relays of a physical switch. The image below shows in detail this part of the circuit

PushButtons simulated.png

The board in action

The video above shows the firmware approach of the board monitoring at different frequencies the sensors input and checking the user interaction (via the two pushbuttons). In the example shown in the video the temperature sensor is preset to start the fan as a temperature of 30C is detected, increasing the fan rotation speed proportionally to the temperature level. 90C is considered the highest acceptable (in risk area) temperature then an alarm action can be activated, eventually acting directly on the controlled board.


The firmware

The firmware has been developed in C/C++ with AVR Studio 6 but the attached sources has been converted in Arduino sketch format for a better readability by the users. The included classes of the source package (attached to this post) can be used in an AVR Studio project as well.


I received my Alpha unit of the C.H.I.P. from Next Thing Co recently:

15 - 3.jpg

(the blue tape at the top is just cause i found the bright power and activity LEDs annoying... I'm weirdo )

15 - 4.jpg

I loved the little detail of QC pass sticker featuring adorable doge with the words "Such Pass"


C.H.I.P. did very well on Kickstarter earlier this year:

  • 39,560 backers
  • $2,071,927 pledged

I choose the Kernel Hacker reward level, so I got this Alpha C.H.I.P. hot off the assembly line:


Full shipment to backers should start in Spring 2016:


The performance specs are similar to the Beaglebone Black (minus the PRUs):



The Allwinner R8 module is a new part from Chinese SoC desginer Allwinner Technology in 2015.  It bundles together a processor similar to the Allwinner A13 with 512MB DRAM and 4GB NAND Flash.

CHIP also includes on-board WiFi and Bluetooth via a Realtek chipset:


CHIP can easily be powered by micro USB or a Li-Po battery:


The only built-in video output is low-res Composite analog video:


But there will be HDMI and VGA capes in the future:


Anyways, I'm perfectly happy with a UART .  I was able to connect to the Linux console using a FTDI USB-to-serial cable:


(the blue tape on the right is just cause i found the bright power and activity LEDs annoying)


I found the pinout and other details on this page:

Flying Blind with C.H.I.P. -- SSH, Serial, and USB OTG


I am very pleased that Next Thing Co. shipped my Alpha CHIP with a fresh Linux 4.2 kernel (which is the current stable kernel):

15 - 1.jpg

15 - 2.jpg


Here's a GitHub Gist with the full console log of the CHIP booting:



Basic system info after booting up:


/home/pdp7 # cat /proc/cpuinfo 
processor : 0
model name : ARMv7 Processor rev 2 (v7l)
BogoMIPS : 1001.88
Features : half thumb fastmult vfp edsp neon vfpv3 tls vfpd32 
CPU implementer : 0x41
CPU architecture: 7
CPU variant : 0x3
CPU part : 0xc08
CPU revision : 2
Hardware : Allwinner sun4i/sun5i Families
Revision : 0000
Serial : 162542c709417353

/home/pdp7 # uname -a
Linux chip 4.2.0-rc1 #1 SMP Sat Sep 19 03:24:28 UTC 2015 armv7l GNU/Linux

/home/pdp7 # df -h 
Filesystem Size Used Available Use% Mounted on
ubi0:rootfs 3.6G 21.1M 3.6G 1% /
devtmpfs 245.3M 0 245.3M 0% /dev
tmpfs 245.4M 0 245.4M 0% /dev/shm
tmpfs 245.4M 68.0K 245.3M 0% /tmp
tmpfs 245.4M 40.0K 245.3M 0% /run

/home/pdp7 # cat /proc/meminfo |head
MemTotal: 502500 kB
MemFree: 466800 kB
MemAvailable: 468492 kB
Buffers: 0 kB
Cached: 8784 k

So that is all well and good, but why am I writing about CHIP on this Open Source Hardware group blog?


Well, that is because CHIP is 100% Open Source Hardware:


Kickstarter Update #9: All about Open Source


The design files are licensed as CC-BY-SA and linked from this centralized documentation page:





The CHIP Hardware repo on GitHub:






  • Schematics


  • PCB Layout


  • Bill of Materials (BOM)

Screenshot from 2015-10-28 19:56:01.png


The repo even has datasheets for components in the BOM:






The goal of Next Thing Co for CHIP is to be a happy and healthy member of the Linux open source community!


This means CHIP needs to:

  • Run official and current version of Linux kernel
  • Build new Linux drivers for on-board hardware
  • Merge changes into Linus Torvald's tree in a process called "Mainlining"


Mainlining the kernel changes necessary for C.H.I.P. is no small task.  Takes huge and ongoing community effort.  The amazing Linux-Sun-Xi community has already made great progress on kernel support for Allwinner SoCs:


linux-sunxi Community Wiki


A huge smile crossed my face when I learned that Next Thing Co contracted the ARM Linux kernel experts at Free Electrons to support CHIP in mainline:


Free Electrons contracted for the $9 C.H.I.P. computer


Free Electrons has been supporting Allwinner processors in the mainline Linux kernel for several years.  Free Electrons engineer Maxime Ripard is the maintainer of the Allwinner SoC support in mainline.  You can follow their progress on Google+:


Free Electrons on G+



Here's an example of how audio support for CHIP was add to the mainline Linux kernel:


  • Maxime Ripard finished the initial work done by Emilio Lopez during a Google Summer of Code on supporting the audio codec built into the Allwinner A10 processor.
  • Maxime sent the patch series to the ASoC maintainers:
  • v1 got merged directly by Mark Brown, one of the two ASoC maintainers!
  • “For a completely new driver, it is quite an achievement to get it merged without having to do additional iterations”
  • CHIP now has audio support in mainline!


Another exciting update from Maxime Ripard:

“Debian 8 and XFCE running on the CHIP, on top of the DRM / KMS driver!”


2015 - 1.jpg


You can also follow the progress of the Linux kernel development for CHIP with this NextThingCo repo on GitHub:



So what about software beyond the kernel?  My CHIP Alpha arrived with a root filesystem that Next Thing Co created with Buildroot: "a simple, efficient and easy-to-use tool to generate embedded Linux systems through cross-compilation."

Buildroot repo for the CHIP:


Here's what the rootfs build that shipped on my CHIP Alpha looked like from the console:


Next Thing Co created CHIP-SDK with everything needed to develop software for CHIP, including creating a custom rootfs with buildroot.





As this MAKE blog post described, the SDK is easy to install and run because it uses Vagrant to manage a VirtualBox VM:


With Linux and Creative Commons, The $9 CHIP Computer Reveals Its Open Source Details


written by David Scheltema [interested1]



However, I love the vast array of packages that Debian GNU/Linux has to offer, so I am happy the Debian is now available for CHIP:

Debian on C.H.I.P


I was able to easily flash Debian onto my CHIP and then boot it!




I think I will next look at what I can do with the GPIO pins on the CHIP:


Simple GPIO Experiments




Some extra pinout docs


Assuming you don't want to use the camera or LCD ports it looks like you get 1 UART, 2 I2C, 1 SPI, 1 PWM & 32 i/O (some with interrupt)


So that's it for now... I think CHIP will only get more exciting as it gets into more and more hands!


Here's some additional links I've found useful:



And finally, slides from my talk about CHIP at Chicago hackerspace Pumping Station: One earlier this week:


Slides from hackerspace talk about C.H.I.P.







This blog post looks at a very small microcontroller board called the StartUSB for PIC StartUSB for PIC, and shows how it can be used either as a standalone microcontroller board or used to control your own hardware (either off-board or built on the supplied prototyping area) via USB control from a PC.

A condensed summary steps version of this post in PDF format is available here.



A brief history

Many hobbyists are familiar with microcontrollers from Atmel on a credit-card sized board and a turquoise software development environment known simply as Arduino.


A microcontroller is a “computer-on-a-chip”; usually it contains the central processing unit (CPU) and program and data memory all-in-one. It is available in tiny sizes sometimes with less than a dozen pins that can be used to control and interact with the outside world.


In the early 1990’s two firms that delivered microcontrollers that largely competed in the same space became popular with hobbyists; one was Atmel and the other was a company called Microchip. Their microcontrollers were relatively simple chips available in friendly low-pin-count DIP packages and the programming tools were reasonably low cost and affordable by individuals.


Most of these early devices had very little memory and software was written in assembler language; as a result of the investment in getting up-to-speed, developers for the Microchip range tended to stick with the Microchip products (known as PIC microcontrollers) and the developers for the Atmel range (known as AVR microcontrollers) stuck with those.


The situation is very different now; the increased memory and better instruction sets means that often development is done in the (slightly) higher-level C language and therefore it is far easier for programmers to rapidly swap between different processing architectures. The introduction of Flash memory that can be programmed at low voltages has reduced the cost barrier of modern in-circuit programming tools and often (not always) the compilers are free.




During those hobbyist PIC/AVR wars I ended up trying some of the PIC12 range, and rapidly moved to the Atmel products as soon as Flash memory in microcontrollers because popular. The PIC12 range had a particularly simplistic instruction set that made it very tedious to write assembler code; I was far more comfortable with Intel, Motorola and Hitachi microcontrollers at that time. The Motorola 68HC11 series and the Hitachi H8 series in particular had easy-to-use instruction sets and they could be self-programmed without requiring any programming hardware.


What is a Bootloader?

The process to self-program involves relying on a simpler program to load the main program into memory.


Often this means setting a pin just before power-up which puts the microcontroller into a mode where it sits and waits for characters to arrive on its asynchronous serial interface (usually wired using RS232 to a PC) and put them into internal RAM. A small program called a ‘bootloader’ was written and sent via the RS232 interface from the PC into the microcontroller. With clever programming the bootloader would then execute from RAM and then receive the main program and automatically self-program the microcontroller’s internal Flash memory.


Modern microcontrollers now support USB bootloader capability either as supplied from the manufacturer or initially programmed in to a portion of the Flash memory using an in-circuit programming tool. The StartUSB board has such a bootloader (described in detail later). The process to work with this board involves writing and compiling code in the usual manner and then sending the built .hex output file via a PC tool called mikroBootloader (available for download here) to the StartUSB board which will already have a bootloader pre-installed in a portion of Flash memory.



8-Bit Popularity

Nowadays although 8-bit microcontrollers are still available, 32-bit device popularity has been increasing. This year is probably the last year when 8-bit microcontroller revenue might exceed 32-bit revenue for microcontroller manufacturers.


Manufacturers like Atmel (recently acquired by Dialog Semiconductor) and Microchip are still launching 8-bit products since 8-bit parts continue to be popular. Texas Instruments, Renesas, Silicon Labs and Freescale still produce 8-bit microcontrollers too – often at under $1 price.


What is the StartUSB for PIC?

The MikroElektronika ‘StartUSB for PIC’ is a very compact board with a PIC 18F series microcontroller on-board with 32Kbyte Flash, 2kbyte SRAM and 256 byte EEPROM. The main board could probably fit inside a small box of matches if the prototyping areas are snapped off (there are scored lines to break it off).


I was interested in this board ever since the Dreamboard Vs Battle because the StripBoard++ dream-board had intended to have a prototyping area built-in too.

I had not used PIC devices in an extremely long time so it would be interesting to revisit them. I wanted to come to it with an open mind; I don’t use many Atmel AVR nor Microchip PIC devices these days.


It was disappointing that a few things had not changed at all – the official programming tool PICkit 3PICkit 3 is slightly pricier than the Atmel tool, and the Microchip compiler (called XC8) is a chargeable product (the free version produces larger, slower code).


Nevertheless, these may be small barriers for commercial customers if the benefits and cost of PIC microcontrollers are greater than the competition. Commercial customers will be willing to pay the cost of the tools and compiler.


It was also noticed that a potential low-cost entry to PIC microcontroller development boards is the new Microchip Curiosity board. I decided to plough ahead with the StartUSB board and document how I used it.


Advantages of the StartUSB for PIC board

The StartUSB for PIC board is fairly low cost (but certainly not the cheapest if we’re comparing microcontroller dev boards) and is very compact yet retains the ability to be able to connect up SIL header pins (these are supplied unsoldered). I also like that it has a small prototyping area for building additional circuits.


The StartUSB board does not need a programmer; it can be programmed using a USB connection to a PC because it comes with a bootloader pre-programmed into a portion of Flash memory.


The features inside the microcontroller (the full part code is PIC18F2550) are reasonable-to-pretty-good for a 28-pin device. The CPU runs at a fairly speedy 48MHz, and there is built-in USB device functionality capable of connecting at up to USB ‘Full Speed’ mode (12Mbps) to a USB host such as a PC. It also contains serial interface features including UART, SPI and I2C, and a 10-bit analog-to-digital converter (ADC) and three 16-bit timers and an 8-bit timer, a comparator and dual PWM (10-bit) capability. It is a good set of functionality for a small 8-bit device.


What are the Disadvantages?

The board is primarily designed to work with a 5V USB connected supply; although the supply pins are broken out to the SIL header pins, there is no protection if the USB supply is connected at the same time. This is something to be aware of (it won’t impact all use-cases).


Another disadvantage is that there is no hardware programmer on the board; instead the PIC 18F microcontroller is pre-programmed with the bootloader which is designed to wait five seconds whenever it is plugged into a USB port to see if the host device (e.g. PC) wants to transfer across a new program (using PC software supplied by MikroElektronika known as ‘mikroBootloader’ or ‘USB HID Bootloader’ tool) into Flash memory (taking care not to overwrite the PIC 18F bootloader which also resides in Flash memory). After the 5-second delay the bootloader assumes the user does not intend to upload a new program and starts up any exiting program in Flash.


The procedure works fine, but does mean that there is a 5-second delay before program execution at power-on.


There is also the risk that the user may accidentally wipe the bootloader and then the startUSB board is useless until the bootloader can be reprogrammed into it (using a separately purchased PIC programmer). This is disappointing but again is more relevant to the new hobbyist than a commercial customer. Those already using PIC devices will likely already have a PIC programmer so this becomes a non-issue for them.


Installing the Development Environment

Microchip’s integrated development environment (IDE) is called MPLAB X and it was installed as well as their compiler toolchain known as XC8. MPLAB X looks much like any other IDE and was fairly easy to get into. I used the Windows version but Linux and Mac is available too. Much like any other IDE, there is a set of logically grouped files on the left that are part of the project, and the main code view is where all the work is done. In brief the 'hammer' icons are used to build the code into a final .hex file and the entire process is logged into the 'Output' pane at the bottom.



Deciphering the Bootloader

What was very disappointing to see was that the bootloader isn’t documented by MikroElektronica at all. Without such documentation it is difficult to build software for the StartUSB because the user has no idea which areas of Flash memory to avoid.


If MikroElektronika’s compiler is used (it is known as MikroCMikroC) then presumably all is fine; it should happily build code targeted for the StartUSB board. However, I wanted to use Microchip’s MPLAB X and XC8, and I didn't have MikroC. Besides, some customers may already have invested in XC8 and may not want to purchase another compiler.


A small bit of reverse-engineering of the bootloader (a copy of the hex file was supplied in the zip file containing the PC software mikroBootloader) was needed. MPLAB X has the capability to disassemble code by importing in the hex file and running it using an internal debugger and bringing up a ‘PIC Memory View’ window.


It soon revealed that the bootloader resides at the top portion of memory and that the PC software that connects to the bootloader automatically moves the reset vector so that the bootloader can call the user’s program after the 5-second timeout. The diagram below shows the disassembly at the reset vector (in blue) and the bootloader (in green). The table on the right shows the 20 or so bytes of bootloader disassembly. So, it is expected for the user program to sit anywhere in the On-Chip Program Memory as shown on the diagram, as long as it doesn’t trample the bootloader. The bootloader uses a specific location (shown in red) for the user program jump vector. Click on the image below to see all this in detail.



All that was needed to do was to avoid overwriting the bootloader. This was easy; in the MPLAB X IDE, right-click on the project and select ‘Properties’. In the Project Properties window that appears, select ‘XC8 linker’ and then option category ‘Memory model’. The ‘ROM ranges’ parameter which by default is blank needs to be set to :




The steps above will ensure that the memory from address 0x653c to 0x7fff is avoided. These are the locations used by the bootloader present in the StartUSB board. When the program is transferred by using the MikroElektronica supplied PC software called mikroBootloader, the PC software will automatically map the reset vector in the user program hex file into the correct location to serve as the program jump vector for the bootloader to use.


Hello World

Another irritating issue is that the StartUSB has no supplied source code for an example user application; by default the board comes with pre-compiled code in the Flash memory which flashes two LEDs. Without the source code to that, a user has to fly solo for their first program.


Still, it is resolvable; I wrote my own demo which approximates the pre-compiled demo program. It is shown here but the source code is attached so use that; no need to copy-and-paste.


* Description: StartUSB for PIC demo program
*              for MPLABX with XC8
*              (Alternately flashes two LEDs)
* File:   main.c
* Author: shabaz
* Revision: 1.0 - 24th October 2015, First Version

// include files
#include <p18f2550.h>
#include <xc.h>

// pragmas'
// See XC8 install folder \docs\chips\18f2550.htm for these values:
#pragma config PLLDIV=2          // 8MHz crystal, divided by 2
#pragma config USBDIV=2          // USB clock is 96MHz/2 = 48MHz
#pragma config CPUDIV=OSC1_PLL2  // CPU clock is 96MHz/2 = 48MHz
#pragma config FOSC = HSPLL_HS   // CPU is clocked from HS_PLL path
#pragma config FCMEN = OFF       // Fail-safe clock monitor enable is off
#pragma config BORV = 3          // brown-out voltage level (3 is minimum)
#pragma config WDT = OFF         // Watchdog is off
#pragma config CPB=OFF, CPD=OFF  // Code protection bits are off

// definitions
#define LED_RED LATAbits.LATA1
#define LED_GREEN LATBbits.LATB1

// global variables
unsigned int subtick=0; // used in the ISR
unsigned int msec=0; // counts 0-999 repeatedly
unsigned int sec=0; // counts upward forever
unsigned char sec_toggle=0; // toggles every second
unsigned char msec100_toggle=0; // toggles every 100msec
unsigned int msec100; // counts upward forever

// function prototypes
void msec100_tick(void);
void sec_tick(void);

// interrupt service routine
void interrupt low_priority LowIsr(void)
    if(PIE1bits.TMR2IE && PIR1bits.TMR2IF)
        if (subtick>=3)
            if ((msec%100)==0)
            if (msec>=1000)
        PIR1bits.TMR2IF=0; // reset interrupt flag

    if (msec100_toggle)



    T2CON=0x07; // timer 2 on, speed=48MHz/2/16 = 750kHz
    PIR1bits.TMR2IF=0; // clear timer 2 interrupt flag
    PR2=250; // timer 2 compare match value
    PIE1bits.TMR2IE=1; // enable timer 2 interrupt (on compare match)
    INTCONbits.PEIE=1; // peripheral interrupt enable
    RCONbits.IPEN=1; // enable priority levels system
    IPR1bits.TMR2IP=0; // set timer 2 interrupt to be low priority
    INTCONbits.GIE=1; // enable global interrupts
    TRISAbits.RA1=0; // set port A bit 1 as an output
    TRISBbits.RB1=0; // set port B bit 1 as an output

// main function
        // loop

    return(0); // ignore warnings on this line


The code can be compiled up and transferred to the StartUSB board using the mikroBootloader PC tool. When the board is reset, after a 5 second delay the bootloader will run the code and it will flash two LEDs rapidly repeatedly.


Doing More Useful Things: USB

I was particularly interested in getting USB to work for user programs, so that this board could become a useful go-to device for quick and low-cost integration of hardware projects with PCs. The PIC18F2550 is not supported by the automatic code generation tools that Microchip offers for more recent processors so I had to resort to trying to compile code from Microchip’s Library for Applications (MLA) which is a set of source code for useful libraries. After some (brutal) messing around the USB finally worked – the code I tested used the USB Human Interface Device (HID) class which usually doesn’t need any driver installing on the PC.  The HID class is typically used by keyboards and mice which would be inconvenient to use if they required a driver for basic functionality each time they were plugged into a new PC. The HID class can also be used for generic data transfer bi-directionally and this is what was of interest to me.


To perform bidirectional transfer some example PC host side software is supplied as part of the MLA code both in compiled and source code form – various demo code exists for all platforms. I only tried a pre-built Windows application for now, which successfully allowed me to toggle a pin on the PIC microcontroller from the Windows application and to receive the status of a different pin; this proved that communication in both directions is possible.


The code on the PIC microcontroller sits and waits for a packet from the USB host (e.g. PC) and then checks to see if it is a command to toggle an LED, or to send data with the status of another pin. It should be easy to modify this to do more advanced things.

The code is attached to the post. If you wish to modify it, you can see where the code for the LED and button press and high-level USB packet handling for them resides here in a file called app_device_custom_hid.c:



The command definitions are in that same file. The LED and buttons are defined in a file called io_mapping.h and the actual low-level port input/output for them occurs in files called led.c and buttons.c respectively – nice and simple!



I’m excited to see that the PIC 18F devices have vastly more functionality than the early PICs of yesterday.

Nevertheless it would be a nice gesture for Microchip to release a no-support (e.g. community edition) of their full XC8 compiler with no restrictions but we can assume this will not occur.


This was just a short review; I certainly will re-visit PIC devices and as mentioned the PIC 18F could well become a popular part for me for general microcontroller use where I may want USB and other basic bits of functionality and not have to redo effort. The 28-pin SOIC and DIP availability of the microcontroller is handy.


The MikroElektronika StartUSB for PICMikroElektronika StartUSB for PIC is an interesting board; it has the fairly decent PIC microcontroller on-board and the board itself is a great form-factor with the proto-board area alongside that can be optionally removed.


However I wasn’t happy at the lack of public documentation. MikroElektronika is a reputable company with a vast portfolio of useful boards – a huge click range for instance; they should have just published the information and let users decide to use what vendor compiler is best for them.


Still, with the information above and the example code that was written, it should be possible for anyone to use this board with the MPLAB X environment and XC8 compiler.


I’m not sure the StartUSB for PIC board is best value though; if you need a small PIC board then it is fine, but otherwise I suspect (although I’ve not used it; it may have its fair share of advantages and disadvantages too) that the Microchip Curiosity board could be a better option because has a reduced set of PICkit functionality on-board so it doesn’t require a bootloader in Flash like the StartUSB for PIC board. But the compact size of the StartUSB for PIC board is very cool!


The source code mentioned in this post is attached below.

Last month, I discovered there was a company called Outernet here in Chicago, where I live, that created a derivative of the BeagleBone Black called Lantern:



Lantern: One Device, Free Data From Space Forever


    • $696,653USD total funds raised
    • Original campaign was 240% funded on January 11, 2015


Here's a quick description about how the satellite reception works:

Lantern tunes into two frequency bands and types of satellites: L-band and Ku-band. A huge volume of content can be accessed via Ku-band satellites, through an external satellite dish.


While on the go, Lantern relies on its internal antenna to receive content from Inmarsat, a global satellite operator. Once the tuner selects the frequency, and the demodulator turns the waves into bits, the data is passed on to Lantern's compute module, which is similar to what powers many cellphones all over the world. At this stage, these bits are turned into digital files, which are all stores in a directory to be shared over Lantern's wifi hotspot.


Syed Karim, Outernet Founder and CEO, invited me to come over and checkout the Latern board:



Here's their GitHub repo with design files for Lantern's main PCB, such as schematic, Gerbers, and BOM, licensed under GPLv3:

The files in this repo pertain to Lantern's main PCB. This includes the schematic, gerbers, and BOM, in addition to project outputs from Altium 15.

Lantern is a portable satellite data receiver which consists of a main compute board and separate RF module which receives satellite transmissions between 1525MHz and 1559MHz.


V1 of the Lantern compute pcb is derived from the Beaglebone Black single board computer. The main differences between V1 and BBB include the addition of a DVB-S2 network interface module (NIM), as well as an onboard wifi module. Unlike the BBB, V1 does not provide for a video interface.

The other interesting addition is Battery Charger Circuit with Solar In:


Example of the PCB footprint from the design files:


Syed also gave an Outernet presentation and demo at Chicago hackerspace Pumping Station: One:

Enabling Universal Information Access: Libraries From Space



outernet talk


Syed brought their existing Lighthouse receiver for a demo:

outernet lighthouse

outernet lighthouse ports


Lighthouse creates a WiFi network that users can connect to.  I was able to browse content that had previously been received by the device such as Project Gutenberg books and Khan Academy videos:




Additional information:








The Youxia X is just as sleek looking as the Model S. (via Youxia & CNC)

Open source your design/patents… this happens. It’s not the first time, but the most ambitious I’ve seen recently. (See the MakerBot close, TangiBot, for another example towards the end of the post.)


In case you didn't know China has a reputation for producing knockoffs of designer brands, like Gucci and Burberry. You may have seen some of these knockoff purses, but how about a knockoff car? Recently, China revealed the Youxia X electric car made to compete with the Tesla Model S vehicle. If you're thinking it looks familiar, you're right. It appears the Youxia, which is the Chinese name for the Knight Rider series, has copied most of the design for the Tesla car. It's not an exact replica, but many of the same features have been reproduced like the central touchscreen that controls almost all of the analog controls, the body shape, fender badges, and black grill. CEO Haung Xiuyuan is the one behind the car and yes, he is a Knight Rider fan.


Though it may be a clone, the Youxia X does have at least one feature not found on the Telsa: a programmable display grill, which can show emojis and even the iconic sliding ride light from KITT. The operating system is based on Android 5.1 and is called KITT OS ( can you guess why?). This OS allows drivers to select various engine sounds from cars like Ferrari 488 GTB and Jaguar F-Type to replace the near-silence of the electric motor.


When it comes to performance, Tesla is still on top with 315 horsepower and reaching 60 mph in 5.5 seconds. The Youxia can put out 348 hp, which is enough for 0 to 60 in 5.6 seconds. When it comes to range both cars are pretty similar with the X having 40, 65, and 85 kilowatt hour battery packs. The Model S offers 70, 85, an 90 kilowatt packs. The Youxia is supposed to reach a max range of 285 miles, while the Model S can go 270 miles on a charge.


Those who can't afford the $70,000 price tag of Model S will be happy to know the clone will start at an estimated $32,000 with range-topping models going for $48,000. The catch is the car isn't coming to the US marketplace anytime soon. Production is supposed to begin in late 2016 with deliveries slated for 2017. I have to say… the price is appealing.


It's easy to point out why clones that rely on open source hardware should be avoided. Many consumers worry about cheaper parts and the product not being made well overall, but open source hardware has the advantage of making money for those who use it. Just look at TangiBot, which is a clone of MakerBot 3D printers. Not only does it offer the same performance as the MakerBot, but every component on the Tangibot is compatible the original printer and is cheaper with a price tag of $1,199 compared with $1,749 for the MakerBot. The printer did exceptionally well, so the Youxia X may find the same success. We'll have to wait to find out.



See more news at:


Gesto is the World’s first open-source boards for wearable gesture control with a unique method that combines muscle signals with motion patterns.


There are available two kits:




Gesto Caelum is a ready to go solution. Caelum has all you need to add gesture control/recognition to your project, with a fast and easy setup, without the need to program it. So you can simply configure the gestures in your Android or iOS smartphone to get started right away.


Gesto Stella is a development kit. It is designed to interface to other boards such as Arduino or Raspberry Pi boards, and sends raw muscle data via its SPI interface.


Prosthetic arm controlled with Gesto


Gesto can handle three types of gestures: singular gestures, air drawing gestures, and directional gestures. The technology making sense of the muscle raw data is called “DualBurst” which combines muscle patterns and motion patterns for better accuracy.



Gesto also provide a modular 3D printed band to assemble all the Gesto electronics in your body (wrist, forearm, arm, torso, leg).

Gesto has now been launched on Crowdsupply with a special price:

- Gesto Stella $99

- Gesto Caelum $149

(with delivery scheduled for March 2016)


Check out the video from Gesto's crowdfunding campaign!



I want to introduce a new project of me. It's a usb hid io module with 2 relay outputs and 2 optoisolated inputs. The module based on a ATTINY45 with V-USB stack. It can be combined with any Linux (Raspberry Pi, Beagle Bone) or Windows platform... It fits perfectely in a 3 module din rail enclosure and can be mounted in a cabinet. Please check this link for more information: http://www.hwhardsoft.de/english/simplibox/io/


USB IO Module side view

with Raspberry Pi

gehäuse und pcb.jpg



Have you sometimes felt some pains in your wrist? Be careful, because you might get a Carpal Tunnel Syndrome (CTS) disorder. So what is Carpal Tunnel Syndrome? Carpal tunnel syndrome (CTS) is a disorder that affects your nerves in the wrist. This disorder makes your nervus medianus compressed when the nerve passes through the tunnel in your wrist (called carpal tunnel, that's why this disorder is called carpal tunnel syndrome).That's why we were inspired to make Attracts, Automatic Treatment for Hand Carpal Tunnel Syndrome. Attracts uses Teensy 3.1 as a board. At the first time, we use ATMEGA2560. At that time we created the first prototype with SMD component and it used 0.96" OLED Display. But at that time, it did not work. So next we moved to Arduino Pro mini. It was cool. But the only bad thing is about the speed. It was too slow because our data of exercise and treatment of Carpal Tunnel Syndrome need to be as fast as possible. So then we choose Teensy 3.1 because not only it has a lots of memories besides it has higher clock (Overclock up to 96 MHz !!!). And next we change the LCD display from OLED Display into TFT Display because the screen resolution is better than OLED, besides it is Colorful. we give our smartwatch a lipo charger and lipo battery 3.7V 1000 mAH. And the last thing, we add a Bluesmirf HID Module that we bought from Sparkfun into our smartwatch because we think it will be cool if you have a watch that can be a mouse or a keyboard and you just control it by using your hand and muscle movements. Besides, it can be an exercise of the patient of CTS or non-CTS because you have to move your hand in order to control your computer.

Here is one of ATTRACTS features


For all the hobbyist, maker community, DIY'ers, students and beyond - we're supplying free reference designs that you can work with, take from and build up to make your own designs!    No need to start from scratch!

Linear Technology DC1194A Demo Circuit = 200ma DC/DC Micro Module

Click Here to download now! 

                lt1.PNG    lt2.PNG


Demonstration circuit DC1194A features the LTM®8020, a 200mA DC/DC step-down μModule® regulator. The board is preset to deliver a 3.3V output at up to 200mA load current from an input voltage of up to 36V. The output voltage may be modified by simply changing one resistor.

This PADS reference design data set has 19 files including:

    • Schematic design in xDX Designer format (.prj)
    • Layout design in PADS 9.5 format (.pcb)
    • Bill of Materials for the design ( Bill of Materials.html)
    • PDF of the schematic design ( (Schematic).pdf)
    • PDF of the layout design ( (Layout).pdf)
    • Property definitions file (netlist.prp)
    • PCB Configuration file (pads95.cfg)
    • Land Patterns
    • Schematic symbols


Be sure to check out all 24 Reference Designs found here: http://www.pads.com/reference-designs/?cmpid=9050 can be used with our new inexpensive (PADS based) Designer Schematic and Designer Layout tools now available for the hobbyist/maker community from Digikey !http://www.digikey.com/product-highlights/us/en/mentor-graphics-designer-software/4171?cmpid=9050 as well as our desktop PADS products.

Cheers !    John

Front panels can cost a lot. As an alternative I had a theory that I put to the test this week, and it worked out well. The theory was that for home-built projects, surely trophy/jewellery type engraving could be used for labels.


It turns out that it can be done on enclosures in most high streets/malls as a same-day service - just using the engraving services of a key cutting or jewellers store : )

In the UK, the chain 'Timpson' was used here, on this aluminium enclosurethis aluminium enclosure (these Hammond aluminium enclosures are really great - simple, with a nice finish):




It was very efficient. I just told them the text I wanted and where, just written on a piece of paper along with a quick 30-second pencil sketch.

They figured out how to center it, the font size, etc., based on their experience with their tools.

I think they did an awesome job!! I'll be going back to Timpson for future projects.

I had a wake up call using Eagle Cad and a third party libraries. And I wanted to share how my ignorance caused my boards to fail (for now).

Just for reference the board uses an Atmega328P SMD and i wanted a smaller and cheaper part than a normal crystal. So I went with a resonator, there are a few very cheap and very small. I am not that good on creating parts layout by myself so I searched on the libraries at hand for a resonator with the footprint similar to the one I wanted to use. And very quickly I found a smd resonator on Sparkfun-FreqCtrl library and the part is RESONATOR-SMD. First I was very happy to actually found this part. So I put the part on my PCB and send it to fab for manufacturing. The board came back beautiful red (I had to pay a little more for color selection). Then I notice that around the resonator there were some solder mask missing, but said to myself this must be a size limitation from that cheap Chinese fab. I am like a little kid whenever I get mail, so I ran to get my iron and started soldering. "No need to do any measurement, I am 99.9% sure the design is correct" I said. If fail then I will test, but I wanted to solder right away. So I did.

Latter after the boards start failing I then went back and did some measurement, just to find some missing solder mask and some exposed copper. The copper exposed then again I thought at first it was because of Chinese fab, but turn to be my mistake not the fab.

Lets see the picture bellow, look the black region is missing red solder mask. And at the borders you can see exposed copper (blue arrows). The missing solder mask (black part) does not causes any problem. However the exposed copper do. It causes my resonator to short to ground making my board fail.



And what was the cause of all? The actual part on the library had instructions to be constructed exactly as it was done. There is a layer in eagle called tStop. The tStop layer is the one that allows solder areas of copper to be exposed. This layer stops solder mask in a specific area. This part has a rectangle over the entire part. The size of this rectangle plus a small isolation in the board causes this tStop rectangle to go over my ground plane, and causes the copper to be exposed. On the image bellow, the big white hatched rectangle is the tStop that caused the problem. This made my twenty boards order to fail.



I have three options:

1. Etch (manually)  out that exposed copper to a distance that I can solder the part

2  Cover with heat resistant tape the exposed copper

3. Paint it over with solder mask (that I do not have at hand).

I am going to get a few pieces of tape, and try to cover the exposed copper in order for me to use these boards. But anyhow I edited my design and send a few more to be made, this project need to be finished and quickly. In about two weeks I should be getting them back and hope this issue is water under the bridge.


Hardware design has its ups and down, but it is well worth it. You win some and loose some and learn a lot during the process.

I should try to contact SparkFun about the part, or submit a pull request with the fix. I am a noob, this might be the right design and I am the one mistaken. Anyhow for PCB with a big ground plane close to this part this is not working. My guess is that the rectangle is intended to avoid ground plane under the part and not to stop the solder mask. This must be a layer mistake.


For the new PCB I did a ground plane cutoff polygon around the resonator, removed the tStop from the part and made the side contacts a little bigger (for easier soldering). When I get the PCB back from fab will post again with the new board. Hope that it work.


This PCB eagle files are not posted now, because this board is for a surprise event. After the event all will be posted. If you want to know, the board is just a usbaspLoader using an Atmega328P with an Arduino header footprint. Nothing revolutionary. Oh and of course, instead of a crystal with two capacitors it is using a 16Mhz resonator.

If you do not know what the ESP8266 is... oh boy. It is a cheap WIFI Uart module (google it).

I have been playing around with the ESP8266 for a few days now. While doing my testing I realized that most of the time my problems are faulty wiring. Yeah I know, noob right. Well what can I say, I am a noob. Anyhow it is frustrating trying to debug software problems while still having hardware issues.

This week while reading on the web found a service that can manufacture a PCB for $5 per square inch for 3 boards and it is made in the US. I am not in continental US but close enough. Also it says the part will be sent back in 12 days (more or less). The service is not important, the important is that my mind ran very quickly.

Would I be able to do a 1x1 inch pcb to interface my ESP8266 delicate 3.3V signals to my strong 5V Arduino ?..... CHALLENGE ACCEPTED!

After a few Eagle Cad iterations (about 3 or 4 in 2/3 days) I came up with a simple board that is suppose to be able to do that. BUYA! It shall be called "WifIco".


Ok all this sounds very quickly and it's because it has been. I didn't even mounted a breadboard prototype before ordering. This one goes all or nothing. For a while I have been wanted to do a pcb using smd components and this sounded like a good chance for it. And very important keeping the design on the $5 mark (there is not that much money to spare here you know).


Board Features

  • Power input of 5V
  • RX and TX signals 5V friendly
  • 3.3V regulated output
  • Breadboard friendly pin out
  • Space at the bottom for a mini usb port in case the device is firmware programmed and need a power input from a cell phone charger or something. Wanted a micro usb but I think I have salvaged a mini usb port someplace around
  • GPIO0 and GPIO2 exposed (not 5V friendly, be careful)
  • Connector to plug in the ESP8266 directly to the board.



On the bottom side there are two resistors that should be solder shut to pull RST and CHPD to high. They are just put there in case I needed to use the board for firmware upgrade or needed them. From the schematic capacitor values do not mean nothing. Should check on 3.3V regulator circuit guide lines for actual values. If input voltage is clean you may skip them ( but don't tell anybody I said that).


This is how WifIco will looks like (at least from the images from the OSHPark web site):


Top Side


Bottom side


My eagle design files are here. All is on Public Domain licensing if anybody wonder. I do not need mention nor credit for nothing you do with this.


This may or may not work, in a few weeks I will know! If you don't ever build it or at least try it you'll never now.



I received an email from the manufacturing service that says, the board was sent to factory on Nov 10 and should be back from factory on Nov 20. After that I guess mailed back to me (+5 more days). My guess is that in best case scenario I will be posting on results back somewhere during December (I hope). Still I am exited about the success of this project and hope you are too.


Update 2 (Nov20):

I received a new email that says, board was received from factory and was shipped to me. This occurred on nov 19, 2014. Today is the 20th. Normally this things take anything from 2 days to 7 days to get here. As soon as I have it with me, the plan is to do a continuity test on the contacts and solder the parts for full testing.


Update 3 (December)

The board were shipped to me and received. I did my best soldering the components to the board. I made big errors on the silk screen. But important connections seems to be ok.

I soldered the components to the board as best as I could. and this how it looks like.




I am sending signals from an Arduino to the ESP8266 board and it seems to be receiving them ok. However it is not consistent when receiving communication from the ESP8266 back to the Arduino. My guess is faulty soldering on one of the transistors, but have not tested.


My Errors (for now):

1. Error in silk screen ( Vin is Vout, GND is not ground, TX is RX... )

2. Solder pads should be bigger to allow hand soldering correctly. Specially on Tantalum capacitors, they cover the entire pad so soldering is pain.


There is the issue that I should have tested the design before ordering the pcb but that is part of the adventure. It is a risk I had to take and do not recommend but do not regret.


Possible fixes I would do to this.

1. Fix Silk Sreen

2. Bigger solder pads

3. Change bottom usb connector to be micro usb.

3. Add a mounting hole if space available.

4. Do similar board for the ESP8266-03 board.

5. Add level shifting to digital IOs to make them 5v tolerant also.

6. Add smd switch in the bottom for firmware update mode.


There is so much to do with the board without actually making it bigger. I love adding features but is hard to do in so limited space.


A physical bitcoin made by Casascious. I suppose as an attempt to make it easier to use? That coin could be have been worth anywhere between $300 - 1200 USD this past year! (via Casascius)

While bitcoins aren’t backed by a government body or well-known bank, the digital currency is still gaining ground in some communities, who will not let the concept die without a fight.


One community that’s taking a huge risk on the concept is the Massachusetts Institute of Technology. Next fall, MIT will give each student $100 worth of bitcoins to see how the digital currency fairs in a real-world setting. It only makes sense that MIT would sponsor such a project – after all, it does have a Bitcoin Club.


MIT Bitcoin Club President Dan Elitzer and colleague Jeremy Rubin organized the experiment, which includes raising half a million dollars from alumni and other donors to make the project possible. Any leftover money will go to the university to continue to enhance programs for undergraduate and potentially graduate students.


Elitzer hopes the experiment makes MIT the biggest bitcoin-based community on the planet. If the project is a success, it could send the value of bitcoins through the roof, as the value fluctuates based on demand, much like stocks. If you were thinking about getting in on the investment, now would be the time.


But what about security? While there hasn’t been specific word on just how secure use of the currency will be on campus, MIT computer scientists and faculty are working hard on preventing digital hacks, as the currency is not insured and when stolen the owner is simply out of luck.


The students hope that this project is the first step towards making bitcoins a widely-accepted form of currency and compare the concept to the early stages of the internet (let the kids dream), but they aren’t the only ones predicting a bright future for the electronic form of payment. A plethora of bitcoin-based gadgets are also under development, like MEVU’s wearable bitcoin bracelet.


While bitcoins would really have to catch on in order for the product to sell, MEVU created a Bluetooth-powered bracelet that enables users to pay for their purchases with bitcoins by a simple flick of the wrist.



The silicon bracelet is a prototype and some adjustments must be made before it ever reaches stores. For one thing, it’s based on the iOS, but most Apple apps are no longer supporting bitcoins. What is more,, most retail locations are not yet accepting bitcoins, making purchasing the bracelet to shake your band at your computer a hard sell. Nonetheless, it shows forward thinking and a lot of confidence in the technology overall.


Have you invested in bitcoins? It may be time to make the jump.



See more news at:


Filter Blog

By date:
By tag: