2.8″ TFT LCD Touch Screen ILI9325 with Arduino Uno and Mega

educ8s.tv uploaded a new video. This is a 2.8” Arduino Touch Screen Tutorial with the ILI9325 driver. Nick writes:

Hey guys, I am Nick and welcome to educ8s.tv a channel that is all about DIY electronics projects with Arduino, Raspberry Pi, ESP8266 and other popular boards. Today we are going to take a look at this 2.8” touch screen designed for Arduino. As you can see, I have loaded a demo program that displays a button on the screen. When I press the button with my finger, the program displays a message. As demonstrated the touch screen is working fine! Finally we can start building projects with a touch screen which are much more interesting and easier to use.

2.8″ TFT LCD Touch Screen ILI9325 with Arduino Uno and Mega [Link]

LT6658 – Precision Dual Output, High Current, Low Noise, Voltage Reference

Linear Technology announces the LT6658, a precision voltage reference that incorporates two high current output buffers.

The LT®6658 precision 2.5V dual output reference combines the performance of a low drift low noise reference and a linear regulator. Both outputs are ideal for driving the precision reference inputs of high resolution ADCs and DACs, even with heavy loading while simultaneously acting as output supplies powering microcontrollers and other supporting devices. Both outputs have the same precision specifications and track each other over temperature and load. Both outputs are nominally 2.5V, however each can be configured with external resistors to give an output voltage up to 6V.

LT6658 – Precision Dual Output, High Current, Low Noise, Voltage Reference – [Link]

Capacitor self-diagnostics


Peter Demchenko discuss about a design idea on how to test capacitors in circuit.

The electrolytic capacitor is far from being the most reliable electronic component. One of its failure modes – a gradual loss of capacity – can hardly be noticed until power supply malfunction occurs. Thus, any chance to monitor the condition of the filter capacitors of an electronic device in situ would be a useful thing.

Capacitor self-diagnostics – [Link]

Single-chip USB-C buck-boost battery charger


Intersil’s ISL9238 and ISL9238A add 5V-20V reverse boost for USB On-The-Go charging of portables such as smartphones and headphones; two USB-C buck-boost battery chargers support bidirectional power delivery in ultrabooks, tablets, power banks and other mobile products. by Graham Prophet @ edn-europe.com:

The single-chip ISL9238 and ISL9238A battery chargers can replace two-chip solutions to reduce bill of materials (BOM) costs by up to 40%. Both ICs employ Intersil’s R3 modulation technology to extend battery life and deliver acoustic noise-free operation, improved light-load efficiency and fast transient response. The ISL9238 and ISL9238A operate in forward buck, boost or buck-boost mode to fast charge mobile battery packs with up to 4-cell Li-ion batteries.

Single-chip USB-C buck-boost battery charger – [Link]

Programming ESP8266 With Arduino IDE : The Easy Way

The ESP8266 WiFi Module is a self-contained SOC that can give any microcontroller access to your WiFi network. It’s an extremely cost-effective board with a huge and ever-growing community. Each ESP8266 module comes pre-programmed with an AT command set firmware. This module has a powerful on-board processing and storage capability that allows it to act as a standalone microcontroller.

Following 2 easy steps, you can upload Arduino sketches on your ESP8266 using Arduino IDE.

  • Configuring the IDE
  • Making the circuit

Parts List:

  1. ESP 8266 Module.
  2. Jumper wires.
  3. A breadboard.
  4. One USB to TTL converter, a.k.a UART converter.

Configuring The IDE:

In order to bring support for ESP8266 chips to the Arduino environment, you need to add ESP8266 Arduino Core in the IDE.

NOTE: You must have Arduino IDE version 1.6.4 or higher. The latest version is highly recommended. Download the latest version of IDE from Arduino.cc.

  1. Install Arduino 1.6.8.
  2. Start Arduino and open Preferences window.
  3. Enter http://arduino.esp8266.com/stable/package_esp8266com_index.json into Additional Board Manager URLs field. (See the first image)
  4. Open Boards Manager from Tools > Board menu and install esp8266 platform. (See the second image)

Add URL to "Preferences" in Arduino IDE

Add URL to “Preferences” in Arduino IDE

Select ESP8266 board from Board Manager

Select ESP8266 board from Board Manager

Making The Circuit:

ESP8266-01 wiring for uploading program
ESP8266-01 wiring for uploading program
ESP8266-12E wiring for uploading program
ESP8266-12E wiring for uploading program


  1. Connect GPIO0 to Ground (set it LOW or 0)
  2. Connect CH_PD toVcc (set it HIGH or 1)


  1. Connect GPIO0 to Ground (set it LOW or 0)
  2. Connect GPIO15 to Ground (set it LOW OR 0)
  3. Connect GPIO2 to Vcc (set it HIGH or 1)
  4. Connect CH_PD toVcc (set it HIGH or 1)

Pin Vcc and GND should be connected to power supply’s +ve and -ve rail respectively. TX and RX of ESP8266 should be connected to RX and TX of USB to TTL converter respectively.

NOTE: You can replace the USB to TTL converter with an Arduino UNO board, but you have to upload a blank sketch or “bare-minimum” sketch to the Arduino so that the MCU of the Arduino board doesn’t interrupt. Connect TX and RX of the ESP8266 to RX and TX of the Arduino UNO respectively.


You are done! Now just select your ESP8266 board from Tools > Board menu, write any program, and click on Upload button. The ESP8266 will run as standalone microcontroller now.

To have a clear idea, read the article FLASH AT FIRMWARE TO ESP8266 also.

DIY Spectrum Analyser

Alan X has been working on a spectrum analyser project that can show the spectrum visually! He started working with ATTiny85 and kept on updating the project over time.


Alan X used Goertzel’s algorithm with a Hamming window, this algorithm can be used to detect a frequency from sampled data. Here is the preliminary code for a spectrum analyzer:

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
// Uses Daniil Guitelson's BGI library
#include "graphics.h" // -lBGI -lgdi32

#define SampleFreq 125000

