Skip navigation
1 2 3 Previous Next


337 posts

If you've ever tried to use SPIFFS on the Dev version of the SparkFun ESP8266 Thing, you will quite likely have encountered the error message "SPIFFS Not Defined for SparkFun ESP8266 Thing Dev" as soon as you tried to upload a disk image using the ESP8266 Sketch Data Upload tool from the Arduino environment. This blog has some background info on this, but for those who are impatient, I'll give you the solution first.

The Problem

The SparkFun ESP8266 Thing Dev board definition is missing some essential details for the SPIFFS Data Upload tool to work correctly. Why SparkFun didn't include these in the board files is beyond me, there seems to be no technical reason behind it. Maybe it was just forgotten and maybe it will be fixed in the future. Maybe it is already fixed by the time you read this :-)


The Solution

Very simple: add the missing details. First locate your ESP8266 boards definition file. Under Windows, it should be in C:\Users\<your user name>\AppData\Local\Arduino15\packages\esp8266\hardware\esp8266\2.3.0\boards.txt. First make a copy of this file, could be handy in case things get messed up. Open this file with an editor that can deal with non-DOS line endings, such as WordPad. You will find using Notepad (Windows' default choice for a .txt file) confusing since it won't show the lines properly.

In the boards.txt file, look for the line that starts with "" (Use Ctrl-F for this or you will spend a long time scrolling and looking). This brings you straight into the right spot in the right section for the SparkFun Thing Dev board. Now right below this line, add the following lines:


Save the boards.txt file, reboot the Arduino environment and now the upload tool should be working fine. Bear in mind though that the SPIFFS Data Upload Tool is famous for giving problems when being used while the Arduino Serial Monitor is active, so make sure that the latter is closed, or not even started to begin with.

Congratulations, you now have a working setup for a SPIFFS Data Upload transaction on your SparkFun ESP8266 Thing Dev board. If you have no clue what just happened here, read the background info below.


SPIFFS, is that some kind of TV Snack?

In the case of ESP8266 based boards, it is a piece of magic to use part of your EEPROM as some sort of external hard disk. From the firmware on your board, you can access files and even modify them, and since they are stored on EEPROM, changes will survive power cycles. It is also possible to write an entire disk image to the ESP8266 in a way similar to programming the software into your board. For this, you create a subdirectory "Data" in the folder of your sketch and then you put all the neccessary files in that folder. Do not create any subdirectories in the Data folder as the SPIFFS tooling is simple and won't deal with subdirs. Once you're ready putting the files in that Data folder, you can upload them to your board by selecting Tools / ESP Sketch Data Upload in your Arduino environment.
The upload tool can be obtained from here: and a nice overview of how to use SPIFFS can be found here: a file system available on a board like this could be handy for a number of reasons. Using the ESP8266 as a web server comes to mind first, although I think for that you shouldn't go with a SparkFun board for that application (see also "A word of warning" further down below). But these "Things" are meant to be used as IoT boards and it is getting more common for IoT back-end servers to require certificates for things to authenticate to that server. Being able to put certificates in a simple file system is more practical than putting them in code as some sort of string constant.


To Dev Or Not To Dev, what's the difference?

This has been confusing some people for a while already, so don't feel ashamed :-) The difference is not that big, but the regular Thing assumes you have a USB to Serial converter for programming and preferably one with a specific pinout, so it can be hooked up straight to some of the Thing's external connectors. So it DOES have a USB connector, but this does nothing beyond powering the board from it. The Dev version has an onboard FTDI chip, which does that USB to Serial converting magic for you. In other words, the dev board can be programmed directly through the USB connector. There are some other minor differences in the implementations of the programming in respect to the Auto Reset / Auto programming circuitry, but you probably won't be to interested in that. What matters here is that for both boards, the ESP8266 is automatically put in programming mode by the Arduino Environment, so no need for these finger twitching toggle-reset-while-holding-down-prog-button exercises.
Looking further into the schematics, you will find that the Dev version sacrificed the LiPo charging functionality for the  built-in USB converter. If you really need that LiPo charger, you're probably best off developing on a Dev board and then go through the USB to Serial hassle once with a regular Thing.


A word of warning on SPIFFS and the SparkFun Thing boards

The SparkFun ESP8266 Thing boards have many qualities, but EEPROM size is not one of them. In total, there is only 512 KB available, of which supposedly 64 KB are available for your SPIFFS filesystem. This can probably tweaked in some ways, but you will quite likely need most of that EEPROM for your software, leaving that mere 64 kB for your files. You can't really do much about it until you take out your soldering equipment and replace the EEPROM chip for a larger one. In which case you might just as well order an ESP8266 board from another supplier, that comes with a bigger EEPROM chip straightaway.

Firmata is a protocol that is used to communicate with microcontrollers from any tablet/pc over the serial interface. There are implementations of Firmata for many other platforms too along with Arduino. You can find support for Firmata if you are using any Arduino IDE released after 2008.Use of Firmata lets you access GPIO of Arduino from any host device natively without uploading the sketch each time you change the sketch. You can use Arduino as ADC for your Pi as it doesn't have native ADC pins, you can also interface a whole lot of sensors by the additional GPIO that you will get after connecting the Arduino which eliminates uses of the port expander and ADC ICs to be interfaced with Pi.In this video, I have shown a basic example of blinking the onboard LED of Arduino from Raspberry Pi by using JAVA and for this, we are going to use the firmata4j library. 




Firmata4J Library:

Jar File of Library:

(Dependency for Firmata4J) JSSC (Java Simple Serial Connector):

(Dependency for Firmata4J) SLF4J API Module:
Firmata Protocol Page:
Protocol Details:
Related Videos: 
Java Application on Pi Playlist:
IOT With Raspberry Pi:




Grbl is a free, open source, high performance software for controlling the motion of machines that move, that make things, or that make things move, and will run on a straight Arduino. If the maker movement was an industry, Grbl would be the industry standard.


Most open source 3D printers have Grbl in their hearts. It has been adapted for use in hundreds of projects including laser cutters, automatic hand writers, hole drillers, graffiti painters and oddball drawing machines. Due to its performance, simplicity and frugal hardware requirements Grbl has grown into a little open source phenomenon.


Full information and code can be found at



As you can see the code will run on a low cost Arduino Uno R3 board and you can see the pin outs below.




This is great but can be a bit fiddly when trying to connect up Stepper motors, limit switches etc. So we decided to design a Breakout Board for it and make it available as a DIY solder up kit.

We have brought out the all the pins through buffer chips which are open collector outputs and also we have added a optocoupler  IC for each limit switch. This allows higher voltage inductive sensors to be used, as well as micro switches.



Below shows a typical setup with three stepper motors/drivers connected and 12V inductive limit switches. You have to also supply 12-24v in.


Below shows a typical setup with three stepper motors/drivers connected and Micro Switches on the Limit Switches. You have to link 5 Volts over into the 12-24V in.



Find below some example wiring for different stepper drivers.





Also you can bring out the pins from the GRBL breakout board and interface to an existing CNC Machine controller box that uses a DB25 style breakout board. You will probably already have the Limit Switches wired in to the breakout with level conversions already done. If this is the case then Link 5 volts into the 12-24 Volts in line to power the on-board optocouplers.



Here is a video showing the breakout board connected to an existing CNC Machine.


Grbl Breakout Kit for self assembly
Here is a picture of the kit and PCB.






Programming UNO R3 with GRBL Firmware

There are a few different ways to program the Uno R3 and if you want to get up and running quickly then simply download the latest .HEX code from and use Xloader to program it up. Xloader can be downloaded from here


Grbl comes with an array of options that be configured over the serial port and also the source code is available with other options that can be configured, compiled and then programmed. Check out the official Wiki for more info, as no point repeating it on this page.


Configuring Grbl to suit your machine.

There are a few settings you need to configure after programming grbl into your controller, these include bed max travel, feed rates, steps/mm etc etc. Again check out the grbl Wiki for full details.

You can do these manually by communicating with grbl using a terminal emulator such as HyperTerminal or there are various applications around for different platforms.

For Windows 10 we have knocked up a quick application that can be downloaded from the Windows App Store. It allows you to connect to your controlling and read out the configuration. You can then alter the values to suit your machine and write them back in. Also it allows other commands to be sent and the reply to be displayed in the Read Data box. You can send test Gcode commands and request status to see the results.



Software for sending Gcode to Grbl.

You are spoit for choice when it comes to software to send Gcode to Grbl and your best place is to google it.

I personally like Candle that can be downloaded here



Bernie, a crested gecko

This is Bernie, she lives with me in a vivarium, monitored by an Arduino.


You see, Bernie is a Crested Gecko (Crestie), and unlike most lizards that are kept commonly as pets, Crested Geckos need a mixed environment to ensure that they can comfortably survive in their habitat. Most lizards, such as bearded dragons, require sand, a heat lamp, ultraviolet light, and perhaps a small, covered space to hide in to help regulate their temperature.


We do not know a great deal about Cresties, and we are still learning about them, such as how long they live, what their habits are and how to care for them properly. Unfortunately this means that there are a lot of people, including pet store owners, who incorrectly care for Cresties. Meaning that they become deformed and poorly treated because of the lack of information and assumptions that they're the same as other lizards.


This lack of knowledge is caused by the fact that we thought Cresties were an extinct species, until they was rediscovered in 1994 to still exist on an area of land called New Caledonia.


For a period of time, Cresties were exported to America and Europe, where they were bred in captivity and ultimately became pets. Cresties are pretty well established now and their export from New Caledonia was put to an end, but that does not mean you cannot pick up a Crestie as a pet for yourself.


Cool! Or, Not?


New Caledonia has an interesting climate, being south of the equator and near Australia should give you some idea of the type of tropical environment which Cresties live in naturally. It is a place of high humidity, temperatures up to 29 degrees centigrade, and as low as 16 degrees centigrade, depending on the time of day, the time of year, and whether or not you are in a cool breeze and in the shade.


It is this kind of environment which we need to recreate in a vivarium to keep the Crestie happy, so that it is able to clean itself, keep hydrated and to shed its skin when necessary.


There are also other considerations to be made for the little virtual environment, such as ventilation / airflow to ensure that on occasion, the vivarium dries out a little to help prevent mould and other unwanted bacteria from growing. It is also sensible to clean out vivariums from time to time, and some people have their setups created as small ecosystems. With insects living in the substrate (usually consisting of a mixture of soil and/or orchid bark) alongside the crickets and soft fruit mix that the Cresties feed upon when the fancy takes them. So if your vivarium is intended to have living plants and animals inside along with the lizard, they too are something to take into consideration.



Taking Care of the Little Gal, Manually

Monitoring the habitat and maintaining it properly, for a time,  are all aspects of looking after the little gecko that we acted on manually each and every day as best we could. This was only possible to some extent, due to work we were not sure what was happening with the vivarium during the day. There's also the environment outside of the vivarium, depending on which room it resides greatly affects how warm or cold it gets, how quickly it dries out and how long it takes to do each of these.


The vivarium we use is long, stood vertically, since Cresties prefer to climb up and down trees and, as it turns out, burrow into the substrate to lay their eggs (even if they haven't had super fun times). The enclosure is monitored by two temperature sensors, one at the bottom of the tank, and one at the top as it is usually best to maintain a temperature gradient in the tank from cooler at the base to warmer at the top.


A hygrometer helps to keep track of the humidity in the tank, with a spray bottle simply used to keep the humidity up when it begins to get too low, too often. Eventually we tired of the bottle and found the funds to buy a misting system, which is basically a 12v water pump and a set of piping.


I live in the UK, and it is not always warm here which means some applied heat is necessary. The vivarium came with a light bulb, and we supplemented this with a heat mat and a ceramic bulb pointed at the glass tank. These are all controlled by a thermostat because doing this part manually, is not sensible in any way. Though these heating elements are not connected to the temperature sensors they are used as guides to ensure the settings on the thermostat are correct, it is also time aware because one of the power inputs can be connected to an on/off timer socket which works surprisingly well.


This setup has its limits, in the past few years the ambient temperature at summer time has been increasing, at least in the United Kingdom, and we had some difficult moments when the temperature was trying to exceed 29 degrees centigrade. Bernie didn't like this, as she was yawning a lot to try to cool down, and burying herself in the damp substrate. There's also no active ventilation, and another difficulty is finding a way to maintain the humidity properly as a spray bottle can become very insufficient very quickly, especially if it's a cold day and the heating elements are drying up the tank.


Introducing: Automation

When I finished University in 2010 I spent a lot of time hanging out with friends whom were studying their undergraduate degree courses in Electronic Engineering. It was here where I was introduced to micro-controllers and that sparked an interest in me to learn more about them and do more with them. My friends were mainly using PIC32s in the labs, or some equivalent, soldering on perfboard/protoboard/veroboard with serial interfaces to the computers. I'm not sure what it was that sparked my interest, I guess it was the idea of control and the sense of being able to monitor your surroundings and react to it, my dissertation supervisor also lamented at the time how they wanted to actually do more with them in light of computer networking. My how the times have changed in only a few years.


it wasn't until a couple of years later that I encountered Leeds Hackspace where JonS introduced me to an Arduino Uno and how to do the 'hello world' of programming the device at the time, blinking an LED. From that first example I started to collect together sensors, servos, and focused on getting each individual component working, wondering when I would have a reason to combine them together to create something sensible, and then along came Bernie.


Crested Gecko amongst Wires

Bernie likes hairEvery time Bernie is let out of the vivarium she goes for a wander up and around it, and (yes the power is disconnected) she enjoys crawling through the wires up against the ArduinoArduino that I currently have setup for the start of the monitoring and control project, we think that she would probably enjoy some more vines inside the vivarium as she also love to crawl into/up hair as well.


So the plan, use an Arduino, or a couple of them, to control fans which would help to ventilate and also cool the vivarium when needed, it would decide when to do so by monitoring the temperature with DS18B20DS18B20s and react to temperatures outside of the desired parameters as appropriate.


The next stage of this development would be to also control the misting system. This would be governed by a sensor, which at present is a DHT11, which is attached to the Arduino to detect the humidity level for when it gets too low, I considered misting the vivarium on a timer also, however this was attempted before all of the electronics and the tank was almost flooded (note to self, consider drainage for the vivarium tank). So, a humidity sensor and some intelligence on the actions is better. Since the Arduino can run from 12 volts from the VIN/RAW thanks to its onboard voltage regulator, I can power the fans, the misting system, and use mosfets between the logic input/output pins and the power for the water pump, while also using the 5v sensors. The fans would have to use pulse width modulation (PWM), using typical 120 millimetre fans designed for cooling a computer case works perfectly for this and happens to be the right size for the top of the vivarium, I could even monitor the speed of them as well, and use a potentiometer as a manual over-ride to control the speed if I didn't want to rely on the automatic logic coded into the chip. In fact, here's a handy fritzing:


vivarium monitor

The barrel jack on the left is the 12 volt in, while the barrel jack on the top right is to the misting pump/system, as it is purely a water pump in a box, connected up to a wall wart.


I was surprised to discover that Fritzing was a pain to use. Especially if you want to use parts that do not already exist in its parts library and forcing you to create new parts. To do so you can't create a new one from scratch, you have to repurpose an existing one and edit it. Trying to create a printed circuit board layout from your breadboard designs is even more annoying, to me at least. Fritzing kept crashing when trying to perform its autorouting and lost the circuit components. Good thing I had a backup.


As an extension to this design though, I could also take over the control of the heating elements from the thermostat that's currently in use. I would have to add additional circuitry to make it aware of the time of day and to maintain this without slipping out of synchronisation with real-time, though the current thermostat has been running for so long, reliably, it is a sufficient constant that I can rely on it to maintain heat.


What I really should look into though are methods of cooling the tank, especially since the ambient temperature in the UK has managed to hit temperatures of 32 degrees centigrade. I considered using a peltier, and they are an idea although they are horribly inefficient, plus I would likely have to actually cool something like the water reservoir for the misting system rather than the vivarium itself directly.


It's also worth noting that these components are not all sat on the breadboard like in the fritzing diagram, in fact, I had to find a way to encapsulate the DHT11 humidity sensor so that I could put it into the vivarium safely. So, enter an amount of overlapped heatshrink and a bit of well enveloped hot glue, and also practicing something I have never done, braiding:


IMG_20170808_223341.jpgIMG_20170808_223351.jpgI'm sufficiently pleased with how they turned out, and it's not the type of thing which Bernie will try to eat on, unless it moves in the dark. She'll probably use it to shed against if anything. The DS18B20 is similarly protected (though I bought it like this rather than making it up myself) :




Fritzing aside, the Arduino IDE steps up for programming the device and using the OneWire example as the basis, we have a very rudimentary program that can monitor the temperature input from the DS18B20 and output the PWM signal required to control the fans, here is a snapshot of the code from my github repo:



There's a lot of rough approximations here, and in fact this is only one version of the code and doesn't really take into account the potentiometer properly, yet. I had a hard time using the Arduino 'map' function to try to get it to control the fans in a rational manner (since they're 0-255 output for speed, and the potentiometer is 0-1023) it wasn't quite working properly (never reaching 100% speed and never going slow enough, input welcome).


I also haven't connected up a humidity sensor yet or control for the misting system, this is mainly held back because of my concern for not putting soldered contacts directly into the vivarium, I require a humidity sensor that is properly enclosed for two reasons: 1. to ensure that it doesn't short out and 2. So that Bernie doesn't mistake it for food and try to chomp on it and hurt herself (she jumps at shadows). So I'm still searching, else I'll probably heat-shrink wrap a DHT11.


Trying not to let the Magic Blue Smoke Out

I did once. Well, that's entirely not true for the Arduino, I have actually killed one of the DS18B20s I'm using, and I broke off the micro-usb connector from the Arduino. When I first setup the Arduino to monitor the terrarium's temperature that felt like the easy part. Buying the sensor and using the example OneWire code pretty much set that as 'done'. The hard part was buying powerful and appropriate fans to cool the vivarium and get the air flowing. I also wanted something which wasn't going to make too much noise, basically if you're using fans you're powering motors, and the smaller the fan, the more annoying and high pitched the noise is going to be. Now, I'm not sure what the tolerance to noise is for a Crested Gecko, but I'm sure that I get fed up of them quickly, plus we want to make sure we're moving a good amount of air.


At the top of the vivarium there is a removable panel which has a metallic mesh to allow heat and airflow. This is perfectly designed for the "Exo Terra" range of vivarium additions such as the heating lamp we currently have covering half of the panel. The other side was available and happened to be perfectly sized at approximately 240 millimetre by 120 millimetre, so two fans it is!


The fans have three connections, power, ground and signal, and most importantly they operate at 12 volts. Aside from the signal connection, which offers up the speed of the fan using PWM and I believe has a built in resistor on the fan to provide this at 5 volts.


The arduino however, operates at 5 volts logic, and will happily take 12 volts. So this meant I needed a way to control the fans via PWM at a voltage which the Arduino was happy at. There are some examples out there where you can solely use a 10kohm resistor connected to the power lines of the fans to control the speed. However I didn't want to do this (because learning), there are sensible reasons why not to, part of my concern for example, are power spikes that usually happen from turning motors on and off (diodes can also help with this). Relays are sometimes peoples choice, but they are too slow for PWM, they really don't like being switched on and off quickly. So my choice in this matter was the MOSFET.


The circuit for the MOSFET is relatively simple. I connected the 12v line to the Arduino and also to the 'positive' of the 120mm fans, and the 'negative' (ground) to one side of hte MOSFET. The other side of the ground is connected to the ground/GND of the Arduino. The third, centre leg of the MOSFET, utilising a pull down resistor (to prevent it floating if nothing else) is connected to an input/output logic pin on the Arduino, and it's this PWM pin which controls the fan's speed and overall provides enough protection to not set fire to the Arduino.


I haven't worked out the code properly to read the fan speed signal from the fans, though. I think I haven't quite got the synchronisation or the maths correct to make sense of the signal coming from the fans. It's important to have this feedback though to ensure that the fans are working, and to be able to alert if there's a problem with them.


I did consider having variable fan speeds, that would scale with the temperature detected, so that at lower temperatures there was still some airflow happening, and when it was getting too hot we put the fans at full speed to "yep, this needs cooling down, right now". The code for this was bad, and it was lagging the microcontroller so that the reaction time from temperature to fan speed was ever increasing (this is not a good idea). I will need to refactor the code so that it is interrupt based, and I changed the code so that it merely goes "okay, we're too hot now, turn the fans on max and cool down as quickly as possible", this has in truth worked reasonably well. So I'm not sure of the merit of the other method, aside from prevention of it getting to the 'it's too hot and we've made sure it doesn't get that high at all'. So I may reconsider it.


There is also some concept of circuit protection in the design, you see, when you're controlling motors and they're spinning up/down, you may be pushing electricity to them, however motors are also like miniature generators that can create some power themselves, and this power is known to spike higher in voltage than what they're rated at. So, to protect against this, we put diodes in the circuit to prevent the spikes from going back to the controller circuitry, and instead force it to run across the motor again. Which is somewhat safer.


Simulating Environments and Ensuring Stability

Once I've finally sorted out the code, the sensors, and the temperature control though I considered that I could effectively emulate the exact environment of New Caledonia. Since we can actually pull near real time information about the weather in the environment, we could use intelligence gained from this, historical and otherwise, to simulate the environment that the crested gecko should be experiencing. Creating almost a home away from home.


To do this properly, and also to keep track of whether or not the Arduino has been behaving properly I would likely have to introduce more hardware. Perhaps the illustrious Raspberry PiRaspberry Pi, providing its functionality as a Linux based computer that is connected to the internet. Now with feedback from the Arduino, based upon the fan speeds, humidity, temperature and compared to the weather in New Caledonia, or even the expected temperature in the UK, the system would know to prepare for changes in the environment which are coming up and to adjust accordingly.


Everyone loves graphs, right? Well I should be able to log the data over time and see how well the environment is simulating the environment compared to New Caledonia, for example here's some of the debug output from the code I've written so far:




For a while with the vivarium setup, several years ago in fact, we needed to buy an uninterruptible power supply (UPS) to ensure that the vivarium thermostat was able to maintain the temperature. We had a lot of power cuts. Most UPS devices actually come with USB connectivity, allowing detection of when you're running on UPS power, the state of the batteries, such as their temperature, charge level, whether or not they're running a maintenance cycle. I think this could also fit in well with the combination of a Raspberry Pi with the Arduino setup.


Happy family


Still Work to Do

I'll admit that progress on this has been somewhat slow, but progress has been made all the same. Hopefully this write-up will help to inspire your next Arduino project, or perhaps you've been considering setting up a vivarium system yourself.


I'm open to ideas or improvements to work on this, and I've had suitable motivation to progress because Bernie is practically part of our small, happy family, and at 5 years old will likely still be around for at least another 15.

Hello community. I was developed my own application for Arduino developers and today i had published it on Google Play. This app bring you flexible and configurable remote for your arduino devices via bluetooth modules HC-05, HC-06. This is free application and i hope i can use this place for show it. Also i hope i can get some feedback and if i will see my app is in demand, then i will improve it. I have some ideas how can do it. Also i will be happy to see any suggesting for future updates.


Here some screenshots of it:



Download link ->

Project website ->




What's new

ver 1.2

Added slider. Now you can control RGB Led, servo, and other PWM output via slider.

ver 1.1

Added the ability to create any number of configurations. You can easily switch between them.


Also i wrote a post about RGB Led controlling using this app. There i show example of arduino sketch, with Serial input and how can setup toggle and slider in my terminal. 

Come to read. RGB Led control via bluetooth modules HC-05, HC-06 using KvushCo Bluetooth Terminal

Arduino Home

An Open-Source platform to create digital devices and interactive objects that sense and control physical devices.

Arduino Tutorials
Arduino Projects


IMG_1190.JPGI was able to get a way from my booth at the 2017 Bay Area Maker Faire long enough to catch Massimo Banzi's annual State of Arduino speech. It was during one of these speeches late last year that Massimo announced that Arduino would be reforming as a single entity, removing a measure of uncertainty that was clouding the future of Arduino.  I was interested in hearing what direction Arduino would be heading in now that all parties were once again united under a single brand. It was during his State of Arduino talk a couple of years ago that Massimo promoted Arduino's new sister brand Genuino.  When the merger was announced it sounded like they would go back to being a single brand.


That hasn't happened so far as the company still sells boards under the Genuino name and from what I can tell it looks like the plan is to keep the Genuino as a sister brand to sell boards in the EU. I'm not sure if this has been clarified anywhere, maybe someone can comment if they know what the long term plan is for the Genuino brand, but the issue of the forked Brand outside the US was not addressed. Genuino and Arduino are the same except for the name, Arduino has the better brand recognition, so I am surprised something hasn't happened to unite these two under the Arduino name. Maybe there are still legal or practical considerations for not selling under the Arduino brand outside the US?


Arduino's focus is on opening up the Arduino IDE to more boards, branding Arduino as the "lingua franca" of microcontrollers, implementing their API on a broad range of architectures to make it easier for anyone to write embedded code and port from one processor to another.  Massimo Banzi gives a summary of his talk on his personal blog where he talks about six projects for the near future of the Arduino open source project.


His talk touched on cleaning up the API by separating the cross platform Arduino API code from the platform specific code; making the Arduino-IDE do a better job of automating coding that people would do by hand by discovering dependencies for included libraries, generating prototypes for functions you create, passing files to the compiler, getting a binary file, uploading it, and more; and improving the layout for Arduino libraries to support for multiple architectures, metadata and more. He also talked about debugging the backend and the need for a task scheduler to achieve some level of multitasking with Arduino.


{gallery} My Gallery Title







Here are some highlights from Massimo Banzi's talk:

  • 23.4 Million IDE downloads since March 2015 (although he suggested these numbers weren't up-to-date and could be higher) or 1 download every 2.6 seconds
  • 38.2 Million Website Users, a 32.2% increase from 2015
  • Their mission is to use Open Source, Open Protocols, Open Knowledge to enable people's creativity
  • They made microcontrollers easier to use for everybody and keep making technology accessible to everyone
  • They are now working heavily on IOT, with investments in boards, connectivity technologies and cloud services
  • They've renewed their focus on STEAM education launching specific initiatives and KITs to support teachers and students
  • They are always committed to Open Source, contributing what they do to the community
  • Arduino is focused on Maker prototyping, Internet of Things, Education Kits, and the DIY Professional.





How do you feel about the State of Arduino? 

Let us know in the comments below!

I'm writing this as a "Blog Post", because I did not see a way to make it a document: Which I would have preferred.


I ran into a problem on the Intel Edison board, that stuck me for a while on coding, until I finally found the issue was with the Arduino Atmega328 chip on the Intel's Arduino breakout board. My personal problem was that I was unable to run I2C while using some of the Analog pins. While the detailed hardware information can be found linked below, I wanted to create an "easier" guide to know what pins you CAN NOT use, if you plan to use others, so you don't keep re-writing your code, and can plan your wiring in advance, to also be able to purchase any expansions you need in advance as well to compensate for the pins you'll be locked out of by using another pin.


From this point forward, I'll refer to these pins you cannot use as "Zombie Pins", because they're physically present, but pretty much dead for use, with their life being somewhere else.


I'm going to make a list of pins in a grid. To the left is the Atmega pin number, to the right is all pins/functions on that pin. You can only use one of those pins listed on the right at a time, or you'll have some odd/unwanted behavior.



-This is NOT an all-encompassing guide to all functions, just conflicts for the most common used ones.
- I am going by the actual CHIP pin number listing.

- A = Analog Input, D = Digital I/O

- Some conflicts are labeled on the board (such as D pins having a function), but I'm including them anyhow, to allow people to plan their wiring in advance, and be able to know what they need to program before they even buy their board!


Atmega PinPin Functions
2**D1 / RXD
3**D2 / TXD
5D4 / PWM
11D5 / PWM
12D6 / PWM
14D8 / CLK0
15D9 / PWM
16D10 / PWM
17*,***D11 / PWM / MOSI
18*,***D12 / MISO
19*D13 / SCK
27A4 / SDA
28A5 / SCL


* = Also known to be used for some of the smaller holes you can solder into the board, near AREF and the "ON" LED (forget what they're called).

** = Also used for Atmega for USB programming. If you have trouble writing, try disconnecting device from these ports.

*** = There is a secondary of this function of this type in the ICSP circuit, near the Reset button
For these markers, please refer to the Reference link below for the breakout board for more information.


-I believe one of the Digital pins also controls the "L" LED, near 13.


Anyhow, I hope this helps others with the Arduino, including the Intel Edison when using the Arduino Breakout board!



Intel Edison Breakout Board:

This is my first use of transistors in a project. I need to control a SainSmart 16-Channel Relay Module using an Arduino 101(3v3 GPIOs). This Relay Module uses 5 vdc through Opto couplers to power the relays. The input pins on the relay board are at 4.4 vdc and need to be brought to GND to switch on.

When I connected the Arduino 101(3v3 GPIOs) directly to the relay module some of the relays would stay on while others would be controlled by the Arduino. It all worked fine when I tried an Arduino UNO(5v GPIOs) in place of the 101. But, I want to use the BLE capabilities of the 101.

So my solution is to use  2N22222N2222 transistors because I’ve read they are good at general purpose low-mid power switching Below is the configuration I think is correct Any feed back would be greatly appreciated I’ve tried reading the Data Sheet but I’m mostly going off of other forum posts


Relay Board inputs; +4.4vdc, input to ground 4mA

Arduino 101; 3.3vdc GPIOs, max 20mA per GPIO

T1  2N22222N2222

R1: 10K, to reduce current through the Base to 0.33 mA

R2: 100K, drop down resistor. (is it needed?)





This video is all about interfacing BMP180 module with Arduino. BMP180 will help us to measure environmental temperature  and pressure and by using that we can calculate the altitude which can be used in various applications like weather monitoring, navigation etc. The BMP180 sensor module comes with I2C interface and with a default address 0x77 which is not configurable limiting stacking of multiple modules to that same I2C bus. In this tutorial we will interface the module with Arduino by using I2C interface that is analog input pin A4 and A5. And for this we are not going to use any library although if you are interested you can use any library available online which are actually pretty easy to use. Interfacing the module without any library will help us learn how it works as well as we can interface to other devices also where libraries are not available.




Links :

Website (BOSCH SensorTec):

Schematic :

Code :

Datasheet :


Subscribe YouTube :


Guys Subscribe to my channel for latest contents into your inbox.

Support me to keep going.



Website :

Twitter :

YouTube :

What do you thing about this project?

Have you some interesting ideas for expansion?


Arduino users and other embedded system designers can now make user interface on the smartphones without wireless or app coding!!






The ESP8266 is a low-cost Wi-Fi chip with full TCP/IP stack and microcontroller capability produced by Shanghai-based Chinese manufacturer, Espressif Systems.The chip first came to the attention of western makers in August 2014 with the ESP-01 module, made by a third-party manufacturer, AI-Thinker. This small module allows microcontrollers to connect to a Wi-Fi network and make simple TCP/IP connections using Hayes-style commands. However, at the time there was almost no English-language documentation on the chip and the commands it accepted.The very low price and the fact that there were very few external components on the module which suggests that it could eventually be very inexpensive in volume, attracted many hackers to explore the module, chip, and the software on it, as well as to translate the Chinese documentation.


Source : WikiPedia (
Links :
Sparkfun AT Guide :


Sketch :
Buy ESP8266 :
Getting started with ESP8266 | AT Commands :


Subscribe YouTube :


Guys Subscribe to my channel for latest contents into your inbox.
Support me to keep going.

This blog documents some belated progress on my Star Trek themed Pi IoT design challenge entry. It is being put in the arduino area since that is where it is most useful.

I wanted to make the subsystems useful and built well enough to work reliably in their target environment, so this sensor array is built using a custom PCB.

The PCB did not arrive until well after the challenge was over, but it worked perfectly with no errors when I assembled it.

The card features an arduino pro micro which has a couple of quirks to be aware of:

  1. Sketches can defeat the USB so to get back into programming mode, you need to push the reset button twice, which reactivates the USB for 8 seconds, hopefully allowing you to get your software load started.
  2. I used the 3.3V variant of the pro micro so it could directly connect to the Bluetooth module.  This cpu runs at 8 MHz so you need to be sure the compiler is aware of the clock frequency, or all communications timing will be messed up. I installed the pro micro board type in the arduino IDE using this instructional note:

Other features of the card include an HC05 Bluetooth module, a Nokia 5110 LCD, a DHT11/22 temperature/humidity sensor a power switch, a reset switch, a solar panel connector and battery connector a recharging circuit, an I2C connector, a couple of input connectors (analog or digital).

Since I had to order a batch of 10 (for $10) I designed the card to have a little more general capability than just a remote temperature sensor.

The card has extra connectors for more sensors, but the main addition is an LCD connector, allowing it to be used as a stand-alone weather station.

Here is a video showing the system in action:

The android app was developed using App Inventor 2 from MIT.


Links to the Pi IoT Design Challenge site:

Pi IoT

Pi IoT - Smarter Spaces with Raspberry Pi 3: About This Challenge


Links to blogs about the Star Trek IoT Alcove project:

Pi IoT - Star Trek IoT Alcove - Blog 1

element14 and the photon torpedo - Pi IoT Blog 2

How many tablets to use? Pi IoT Blog 3

Starship Enocean Voyager

The Starship Enocean Voyager - Pi IoT Blog 4

LCARS (Library Computer Access Retrieval System){Star Trek} - Pi IoT Blog 5

LCARS Tablets

Henrietta LCARS

Alcove Transporter

Henrietta LCARS - Pi Iot Blog 6

arduino bluetooth weather station

I've been looking into designing my own Arduino programming and development board after seeing Ben Heck's episode. Apologies if this is in the wrong area.


So I made a quick Schematic in Eagle using the arduino schematic from the website, I've included support for the ATTiny85. I know this isn't the first time someone has done something like this, or with home pcb manufacture, just wanted to share some of the problems I've had with this design.


So here is the final result, I don't have any form during as I wasn't expecting it to work out. I haven't tested this board as there are a number of shorts, and I don't have a reset from the FTDI header.




I Tried to keep the layout simple as my original plan was to build this on proto-board, but I only had multi core wire and trying to wire that up was a nightmare in itself. So I took the plunge and etched my own board.

I have read of three (at least most mentioned) way of etching a PCB using a laser printer 1) Photo Paper 2) Magazine Newspaper 3) Print n' Peel. So i tried all of them, one of the reasons why i think that the copper on my board appears slightly pitted, removing the toner with fine grit sandpaper. By far the worst method, Print n' Peel, with kept jamming in my printer. Photo Paper worked well, but not all of the traces transferred. Possibly my traces and fills are too close for home manufacture, I plan to have a DRC for eagle best suited for home manufacture. The method I finally used was the Magazine paper, this gave me the best results.


I used Ferric Chloride, the only enchant I can easily find in the UK without online ordering. This worked a lot quicker than I thought it would.


Thing I want to change for next time;

  • Better Design board, mainly clearances with the copper fill ground. This made it almost impossible with my equipment to solder without shorting to ground.
  • Maybe using Photoresist, I've heard a lot of good reviews of this method
  • Solder Mask - I think this is a must, I am no expert at soldering, and it will help to make my boards look more professional.
  • Drill Press - I too late found out that I don't own a dremel chuck small enough to fit my drill bits, so all of the hole on this board where done using a old school archimedean drill (not fun )
  • Two sided board.


I would encourage anyone who has been tempted to design their own boards, just do it. It can be stressful but worth it.


Ultimately I want to have a process with I well works best and have a small movable workbench to make custom PCB's and solder station. As my flat is fairly small and i don't have room for a full workbench. If manage to do this I will keep the community informed

I will develop these more when i find time. I've also got a plan for this basic idea including a Raspberry pi, but too early to announce that.

Ublox Neo-6m from E-Bay

Posted by ajens23 Nov 9, 2016

Ublox Neo-6M  from E-bay

Hi All,


(First time trying this so please forgive if it's in the wrong place/format/whatever)


Just received a couple of Ublox Neo-6M GPS boards from E-bay
and thought I would try a quick review for anyone interested.

Board: GY-GPS6MV2 with Ublox Neo-6M

Seller: Worldchips

Shipping: included

Price: 17USD(+/-)


Apparently this board contains a voltage regulator (5 pin
chip to left of RX/TX pins) and can be powered off of a 5V supply. I am using
the 3.3V source from a Nearduino Uno (made from only the finest Chinesium).

The board appears to be well made. Soldering is good, antenna
connection is tight and assembled with a nice click/pop.

GPS TX is connected to digital pin 4 on Uno. Online
literature indicates that 3.3V will read as high. (It seems to work OK)

GPS RX is connected to a dropping resistor pair (4.7K + 10K) giving
3.4V. (It also seems to work OK)


Detailed directions here


VCC is attached to 3.3V supply of Uno.

GND is attached to Uno Gnd.

Serial monitor connection rate is set to 115200.

TX/RX rate between GPS and UNO is set to 9600. (note that the older GPS
chips were set to 4800bps)


Sketch is from TINYGPS examples on github:

When you first start up the GPS, it does take awhile before it starts
producing data. Be patient is can take up to 60 seconds to acquire lock.

It also does not work well indoors. I stuck mine on the window sill and
it was able to acquire a lock fairly quickly.


I checked my location using Google maps and it was within 6’ of true position.
I left the unit running for three hours and rechecked it. Indicated position
had drifted to about 15’-20’ from true position.

Not perfect, but for $17 I can probably live with it.


For those looking to delve a little deeper, here is information on the
NEMA data that the GPS can output.




Code from TinyGPS example

#include <SoftwareSerial.h>

#include <TinyGPS.h>

/* This sample code demonstrates the normal use of a TinyGPS object.

   It requires the use of
SoftwareSerial, and assumes that you have a

   9600-baud serial GPS device
hooked up on pins 4(rx) and 3(tx).


TinyGPS gps;

SoftwareSerial ss(4, 3);

static void smartdelay(unsigned long ms);

static void print_float(float val, float invalid, int len, int prec);

static void print_int(unsigned long val, unsigned long invalid, int

static void print_date(TinyGPS &gps);

static void print_str(const char *str, int len);

void setup()




TinyGPS library v. "); Serial.println(TinyGPS::library_version());

  Serial.println("by Mikal


  Serial.println("Sats HDOP
Latitude  Longitude  Fix
Date       Time     Date Alt  
Course Speed Card  Distance Course
Card  Chars Sentences Checksum");

  Serial.println("          (deg)     (deg)    
Age                      Age  (m)  
--- from GPS ----  ---- to
London  ----  RX  
RX        Fail");






void loop()


  float flat, flon;

  unsigned long age, date, time,
chars = 0;

  unsigned short sentences = 0,
failed = 0;

  static const double LONDON_LAT
= 51.508131, LONDON_LON = -0.128002;




&flon, &age);








  print_str(gps.f_course() ==
TinyGPS::cardinal(gps.f_course()), 6);

  print_int(flat ==
long)TinyGPS::distance_between(flat, flon, LONDON_LAT, LONDON_LON) / 1000,

  print_float(flat ==
TinyGPS::course_to(flat, flon, LONDON_LAT, LONDON_LON), TinyGPS::GPS_INVALID_F_ANGLE,
7, 2);

  print_str(flat ==
TinyGPS::cardinal(TinyGPS::course_to(flat, flon, LONDON_LAT, LONDON_LON)), 6);


&sentences, &failed);

  print_int(chars, 0xFFFFFFFF,

0xFFFFFFFF, 10);

  print_int(failed, 0xFFFFFFFF,





static void smartdelay(unsigned long ms)


  unsigned long start = millis();



    while (ss.available())


  } while (millis() - start <


static void print_float(float val, float invalid, int len, int prec)


  if (val == invalid)


    while (len-- > 1)


    Serial.print(' ');




    Serial.print(val, prec);

    int vi = abs((int)val);

    int flen = prec + (val <
0.0 ? 2 : 1); // . and -

    flen += vi >= 1000 ? 4 :
vi >= 100 ? 3 : vi >= 10 ? 2 : 1;

    for (int i=flen; i<len;

      Serial.print(' ');




static void print_int(unsigned long val, unsigned long invalid, int


  char sz[32];

  if (val == invalid)



    sprintf(sz, "%ld",

  sz[len] = 0;

  for (int i=strlen(sz);
i<len; ++i)

    sz[i] = ' ';

  if (len > 0)

    sz[len-1] = ' ';




static void print_date(TinyGPS &gps)


  int year;

  byte month, day, hour, minute,
second, hundredths;

  unsigned long age;

&month, &day, &hour, &minute, &second, &hundredths,

  if (age ==

******** ");



    char sz[32];

"%02d/%02d/%02d %02d:%02d:%02d ",

        month, day, year, hour,
minute, second);



  print_int(age, TinyGPS::GPS_INVALID_AGE,



static void print_str(const char *str, int len)


  int slen = strlen(str);

  for (int i=0; i<len; ++i)

    Serial.print(i<slen ?
str[i] : ' ');



Filter Blog

By date: By tag: