Category: Arduino

After discovering the tiny but mighty ATtiny85 microcontroller, I decided to put it to use to help me park my car in the garage. Sure, I could continue to use the softball hung from the ceiling to let me know when I have the car pulled in far enough, but why not take advantage of some tech and have it show me instead? Alternatively, for these times, it is also a fun way to clearly demonstrate 6ft social distancing. 😉

ATiny85 Microcontroller

The ATtiny85 has 5 GPIO easily usable pins (technically you can even use Reset pin as a 6th GPIO but that makes it much more difficulty to reprogram). For information about how to program the ATtiny85, see my previous blog post here.

For my “Parking Helper” project I decided to use the low cost entry level ultrasonic distance sensor, the HC-SR04 and two 7-Segment LEDs to show the distance between the device and the front of the car.

HC-SR04 Ultrasonic Sensor

The HC-SR04 has 4 pins: VCC, Trig, Echo and Gnd. The Trig and Echo lines will be driven by the Attiny85.

The HC-SR04 measures distances by sending (TRIG) an sound pulse and measuring the time it takes for the ECHO. Sound travels through air at 332 meters per second at 20 °C (68 °F). Using this the unit provides a duration pulse back to the controller that can be used to determine the distance.

The speed of sound is: 343m/s = 0.0343 cm/uS = 1/29.1 cm/uS

I found a great project here where the author uses the HC-SR04 as an ultrasonic rule. Using the ATtiny85 to trigger and receive the duration pulse we can determine the distance to the parked car.

// Send TRIG HIGH for 10 microseconds 
// to trigger the HC-SR04 to send a sound pulse
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

// Read the ECHO duration
  duration = pulseIn(echoPin, HIGH);

// convert the duration to cm
  distance = (duration / 2) / 29.1; 

LED Display (2 Segment)

Driving the display with two 7-segment LEDs is a bit more complicated. Each segment has 7 LEDs to form the numbers plus one LED for the decimal point. That would require 8 GPIO ports for each LED Display or a total of 16 GPIOs! The ATtiny85 has only 5 available for use so we need another way. Thankfully, we can use two low cost 8-bit shift registers (74HC585) and get by with using only 3 GPIO and still drive the 16 LEDs on the two displays.

Here is how it works… The ATtiny85 sends the binary data for the the numbers to a first 74HC595 8-bit register using its “Data Input,” “Clock” and “Latch” lines. Once the register receives a total of 8 bits (1 byte), it will overflow the data out through its “Output” line which can be connected to the “Data Input” of another register.

We toggle the “Clock” to signal to the registers to record the value of the data line (1 or 0). We do that for each of the bits of the two bytes we need sent for each display. Finally, we have the ATtiny85 toggle the “Latch” to let the registers know when the transmission is complete. They then lock the 8 output lines (QA to QH) to high or low depending on what they recorded. These lines are connected to the individual LEDs on the 7-segment LED displays.

I found a great example of using the 74HC595 to drive multiple LED Displays here. I used that code to send the data as well as the byte arrays used to form the numbers on the LEDs. Since that project was using a common anode LED and my project uses a common cathode LED I had to flip the bits. In the code below, a one (1) value would drive the LED high (on) and a zero (0) would drive it low (off).

/* Set up 7-segment LED Binary Data

     |--A--|
     F     B
     |--G--|
     E     C
     |--D--|   H - Decimal

     0b00000000
       ABCDEFGH
  */  
  numArray[0] = 0b11111100; // 0 - Zero
  numArray[1] = 0b01100000; // 1 - One
  numArray[2] = 0b11011010; // 2 - Two
  numArray[3] = 0b11110010; // 3 - Three
  numArray[4] = 0b01100110; // 4 - Four
  numArray[5] = 0b10110110; // 5 - Five
  numArray[6] = 0b10111110; // 6 - Six
  numArray[7] = 0b11100000; // 7 - Seven
  numArray[8] = 0b11111110; // 8 - Eight
  numArray[9] = 0b11110110; // 9 - Nine
  numArray[10]= 0b00000000; // All Off

Circuit Schematic

Pulling it all together, here is a schematic I put together that combines the ATtiny85 with the two 74HC595 registers, two LED displays and the HC-SR04 ultrasonic sensor.

A Kicad schematic is included in this project and the schematic export is sown above. The circuit is powered with a steady 5V DC supply (e.g. USB adapter). The HC-SR04 is an entry level sensor and does suffer from some fluctuation. Logic in the code attempts to stabilize the measurement by making multiple readings.

List of Materials

• 1 x ATiny85 Microcontroller (DigiKey)
• 2 x 74HC595 8-bit Shift Register (DigiKey)
• 1 x HC-SR04 Ultrasonic Distance Sensor (DigiKey)
• 2 x 7-Segement LED Display CC (DigiKey)
• 16 x 220 Ohm Resistor
• 1 x 100uF Electrolytic Capacitor (DigiKey)
• 1 x 0.1uF Ceramic Capactior – (Amazon)