int main(void)
  int N=250;
  double data[N];
  double samples[N];
  double freq;
  double s;
  double s_prev;
  double s_prev2;
  double coeff;
  double magn;
  int i;

  int gd=CUSTOM, gm=CUSTOM_MODE(700,700);
  initgraph(&gd, &gm, "");

  int X1,Y1,X2,Y2;
  double scale,xmin,ymin,xmax,ymax;

  // Find the maximum and minimum data range

  // Generate samples
  for (i=0;i<N;i++) {
    // Window the data
    // data[i]=samples[i]; // Straight Goertzel - not great
    // data[i]=samples[i]*(0.5-0.25*cos(2*M_PI*i/N)); // Hanning Window
    data[i]=samples[i]*(0.54-0.46*cos(2*M_PI*i/N)); // Hamming Window
    // data[i]=samples[i]*(0.426551-0.496561*cos(2*M_PI*i/N)+0.076848*cos(4*M_PI*i/N)); // Exact Blackman Window

  // Scan frequencies
  for (freq=100;freq<=50000;freq+=100) {
    for (i=0;i<N;i++) {
      // Goertzel


    // Get magnitude
    printf("Freq: %6f Mag: %6.4f\n",freq,magn);

    // Plot data


  return 0;

Daniil Guitelson’s BGI library was also used for the graphics.


Here is the output showing the DC, 3300 Hz, 5700 Hz and 25700 Hz signals:



The next step is to port the code to a suitable Arduino board and to show the results physically. Thus, he used a MicroView OLED display and here it is listening to a 3v 1kHz square wave:



#include <MicroView.h>

// Audio Spectrum Analyser
#define SampleInput A0   // Name the sample input pin
#define BandWidth  500   // BandWidth
#define MaxFreq   4000   // Max analysis frequency
#define Trigger     10   // Trigger to synchronise the sampler 2vpp at 1kHz = 32

// Define various ADC prescaler
const unsigned char PS_16=(1<<ADPS2);
const unsigned char PS_32=(1<<ADPS2)|(1<<ADPS0);
const unsigned char PS_64=(1<<ADPS2)|(1<<ADPS1);
const unsigned char PS_128=(1<<ADPS2)|(1<<ADPS1)|(1<<ADPS0);

// Setup the serial port and pin 2
void setup() {
// Setup the ADC
ADCSRA&=~PS_128; // Remove bits set by Arduino library
// Set prescaler
// ADCSRA|=PS_64; // 64 prescaler (250 kHz assuming a 16MHz clock)
// ADCSRA|=PS_32; // 32 prescaler (500 kHz assuming a 16MHz clock)
ADCSRA|=PS_16; // 16 prescaler (1 MHz assuming a 16MHz clock)

uView.begin();// Start MicroView
uView.clear(PAGE); // Clear page
uView.println("Spectrum  Analyser"); // Project
uView.println("0-20 kHz"); // Range
uView.println("agp.cooper@gmail.com"); // Author
uView.display(); // Display
uView.clear(PAGE); // Clear page
delay(2000);// Wait

void loop() {
static byte *samples; // Sample array pointer
static byte *window; // Window array pointer
static int N=0; // Number of samples for BandWidth
static long sampleFreq; // Sample frequency
long freq; // Frequency of interest
float s; // Goertzel variables
float s_prev;
float s_prev2;
float coeff;
float magn;
int i;

if (N==0) {
// Check sample frequency and set number of samples
samples=(byte *)malloc(100);
unsigned long ts=micros();
for (i=0;i<100;i++) samples[i]=(byte)(analogRead(SampleInput)>>2);
unsigned long tf=micros();

uView.setCursor(0,0); // Set cursor to beginning
uView.print("SI: A"); // Sample input pin
uView.print("SF: "); // Sample frequency
uView.print("MF: "); // Max frequency
uView.print("BW: ");// andWidth
uView.print("SN: ");// Number of samples
uView.display(); // Display
uView.clear(PAGE);// Clear page

// Create arrays
samples=(byte *)malloc(N);
window=(byte *)malloc(N);

// Modified Hamming Window
for (i=0;i<N;i++) window[i]=(byte)((0.54-0.46*cos(2*M_PI*i/(N-1)))*255);

// Generate test samples
for (i=0;i<N;i++) {

if (true) {
// Sychronise the start of sampling with data slicer
int a0,a1;
for (i=0;i<N;i+=2) {
if (a1>a0+3) break;
for (i=0;i<N;i++) samples[i]=(byte)(analogRead(SampleInput)>>2);

// Scan frequencies
for (freq=0;freq<=MaxFreq;freq+=(MaxFreq/40)) {
// Goertzel (https://en.wikipedia.org/wiki/Goertzel_algorithm)
for (i=0;i<N;i++) {
// Get magnitude
// Display on MicroView
// Frequency graduations
// Voltage graduations
uView.print("  0");

He then updated the project to work with Nokia LCD, here it is showing the 0-3v 1 kHz square wave signal:


Amazing ideas and projects can be inspired by this project. You can download these files to start your own spectrum analyser!

The full project and detailed information are available at the project page on Hackaday. You can follow it to keep updates with the latest versions.

From Sand to Circuits – How Intel makes integrated circuits [PDF]


Here is a nice PDF document from Intel explaining how integrated circuits are made.

From Sand to Circuits – How Intel makes integrated circuits [PDF] – [Link]

World’s first broadband infrared LED by Osram


Designed for everyday food analytics, the SFH 4735 LED emits broadband infrared light in a wavelength range from 650 to 1,050 nanometers. by Julien Happich @ edn-europe.com

The component is well suited as a light source for near-infrared spectroscopy, for example to assess the quality of food thanks to mini spectrometers that could be developed as an add-on for smartphones.

World’s first broadband infrared LED by Osram – [Link]

Temperature Measurement with NTC Thermistors


Philip Kane @ jameco.com discuss about how to measure temperature with NTC thermistors. He writes:

Thermistors (thermal resistors) are temperature dependent variable resistors. There are two types of thermistors, Positive Temperature Coefficient (PTC) and Negative Temperature Coefficient (NTC). When the temperature increases, PTC thermistor resistance will increase and NTC thermistor resistance will decrease. They exhibit the opposite response when the temperature decreases.

Temperature Measurement with NTC Thermistors – [Link]

A LEGO-Compatible Digital Weather Billboard

Internet of LEGO “IoL” is an interactive LEGO city built and designed by Cory Guynn, a cloud computing and IoT enthusiast. This project combines computer and electronics  engineering with our favorite childhood toy, LEGO!

Through the IoL blog, Cory shares a collection of circuit projects, coding examples, and tutorials which use Arduino, Raspberry Pi, NodeJS, Node-RED, and LEGO.


A recently added project is a digital billboard that broadcasts the weather information from IoL local weather station. It uses a Raspberry Pi running Node-RED to collect weather data from the local station and display it on an OLED screen powered by an ESP8266.

The hardware materials needed for this project:

  1. Raspberry Pi
  2. WeMos D1 mini
  3. OLED 128×64 I2C screen
  4. 2x LEDs
  5. 2x 220 ohm resistors
  6. Breadboard and wires
  7. LEGO bricks!

And the required software:

WeMos D1 mini is a cheap mini wifi board based on ESP8266 and compatible with Arduino and NodeMCU. It has 11 digital I/O pins that support PWM, I2C, and interrupts, and has only one analog input with a microUSB connector. The WeMos D1 is available for only $4 and is supported by many shields.

WeMos D1 mini top and bottom faces
WeMos D1 mini top and bottom faces

The 128X64 OLED is about 1.3″ display, it is very readable due to its high contrast. This display is made of 128×64 individual white OLED pixels, each one is turned on or off by the controller chip. No backlight is required because the display makes its own light, which reduces the power required to run the OLED.

Adafruit Monochrome 1.3" 128x64 OLED graphic display
Adafruit Monochrome 1.3″ 128×64 OLED graphic display

OLED’s driver chip, SSD1306 can communicate in two ways: I2C or SPI. The OLED itself require a 3.3V power supply and 3.3V logic levels for communication.

The display uses I2C connection at this project, so you will need to solder the two jumpers (SJ1/2) on the back of the OLED, then use the ‘Data’ pin as ‘I2C SDA’ pin and ‘CLK’ pin as ‘I2C SCL’. The WeMos D1, OLED, LEDs, and resistors are connected as shown in the figure.


To simplify configuring WeMos D1, a special firmware called “ESPEasy” has been used. It is a free and open-source web configurable software framework for IoT, which allows the device to be configured using the web browser instead of writing codes.

ESPEasy can be uploaded to the WeMos D1 using the Arduino IDE by installing the ESP8266 board support from Boards Manager, and then uploading the ESPEasy firmware as described in this tutorial.

ESPEasy Firmware on Arduino IDE
ESPEasy Firmware on Arduino IDE

MQTT is a lightweight machine-to-machine publish/subscription messaging protocol. It works like Twitter where each device will subscribe and/or publish to a topic, much like a #hashtag, and the payload will then contain the data being transmitted.

Mosquitto is a free open source broker that works perfectly on a Raspberry Pi. It is a MQTT server manages the MQTT message flow, and connects with all devices.

The last step is configuring the Raspberry Pi on the weather station for sending the information to the billboard. An easy way for that is using Node-Red, a visual tool for wiring together hardware devices, APIs and online services for IoT applications.

Node-Red is pre-installed on the Raspbian Jessie image. Run the software and download this flow. It will accept an MQTT message on the topic “/sensors/iolcity/weather/#” and transmit it to the WeMos on the topic “/billboard/cmd”. Function nodes will format the message using JavaScript.

Node-RED Billboard MQTT Flow
Node-RED Billboard MQTT Flow

You can use it with your own weather station or any other sources of data, just change the MQTT input nodes to match your topics. To build a weather station check this IoL project and this ChipKIT-based station. Alternatively, you could get weather data using the Weather Underground service with the Node-RED node.

Further information and detailed description are available at the original project page.