Code

The code for the project can be found on GitHub: https://github.com/jasonacox/UltrasonicDistanceDisplay

Imperial and SI Units

In Imperial unit mode, the code is written to display distances in inches (1 to 11) for distances less than 1 foot. Once the distance reaches 1 foot, it will show feet in decimal (1.0 to 9.9) until the distance reaches 10 feet when it will display in feet only (e.g. 10).

In SI unit mode, it will show centimeters for distances less than 1 meter (1 to 99, then it will show meters with decimal (1.0 to 9.9) until the distance reaches 10 meters and will continue to show meters only.

To toggle Units: Hold the distance to 4 (either unit) for ~4 seconds and it will toggle between units. Imperial mode will flash “in” and SI mode will flash “c”.

Sleep Feature

Sleep Mode: The code includes logic to turn off the display when there is no movement and power back on when movement is detected.

Prototype

This guide will help set up a Mac OS computer to program an ATtiny 85 using the USB Tiny AVR Programmer from Sparkfun and the Arduino IDE.

Required Items:

• Sparkfun Tiny AVR Programmer (Sparkfun) – This is a handy USB based programmer for ATtiny microcontrollers. It is powered by an ATtiny84 that is set up as a USBtinyISP programmer. The board has an 8 pin socket to hold a ATtiny45/85 microcontroller that you want to program.
• ATtiny 85 Microcontroller (Digikey) – The ATtiny85 is a low-power 8-bit microcontroller based on the AVR enhanced RISC architecture.
• Arduino IDE (Download)
• Mac computer (e.g. MacBook Pro) with OS 10.14 or later

I used the following steps to get the Sparkfun Tiny AVR Programmer working on my Mac. Hopefully this will be helpful for you as well. Your experience may vary.

Step 1: Install ATtiny85

Install the ATtiny 85 into the programmer. Make sure you orient the chip so that pin 1 (usually identified by a dot) is by the notch. Once this is installed, plug the USB into your computer. You will not see a light and Mac OS will not recognize it as a serial port (don’t worry).

Step 2: Set up Arduino IDE

Install the Arduino IDE software (Download) and navigate the menu Arduino -> Preferences and in the field for “Additional Board Manager URL” paste this link:

https://raw.githubusercontent.com/damellis/attiny/ide-1.6.x-boards-manager/package_damellis_attiny_index.json

Click “OK” to save and restart the Arduino IDE. Navigate the menu Tools -> Board -> Boards Manger and type “attiny” into the top search board and there will click on the “Install” button on the attiny board package.

You should now see an entry for ATtiny in the Tools > Board menu. Select “ATtiny25/45/85”.

For “Processor” select the chip you are using, e.g. ATiny85.

For “Programmer” select “USBtinyISP“

For “Clock” unless you have an external crystal in your circuit, you should select “Internal” and 1 MHz seems to be fine for most projects.

Finish by clicking “Burn Bootloader“. You should see the LED on the programmer flash. If it doesn’t work, you may need to Quit the Arduino IDE and restart to try again.

Please note: On the Mac, you do NOT select a serial “Port”. The IDE will program the ATtiny through the USBtinyISP that is loaded on the Tiny AVR Programmer board.

Step 3: Program your ATtiny85

You can use the example blink test to make sure you can program your ATtiny85. You can use the built in blink test but you will need to change the LED_BUILTIN to be 0 (zero). You can also copy and past the following code:

void setup() {
  pinMode(0, OUTPUT);
}
void loop() {
  digitalWrite(0, HIGH);   
  delay(1000);                       
  digitalWrite(0, LOW); 
  delay(1000); 
}

Arduino 1.x IDE: Click the upload button (right arrow) or press Command-U.

Arduino 2.x IDE: Select Sketch > Upload Using Programmer or Shift-Command-U

Once uploaded, the built-in LED should start to flash.

The ATtiny85 has PWM (Pulse Width Modulation) outputs so you can use the analogWrite() function to adjust the brightness of the LED from 0 to 255. Here is an example that fades the LED.

/*
  Fade
  This example shows how to fade an LED on using the analogWrite()
  function.
  The analogWrite() function uses PWM, so if you want to change the pin you're
  using, be sure to use another PWM capable pin. On most Arduino, the PWM pins
  are identified with a "~" sign, like ~3, ~5, ~6, ~9, ~10 and ~11.
*/
int led = 0;           // the PWM pin the LED is attached to
int brightness = 0;    // how bright the LED is
int fadeAmount = 1;    // how many points to fade the LED by
void setup() {
  pinMode(led, OUTPUT);
}
void loop() {
  analogWrite(led, brightness);
  brightness = brightness + fadeAmount;
  // reverse the direction of the fading at the ends of the fade:
  if (brightness <= 0) {
     analogWrite(led, 0);   
     delay(1500);
     fadeAmount = -fadeAmount;
  }
  if(brightness >= 255) {
    fadeAmount = -fadeAmount;
  }
  delay(10);
}

References

This was tested on Arduino 1.x and 2.x IDEs, on an Intel i7 based Apple MacBook Pro and on an M2 based MacBook Air using an USB-C to A adapter.

• High-low tech: Programming an ATtiny w/ Arduino 1.6 (or 1.0) – http://highlowtech.org/?p=1695
• Instructables: Program an ATtiny With Arduino – https://www.instructables.com/id/Program-an-ATtiny-with-Arduino/
• Getting started with Atmel ATtiny85 (AVR Programming) – https://electronut.in/getting-started-with-attiny85-avr-programming/
• Programming with AVRdude – https://learn.adafruit.com/introducing-trinket/programming-with-avrdude
• Crosspack for AVR Development – https://www.obdev.at/products/crosspack/index.html
• How to Program an Attiny85 From an Arduino Uno – https://www.instructables.com/id/How-to-Program-an-Attiny85-From-an-Arduino-Uno/
• Programming the ‘AtTiny85’ With the ‘Tiny AVR Programmer’ and Supplemented ‘Arduino IDE’ – https://www.instructables.com/id/Programming-an-Atmel-AtTiny85-using-Arduino-IDE-an/

I’ve always wanted to add a backyard weather station to help record not just temperature data, but humidity, pressure, rainfall, wind speed and UV levels. My recent experiments introduced me to the ESP8266 NodeMCU, a low-cost microcontroller with embedded WiFi. I just needed to add a solar cell, a battery, a sensor and an enclosure.

Solar Power

I found a 2.5W 5V/500mAh solar cell (from Amazon) and a 3.7V 3000mAh rechargeable Li-ion battery pack (Amazon). After some research (see here), I added a TP4056 charger module (Amazon) that regulates the charging and protects the battery from overcharge.

I added a 0.1uF ceramic capacitor and 100uF electrolytic capacitor to smooth the output voltage. I used a simple 3.3v voltage regulator (DigiKey) to feed the 3.3v bus for the ESP8266 and sensors.

Monitoring the voltage coming from the solar cell and/or battery would help determine if the system is getting enough power during the day to keep the system running at night. The ESP8266 has an analog input (A0) that can be used to determine the output voltage but it can only handle up to 3.3v. By using a simple 2 resistor divider circuit (see right) I could monitor the voltage and apply a multiplier to get to the actual voltage I measured with a multimeter. In this case, the A0 pin was reporting 907 when the multimeter was showing 4.69v so I used 4.69 / 907.0 and further sampled other readings to ensure I had the correct value.

Circuit Design

The sensors I wanted to add included a BME280 pressure and humidity sensor, a one-wire DS18B20 temperature sensor and a 2N2222 transistor powered rain detector. I put the circuit together using a simple breadboard and started on the code.

Using the free open source KiCad electronic design software, I build a schematic drawing to help build the final non-breadboarded product.

Getting Started with Arduino IDE and ESP8266

The ESP8266 NodeMCU has a USB port that allows the microcontroller to be easily powered and programmed with the Arduino IDE . However, it is not as easy to set up and use as an Arduino device. I found out that you will need to install a driver to see the device on my MacBook (see here for MacOS instructions and download the USB to UART Bridge VCP Drivers here). Once the driver is installed, the Arduino IDE needs to be set up to manage the NodeMCU. The ESP8266 I purchased came with some instructions:

Instruction & Steps of How to use:
1. Download and Install the Arduino IDE (download here)
2. Set up your Arduino IDE as: Go to File->Preferences and copy the URL below to get the ESP board manager extensions: http://arduino.esp8266.com/stable/package_esp8266com_index.json
3. Go to Tools > Board > Board Manager> Type “esp8266” and download the Community esp8266 and install.
4. Set up your chip as:
Tools -> Board -> NodeMCU 1.0 (ESP-12E Module)
Tools -> Flash Size -> 4M (3M SPIFFS)
Tools -> CPU Frequency -> 80 Mhz
Tools -> Upload Speed -> 921600
Tools -> Port -> (whatever it is)
5. In Arduino IDE, look for the old fashioned Blink program. Load, compile and upload. Go to FILE> EXAMPLES> ESP8266> BLINK

Code

Once I had the ESP8266 connected, I could start creating the code. The code is available here: https://github.com/jasonacox/WeatherStationWiFi

Rain Sensor

Using a simple NPN transistor, you can detect the presence of water. I wanted to detect rain which mean that I needed to add a couple of electrodes connected to that transistor (for detection) and our power supply. Water allows a small amount of current to pass through it to detect water, you will need to amplify it, hence the need for the transistor which turns a low current into a switch to a much larger current. The ESP8266 digital inputs can see the switched power from the transistor and can indicate water has been detected.

Wind Speed Sensor with an Anemometer

An anemometer is a device used to catch the wind and record its speed.

I found a 3D model on https://www.thingiverse.com/thing:2559929

More to come…

Installation