Introduction And The Big Picture

Tiny-Ciaroduino is a small-sized Development board based on the beautiful ATtiny85 chip from Atmel. Don’t get fooled by its small size, it’s powerful with great potential and well-documented resources built around it. We wanted to make a small-sized and low-cost development board that fits in any project without hesitation. You don’t need to give up your expensive Arduino or Raspberry pi board anymore to build your project. Blow up your cheap Tiny-Cairoduino board and buy another one, EASY!

There are a lot of open-source Duinos out there, I’m building one more open-source Duino-inspired board but with some addons and features that I was searching for. Tiny-Cairoduino is mainly inspired by the Digispark and the Trinket boards. Thanks to the open-source community. The main goal of the Tiny-Cairoduino board is to integrate the strength points from all the available ATTiny85 based dev boards and come out with a new beast that is easy to program and easy to play with on the hardware level too. And, totally open-source!

Our plan is to develop a whole set of shields that helps hobbyists and newbies to easily implement their hardware projects like if they are assembling lego bricks. We are currently working on that and we will be publishing these shields very soon.

I told you before, Don’t get fooled with its size! Despite being so small The Attiny85 chip has 8K bytes of flash memory and 5 I/O pins. All the 5 GPIO pins can be programmed as digital inputs or digital outputs. Including ADC(analog input) on four pins, PWM(analog outputs) on three pins -more can be achieved with software PWM-. It literally plug and play thanks to the preloaded bootloader that helps you to reprogram the board over USB like any Arduino board. Tiny-Cairoduino is also compatible with Arduino IDE. Even though you can program your Tiny-Cairoduino using the Arduino IDE, it’s not fully 100% Arduino-compatible. There are some things you trade-off for such a small and low-cost microcontroller!

• Tiny-Cairoduino does not have a Serial port connection for debugging so the serial port monitor will not be able to send/receive data. But, you still can reprogram your board through the USB connection.

Tiny-Cairoduino specifications:

1. Support for the Arduino IDE 1.0 and later (OS X, Windows, and Linux).
2. Built-in USB for programming.
3. 5 I/O pins (2 are used for USB only if your program actively communicates over USB, otherwise you can use all 5 even if you are programming via USB).
4. 8 KB flash memory (about 6 KB after bootloader),
5. I2C and SPI (vis USI).
6. PWM on 3 pins (more possible with Software PWM).
7. ADC on 4 pins.
8. On-board power indicator LED.
9. On-board WS2818B addressable RGB led (connected on pin 4).
10. Keyboard or other HID devices emulation (mouse, gamepad …).
11. Handy pinout header to easily connect your Tiny-Cairoduino with the outside world.
12. On-board RESET button.
13. A whole set of shields to maximize and expand the board functionality.
14. Four mounting holes!

Guided Tour

Let me take you a tour through your Tiny-Cairoduino development board, Each board is assembled here at Make Some Stuff with love.

• Mini-B USB: We settled on the Mini-B USB for powering the board and code uploading for many reasons. The Mini-B USB is very rigid and solid on the PCB unlike other connector types like the Micro-B connectors which can rip off the PCB easily. Also, the Mini-B USB is a proper connector type, you can grab any USB cable with any length from any hardware store. Some Attiny85 Dev. boards use a PCB that slides into a USB port to cut costs, but that makes it hard to re-program and annoying to power with an external battery pack.

• Power LED: A cool power indicator LED. It lets you know when your board is powered up by being so lit!

• Reset Push-button: An onboard reset push-button launches the bootloader program when pressed. Making it easy to reprogram the board without unplugging and replugging the board to the computer.

• External reset pin: We bring out the reset pin so you can reset your board without reaching the onboard reset button. It’s handy when your board is inside an enclosure or a box and it’s hard to reach out, you can wire up a button to this pin to reset your board on the road.

• Breadboard-friendly header: You can easily plug the board on a breadboard and have a bigger space to wire things up.

• WS2818B RGB LED: An onboard WS2818B addressable RGB LED connected on pin #4. You can easily control it to make some cool stuff according to your needs.

• AMS1117-5V regulator: An onboard 5V 1A voltage regulator. It allows you to supply voltage from 7V to 12V on the Vin pin without fearing the needed 5V for the microcontroller. It does the work for you. Making the Tiny-Cairoduino proper for DIY projects and very easy to connect to a wall adapter, power bank, battery, or any other kind of power source.

Tiny-Cairoduino Pinout

Power Pins

Let’s start with the power pins. On the top of the board, you will see three different power pins 5V pin, VIN pin, and GND pin.

• 5V pin: It’s a power positive pin connected to the output terminal of the voltage regulator and also connected to the USB 5V terminal. If you are powering your Tiny-Cairoduino board from your computer through the USB cable, you can use this pin to get 5V upto 500mA coming from your computer USB port, with it you can charge a battery, or control some output devices. If you are powering your Tiny-Cairoduino board from an external power source like a battery, power bank, or any other kind of power source through the VIN pin, you can use this pin to get 5V upto 1A coming from the onboard voltage regulator.

• VIN pin: You can use this pin to power up your Tiny-Cairoduino board from a battery, power bank, power adapter, or any other type of power source. Connect the positive terminal(+) of your power source to this pin and the ground terminal(-) to the Tiny-Cairoduino GND pin. Your power source needs to be between 7V and upto 12V.
• GND Pin: It’s the common ground pin of the Tiny-Cairoduino used for logic and power. It is connected to the USB ground and the AMS1117 voltage regulator. This is the pin you’ll want to use for any and all ground connections.

GPIO Pins

All the GPIO pins can be used as digital input or digital output pins, you can use them to read data from a sensor, control an LED, reading switch state, … They are all 5V logic pins. Each pin can provide upto 20mA of current. Don’t connect any component that draws more than 20mA directly to the GPIO pins like motors for example. You can use a transistor, relay, or motor driver instead. 

The first three GPIO pins(#0, #1, #2) are all completely free you can program them without worrying about USB communication interference.

• GPIO #0: It’s connected to the ATtiny85 PB0 pin, it can be used as an output PWM pin, also can be used as MOSI pin(SPI communication), also can be used as I2C data pin(SDA I2C Pin).
• GPIO #1: It’s connected to the ATtiny85 PB1 pin, it can be used as an output PWM pin, also can be used as MISO pin(SPI communication).
• GPIO #3: It’s connected to the ATtiny85 PB1 pin, also can be used as SCK(SPI communication clock pin), also can be used as I2C clock pin(SCL I2C pin), also can be used as an analog input pin which is known as A1.

The remaining two GPIO pins(#3, #4) are connected to the USB port for USB programming. When the board is in the bootloader mode or in the middle of a program uploading these two pins are used to send/receive data to/from the computer. So, it’s highly recommended to not use them while you are reprogramming your board. Also, it’s recommended to disconnect any connections from these pins while uploading your program.

• GPIO #3: It’s connected directly to the ATtiny85 PB3 pin, It’s also used for USB programming, it also can be used as an analog input pin which is known as A3. it also can be used as a PWM output pin.
• GPIO #4: It’s connected directly to the ATtiny85 PB4 pin, It’s also used for USB programming, it also can be used as an analog input pin which is known as A2. it also can be used as a PWM output pin. It’s also connected to the onboard WS2818B LED.

• RST: The reset pin is connected directly to the ATtiny85 reset pin and to the reset push button. It can be used to restart your board in case you want to reset it. Or to enter the bootloader mode to easily reprogram your board without unplugging and replugging the USB cable. You can wire a simple push-button from the reset pin to the ground and press it if you want to enter the bootloader mode in case the board is inside an enclosure or a box and it’s hard to reach.

Installing The Board Drivers

To be able to program your board and make it recognizable by your laptop, you need to install some drivers. MAC and Linux operating systems already have the drivers installed. So, MAC and Linux users don’t need this step. Only Windows users need to install the board drivers. 

We need to download the Digispark bootloader Windows drivers from the link down below. After extracting the .zip file, if you are using a 64-bit Windows OS you will need to use this installer “DPinst64”. And, if you are using a 32-bit Windows OS you will need to use this installer “DPinst”.

After finishing the installation process. Plug in your Cairoduino board to your laptop and open the device manager on your windows. Now you should find your Tiny-Cairoduino board listed under the “libusb-win32 devices” as “Digispark Bootloader”. 

If you did not find it. Click on the “View” tab from the top menu bar and select “Show hidden devices”. Now, you should see “Unknown device” under “Other devices”. 

Press right-click on “Unknown device” and select “Update Driver Software…”

select “Browse my computer for driver software”. Then select the location for the drivers we installed in the previous step. You can use the “Browse” button to select the drivers location.

Once you finish that and see the message “Windows has successfully updated your driver software” now unplug your board and plug it in again. You should now find your Tiny-Cairoduino board listed under the “libusb-win32 devices” as “Digispark Bootloader”.

How To Program Your Board

After installing the DigiSpark drivers, we are now ready to program our Tiny-Cairoduino board. By default, Arduino IDE does not contain the Digispark boards so we need to add these boards manually by ourselves. To do that, from the Arduino IDE top menu bar press on File > Preferences and add the link below in the Additional Boards Manager URLs then click ‘OK.

http://digistump.com/package_digistump_index.json

After that, from the Arduino IDE top menu bar press on tools > Board > Boards Manager and search by “Digistump AVR” then select “Digistump AVR Boards by Digistump” and click on install. 

After installing the board on your Arduino IDE, now you can select the “Digispark (Default 16.5MHz)” board from Tools > Board under the Digispark AVR Boards.

Now, you are ready to upload your first program to the Tiny-Cairoduino board. Copy the code down below, paste it into your Arduino IDE and press the upload button. Once you see the message “Plug in device now … (Will timeout after 60 seconds)” in the messages display place on the bottom of the Arduino IDE program, press on the reset button of the Tiny-Cairoduino board. The code will get uploaded on your Tiny-Cairoduino board and the Arduino IDE will display “Micronucleus done. Thank you!”. 

// NeoPixel Ring simple sketch (c) 2013 Shae Erisson
// released under the GPLv3 license to match the rest of the AdaFruit NeoPixel library
#include <Adafruit_NeoPixel.h>

// Which pin on the Arduino is connected to the NeoPixels?
#define PIN            4

// How many NeoPixels are attached to the Arduino?
#define NUMPIXELS      1

// When we setup the NeoPixel library, we tell it how many pixels, and which pin to use to send signals.
// Note that for older NeoPixel strips you might need to change the third parameter--see the strandtest
// example for more information on possible values.
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_RGB + NEO_KHZ800);

int delayval = 5; // delay for half a second

void setup() {
  pixels.begin(); // This initializes the NeoPixel library.
}

void loop() {
  for (int i = 0 ; i <= 255 ; i++) {
    pixels.setPixelColor(0, pixels.Color(i, 0, 0)); // Moderately bright green color.
    pixels.show(); // This sends the updated pixel color to the hardware.
    delay(delayval); // Delay for a period of time (in milliseconds).
  }
  delay(80);
  for (int i = 255 ; i >= 0 ; i--) {
    pixels.setPixelColor(0, pixels.Color(i, 0, 0)); // Moderately bright green color.
    pixels.show(); // This sends the updated pixel color to the hardware.
    delay(delayval); // Delay for a period of time (in milliseconds).
  }
  for (int i = 0 ; i <= 255 ; i++) {
    pixels.setPixelColor(0, pixels.Color(0, i, 0)); // Moderately bright green color.
    pixels.show(); // This sends the updated pixel color to the hardware.
    delay(delayval); // Delay for a period of time (in milliseconds).
  }
  delay(80);
  for (int i = 255 ; i >= 0 ; i--) {
    pixels.setPixelColor(0, pixels.Color(0, i, 0)); // Moderately bright green color.
    pixels.show(); // This sends the updated pixel color to the hardware.
    delay(delayval); // Delay for a period of time (in milliseconds).
  }
  for (int i = 0 ; i <= 255 ; i++) {
    pixels.setPixelColor(0, pixels.Color(0, 0, i)); // Moderately bright green color.
    pixels.show(); // This sends the updated pixel color to the hardware.
    delay(delayval); // Delay for a period of time (in milliseconds).
  }
  delay(80);
  for (int i = 255 ; i >= 0 ; i--) {
    pixels.setPixelColor(0, pixels.Color(0, 0, i)); // Moderately bright green color.
    pixels.show(); // This sends the updated pixel color to the hardware.
    delay(delayval); // Delay for a period of time (in milliseconds).
  }
  delay(100);
}

After successfully uploading the code on your Tiny-Cairoduino board, The on-board WS2818B LED should now start breathing between red, green, and blue colors. Congrats! You uploaded your first Arduino code to your Tiny-Cairoduino board.

Board Design

Before designing the schematic file, We must settle on the parts and the specific footprints that we will use to build this board. Since we want to make this board as small as possible. We decided to use only SMD parts. All the resistors and capacitors are in 1206 SMD footprint except only one capacitor in 0805 SMD footprint. To regulate the input voltage, we used an AMS1117-5V voltage regulator since it comes in a relatively small form factor but with great power. We used two Schottky diodes, one on the USB port and the other one on the voltage regulator output pin to protect them from any possible reverse current.

To identify our Tiny-Cairoduino board as a USB device to the host, we need to implement the USB communication circuit. Since, the signaling on the D+ and D− lines should be within 0V to 3.3V rails, while the host-supplied voltage is 5V. So we used two 3.3V Zener diodes on the D+ and D- lines to pull those lines two 3.3V. Ali Shtarbanov explained that part in an amazing way is this blog.

We put a 5050 SMD 5V addressable LED(WS2818B) on the board. It’s connected directly to pin #4 on the ATtniy85 chip. We used two 22uf SMD 0805 capacitors on the input and output pins of the voltage regulator to eliminate any ripples(noise) from those lines. We used one green 0805 SMD LED connected directly to the 5V line which acts as a power indicator. We used a generic two-pin SMD push button that connected to the ATtiny85 reset pin.

We love the open-source community! You can download the PCB Eagle source design files from this link

Board Fabrication

Before sending the Gerber files to PCBWay to manufacture the Tiny-Cairoduino board, I machined a test board on my Milling machine to test all the functionalities and to make sure that everything is working fine. After that, I sent the Gerber files to PCBWay who sponsors this build!

To make the PCB traces I used a 0.1mm v-bit. And, a 1.5mm 2 flutes square endmill to cut the PCB outline. 

PCBWay is a PCB manufacturer and PCB assembler based in Shenzhen. They offer a broad spectrum of PCB prototyping, assembly, design, and CNC/3D printing services across five factories that are staffed by more than 520 employees. The coolest feature I use a lot before ordering my PCBs is the instant quote tool. PCBWay’s website is well designed and convenient. You can use the online instant quote tool to get an estimated cost for your board according to the fabrication parameters you select. Which made PCB ordering very easy and fast.

Uploading the bootloader

To be able to program your Tiny-Cairoduino board directly using the USB port, there’s a special program called “Bootloader” that runs on the microcontroller once you supply power to the board. The bootloader program is responsible for making the Tiny-Cairoduino board a USB recognizable device. and taking new programs from you and flashing them on the ATtiny85 chip memory. By default, the ATtiny85 does not come with the bootloader preloaded with any bootloaders. So we need to upload the bootloader to the ATtiny85 microcontroller manually. This is a one-time process. 

We will use the same bootloader runs on the Digispark board “micronucleus tiny85” boot-loader, originally written by Bluebie. You can use any AVR programmer to upload the bootloader to the Tiny-Cairoduino board or use an Arduino UNO board which we will use in this step.

In the first step, we need to configure our Arduino UNO board as an ISP(In-System Programming) to work as an AVR programmer to the Tiny-Cairoduino board. Connect your Arduino UNO to your computer and open Arduino IDE then navigate to File > Example > ArduinoISP and upload the Arduino ISP code.

In the second step, we need to connect the Arduino UNO board to the Tiny-Cairoduino board as the wiring diagram down below. We are using a 10uf polarized capacitor on the reset and GND pin of the Arduino board.

In the third step, Connect your Arduino UNO board to your computer and open Arduino IDE. Find which port is your Arduino board connected to. In my case, my Arduino UNO board is connected to COM6 .We will need that information in the next steps

After this, download the bootloader burning files from the link down below. open the “Burn_AT85_bootloader.bat” and change the COM port number “PCOM5” with whatever COM port number your Uno is connected to. Save the changes before exiting.

Now move the edited “Burn_AT85_bootloader.bat” and “ATtiny85.hex” files into the Arduino IDE root folder (C:\Program Files (x86)\Arduino). After that right-click on the “Burn_AT85_bootloader.bat” and select “Run as administrator” it will take about 5 or 6 seconds to burn the bootloader to the Tiny-Cairoduino board. If all went well, you should receive this message “AVRdude done. Thank you. Press any key to continue…”. 

Now, your ATtiny85 chip is flashed successfully with the bootloader. You can now connect the Tiny-Cairoduino board directly to your laptop and use it like any development board.

The post Tiny-Cairoduino Open-Source DIY Kit appeared first on Make Some Stuff.

Recently, I have been using a lot of AVR chips and I faced few problems regarding burning the code on these chips using commercial AVR programmers. So, I decided why not building my own AVR programmer and get rid of all of this hassle. And, why not customize it according to my needs.

Tiny AVR Programmer Background

Today, we will take a look at how this board is designed, and I will take you on a journey on how each component is working in this design.

If you have just an AVR chip, you need something to program it. the most common way is through ICSP(In-circuit serial programmer). simply, it’s a board that has 6 pins usually a 0.1″ pitch header that can talk to your AVR chip through the SPI protocol. At the other end, it also can talk with your PC through the USB protocol. So, after compiling your C code using avr-gcc, the programmer board will take and send it to your AVR chip directly. You can think of it as a bridge between your PC and your AVR chip.

I did my research for AVR programmers and I found a lot of cool resources. this one specifically caught my eye. It’s the FabOptimus AVR programmer built by Ali Shtarbanov which built on the FabISP programmer built by prof. Neil from MIT Media Lab. the FabOptimus documentation is very good and easy to follow if you are a newbie. I decided to make a very small modification to the FabOptimus AVR programmer since it doesn’t have a power indicator LED, I wanna add one!

PCB Design And Circuit In-depth Analysis

First, we need to understand how this board is designed and how each component in this circuit is behaving.

This AVR programmer is based on the ATtiny44 AVR chip which by default it comes blank, no code or anything is uploaded to it like any microcontroller chip you buy. Since we are building an AVR programmer, we need to upload a very specific firmware to the ATtiny44 chip that tells exactly the role it should follow and execute. Simply, which is sending some hex files to other AVR microcontrollers. This firmware is called FabISP firmware(more on that later.)

So, we need to be able to upload the FabISP firmware to the programmer AVR chip then disable the possibility of reprogramming it.

To be able to upload the FabISP firmware to the programmer AVR chip we need to pull its reset pin to LOW(0 volts). and to disable the possibility of reprogramming it once it has been programmed, we need to pull its reset pin to be always HIGH(5 volts). So, we need to design the circuit in such a way that the reset pin is HIGH(5 volts) by default. But, once another programmer is connected to it, it can pull the programmer AVR chip reset pin to LOW(0 volts). That’s why we are using a 10k ohm pull-up resistor on the reset pin.

As you notice the ATtiny44 chip reset pin is connected to the RST pin on the ISP pin header through a 0 ohm resistor. after uploading the firmware to the ATtiny44 chip we will remove this zero ohm resistor to disable the possibility of reprogramming the board again.

Since we need to use our programmer board to program other AVR boards, our programmer board will need to be able to provide the reset signal to the other AVR boards that we need to program. So, we are also connecting an I/O pin from the ATtiny44 chip to the RST pin of the ISP pin header to provide the reset signal to the other AVR chips that we need to program.

To reduce any high frequency noise or any voltage drops coming from the power supply we are using 1uf decoupling capacitor between the VCC(5 volts) and GND.

We also using a 20MHz resonator as a clock source for the ATTiny44 chip instead of it’s internal clock to achieve more accuracy.

We are using two 3.3v Zener diodes as voltage clippers to regulate the voltage from 5v to 3.3v. According to the V-USB and USB specifications, the voltage on the USB data lines should not exceed 3.3v. Also, we are using a 1.5k ohm pull-up resistor on the D- pin of the USB to make it recognizable as a low-speed device on the host side.

Finally, I made a simple edit to the board. I added a power indicator LED to the board.

It’s a best practice to disconnect the VCC pin on the ISP pin header to make sure that the AVR programmer is not attempting to supply power to the board that we want to program. the board that we want to program should provide its own power. If we didn’t disconnect the VCC pin on the ISP header, the AVR programmer and the board being programmed will draw their current from the USB port(from your computer). if your USB port can’t supply that much current or at any short circuit circumstances, that may cause a huge problem to your computer.

PCB Manufacturing

As you can see, I fabricated this board using a CNC milling machine at Fab Lab Egypt. But, if you are searching for high-quality PCB manufacturing with a solder mask and silkscreen at a very fair price and fast worldwide shipping with no minimum requirements you may order as small as 10 pieces for 5$. you can order yours from PCBWay. You can also support me by just ordering this board from my link.

We love open source. You can download all the board source files from my Github repo.

PCB Soldering And Components Placings

Uploading The Firmware To The Programmer

To upload the FabISP firmware to the FabISP AVR programmer board, we need another programmer to help us upload the firmware to our FabISP board. we will use an Arduino UNO board as an ISP programmer and we will connect it to our FabISP AVR programmer board.

First, we need to upload the “ArduinoISP” sketch to the Arduino UNO board. You can find that sketch from files->Examples->ArduinoISP->ArduinoISP.

After uploading it to the Arduino UNO board. Let’s connect our FabISP AVR programmer(Target) with the Arduino UNO board(Programmer).

D10(Arduino) –> Reset (Target)
D11(Arduino) –> MOSI (Target)
D12(Arduino) –> MISO (Target)
D13(Arduino) –> SCK (Target)
GND(Arduino) –> GND (Target)

As you can notice we are connecting a 10uf capacitor between the Reset and the GND pin of the Arduino UBO board. As you notice, we are not providing power to our target board directly from the Arduino board. We are providing power to the FabISP AVR programmer board(target) by connecting it separately to the laptop through the USB port. And don’t forget to make a common GND between the two boards by connecting the GND of the FabISP AVR programmer board(target) board to the GND of the Arduino UNO(programmer).

After connecting the Arduino UNO board(Programmer) To the FabISP board(Target) we need to compile the FabISP firmware and upload it to the FabISP board. The Arduino UNO board will act as a bridge between my Laptop and the FabISP board. Since I’m using a Mac machine, I will download AVR CrossPack. CrossPack is a development environment for Atmel’s AVR® microcontrollers running on Apple’s Mac OS X, similar to AVR Studio on Windows. It consists of the GNU compiler suite, a C library for the AVR, the AVRDUDE uploader, and several other useful tools.” After heading to the AVR CrossPack website, click the “Download” button and install the .dmg file. That’s it!

Then we need to download the FabISP firmware from the link below. The Makefile which is inside the original firmware folder is ready to use with the avrisp2 or the usbtiny, if you will use a different programmer from these two options it will not work. So, I made some tweaks to that Makefile to make it compatible with the Arduino Uno that I use as a programmer. And it’s now ready to use with your Arduino UNO as a programmer you can download it from the link down below.

Now, we will open the terminal and navigate to the firmware folder. Then, clean any previously compiled files by writing make clean. Then we need to generate a new .hex that meets our new MakeFile. We will use the make hex command.

Then we need to write the make fuse command to set the fuses so the board will use the external clock. You should see a response like the one in the first image. Lastly, use the command make program to burn our firmware to the board to work as an AVR Programmer.

FabISP AVR Programmer Testing

After finishing the previous steps, your computer should now recognize the board as an ISP. Since i’m using a MAC machine, click on the Apple logo, then click in “About This MAC”, then “System Report”.

Then from the left side menu under the “Hardware” section click on “USB”. your programmer should be recognized by your computer with the name FabISB. Which means your AVR ISP is now ready to work!

FabISP AVR Programmer 3d Printed Enclosure

I designed an enclosure for the Tiny AVR programmer you can download it from the links down below. I 3d printed these parts with 20% infill without supports.

Here comes the end of the tutorial, thanks for your patience and check our upcoming tutorials on how to use this Tiny AVR programmer and how to program your own circuit boards. Don’t hesitate to drop down any question you want!

The post How I Made My Tiny AVR Programmer appeared first on Make Some Stuff.

Today we will learn how to build a standalone ATmega328p board. The same chip used in the Arduino UNO board. It’s Arduino UNO compatible which means that you can program it from the Arduino IDE without any hustle.

Used Components

ATmega328P Bare minimum configuration

Before building our standalone ATmega328P chip Arduino compatible board, let’s take a look at the awesome Arduino UNO board and see the main components that used to build that beautiful thing.

The first main component is the ATmega328P chip which is the brain of the board. A Voltage regulator that regulates the input voltage to a 5V clean output which gets used mainly by the ATmega320p chip. The 16MHz crystal oscillator, that creates an electric signal with a given frequency. Simply it counts the seconds so you don’t have to. Some LEDs to make you sure that the board is running smoothly and still alive. DC Plug allows you to connect the board to a DC power source. USB Port allows you to connect the board to your computer. Some pin headers to interface it with the external world(sensors, motors, LEDs, ..) through some jumper wires.

After knowing the main components used in the Arduino UNO board, we can make one using the same main components that we stated before which is called the ATmega328P bare minimum configuration.

Schematic

Wiring Diagram

As you can see, the bare minimum configuration means using the smallest possible quantity of components that makes that thing runs without problems. but later on, we will add some more components like LEDs, buttons, pin headers, .. to spice things up.

the ATmega328P works at 5V that must be well regulated without any spikes that’s why we are using a 10microfarad capacitor between the 5V power line. in order to make the ATmega328p runs, you have to apply a HIGH logic value “5V” on the “reset” pin.

Usually, the ATmega328P chip works on a 16MHz crystal oscillator placed on the pins 9 and 10 but in order to make it oscillate it needs two 22Picofarad capacitors connected to the GND.

But we want to spice things up, let us add some more components to give the board more features and make it more user-friendly.

Schematic

Cairoduino V1.0 Board

We added some new components to the bare minimum configuration that we discussed before to add more features to the board and make it more simple to use like a very normal Arduino UNO board.

1. DC Power plug to make connecting the board to a power source easy and fast.
2. L7805 voltage regulator, so you can plug it to any power source ranged between 7V-12V and the L7805 chip will regulate that voltage and give the ATmega328p chip a well-regulated 5V. The difference between the input voltage and the output voltage will go in a form of heat.
3. Reset button, to be able to reset the board easily in case of any misbehaving.
4. power LED as an indicator that tells the user if the board is connected to the power source or not.
5. On&Off switch.
6. pin headers to allow the user to connect any electronic components like sensors, LEDs, switches, … to the board easily using some jumpers, like any Arduino board.
7. FTDI breakout board, to be able to connect the board to the laptop so you can program and upload the code to it easily without removing the ATmega chip itself.

PCB Manufacturing

This board is designed on Eagle from Autodesk. You don’t have to be a PCB design expert to make or own this board because it’s fully open-source you can download the whole project from this link.

If you need this eagle project as a template so you can customize it according to your needs, you are very welcome to do anything you want to the project.

You can order your own Cairoduino board from PCBWay in just Two clicks. from this link.

From my point of view, PCBWay has the most user-friendly web-based interaction design in the industry! You can instantly get the quotation of your PCB, you can also check the order fabrication and processing status online in your account panel, After your PCBs are sent out to your address, you can track your order shipping status online and a lot more.

Uploading the bootloader to the chip

To be able to use the Arduino IDE to program the chip, we need to burn the bootloader to the Atmega chip. At this step, we need an Arduino UNO board we will use it as a programmer by connecting the MOSI, MISO, SCK pins between the ATmega328p chip and the Arduino UNO board.

If you already have an ATmega chip with the Arduino bootloader pre-loaded you don’t need to do these steps.

After connecting the ATmega chip with the Arduino board, we need to open the Arduino IDE –> File –> Examples –> ArduinoISP –> ArduinoISP

Then, set the Programmer to Arduino as ISP. Tools –> Programmer –> Arduino as ISP.

Now, it’s the time to burn the bootloader, Tools –> Burn Bootloader.

FTDI breakout board

As we stated before, we are using the FTDI module to connect the Cairoduino board to the laptop so we can program and upload the code to it, also you can send, read some stuff back and forth to the serial monitor through the established serial communication.

LED Blinking

Let’s try to upload a hello world code to the board to see if it behaving as expected or not. open Arduino IDE –> Examples –> Basics –> Blink

after connecting the board to your laptop and hitting the upload button, you should see the built-in LED which is connected to pin 13 blinking every 1 second. if you want to know more details about how LED blinking works you can check this tutorial which we published before.

The post ATmega328P Standalone Board appeared first on Make Some Stuff.

Makers always look at the simplest and shortest way to get things done. So, today we will learn how to control our home light switch in the simplest and quickest way.

Hardware Components

Introduction

Today, we will learn how to control home light switches by just hand-clapping, Cool ha! to build that project we will use some new electronic components like the decade counter CD4017 IC and the UA741 op-amp, and a condenser MIC as a sound sensor. So, let’s do it

Working Scenario

• Sensing

The main part of the project is sensing the hand-clap, we used an electret condenser MIC to do that job. which converts sound energy into electrical energy. this electrical signal will be an input signal to the UA741 IC. that electret MIC is very sensitive, easy to use, and cheap.

• Triggering

After sensing the hand-clap, the generated electrical signal will go to the input pin of the UA741 op-amp which works in this project as a comparator, the UA741 IC will compare the MIC input signal with a specific reference voltage if the input signal is higher than that reference voltage it will output logic value “HIGH”. And will output “LOW” when the reference voltage is higher than the input voltage.

We are using a potentiometer connected with the UA741 chip to adjust the reference voltage, which works just as setting the sensitivity of the circuit.

The UA741 IC output value goes to the “Clock” pin of the counter 4017 IC to turn on and off the relay.

• Driving high voltage/current load

You know, we are building this circuit to control AC high voltage loads. So, we used a 5VDC relay to make our small poor circuit able to communicate with that beefy AC high voltage load.

UA741 op-amp works as a comparator

The typical use of the UA741 IC is to amplify a specific signal. Essentially it takes an input voltage, amplifies it by a specific gain, then outputs an amplified voltage. That’s it. It’s mostly used in the speaker circuits to amplify the input signal to make the sound loud and clear.

But today, we will use the UA741 op-amp as a comparator, not as an amplifier.

As you can see, there’s a positive pin called “non-inverting terminal” and the negative pin called “inverting terminal”. these two pins are the input voltage pins. Also, there’s the voltage output “Vo” pin, and obviously the two power supply pins VCC, and GND.

Since the gain naturally of the op-amp is very huge, then what happens when we feed the op-amp two input pins?

If the input voltage on the positive terminal“Non-inverting pin” is higher than the input voltage on the negative terminal “Inverting pin” Even by a tiny amount. the op-amp will try to amplify the difference between those two inputs by a huge gain and the output voltage from the op-amp will equal (the difference between the two input voltages * the huge gain) which is a very large amount like hundred and hundred thousands of volts or something. But it can’t do it since you are powering your circuit by a 12V or 5V or even 15V.

As a result, it will saturate at the amount of voltage which you are powering your op-amp with. Which is the VCC.

Vice versa, if the input voltage on the negative pin “inverting terminal” is higher than the input voltage on the positive pin “non-inverting terminal” even by a tiny amount, the output voltage will equal the -VCC (GND).

UA741 Op-amp Pinout

• Pin 1 and 5 (Offset null)

We can set the op-amp gain value by connecting a capacitor on pins 1 and 5 but we don’t have to use those pins in this application, we will keep them unconnected.

• Pin 2 and 3 (Inputs)

Voltage input pins. We are connecting a potentiometer on the negative terminal (Inverting pin) to adjust the sound sensor sensitivity (Reference voltage). So, you can make the sensor very sensitive and feel the hand-clap from a long distance. Or decrease the sensitivity if there’s a lot of noise around you or something.

• Pins 4 and 7 (GND, VCC)

Easy! it’s the power supply pins. Pin 7 is VCC and 4 is GND. This chip can handle an input voltage from 5V to 15V.

• Pin 6 (Output)

The voltage output pin.

• Pin 8 (Not Connected)

Pin 8 is unconnected.

CD4017 IC Decade Counter

Each output of this chip will turn on, one at a time, sequentially or in succession. For example, let’s say that we are connecting ten LEDs with the chip. Each LED is connected on a different output pin, each LED will light, one at a time unless all have been turned on at the same time. After it reaches the last output pin(Q9) it will start over again and repeats and repeats infinitely.

This counting behavior is working by a command from the 4017 IC “Clock” pin which plays a big role in 4017 chip, without this pin the chip will not work at all. Once the “Clock” pin goes from LOW to HIGH, at this point the chip knows that it is the time to turn off the current output and turn on the next output. So, it knows when to act based on the clock signal.

CD4017 IC Pinout

• Pins 1,2,3,4,5,6,7,9,10,11

It’s the output pins where we place the load which we need to control. The outputs are numbered from Q0 to Q9. In our case, we will use only two output pins (Q0, Q1) to turn on and off the relay, the transistor which controls the relay state will be connected on Q0, and a normal LED on Q1 to indicate that the relay state is off.

• Pins 8 and 16 (GND, VDD)

Power supply pins, this chip can handle an input voltage from 3.3V to 18V.

• Pin 15 (Reset)

It resets the count back down to output 0 (Q0), normally it’s grounded. This means when it brought to a HIGH logic level it will reset the count down back to output 0 (Q0).

• Pin 14 (CLK)

As we stated before, It’s the pin that tells the chip when to start/stop counting.

• Pin 13 (EN)

The enable pin is an active low pin, which means it will normally be connected to the ground to make the chip active and operating properly, once it is brought to a HIGH logic level, the chip will stop operating.

• Pin 12 (CO)

The carry-out pin remains HIGH as long as the counting is on the first half(Q0 – Q4) and it turns LOW when the counter reaches the second half(Q5 – Q9).

Control high voltage appliances

Relay is an electromagnetic switch that turns on/off a circuit with a low power signal. Like in our case we need to drive a 220VAC load. But, our circuit can’t do that on its own so we added a relay to switch the AC on/off by the CD4017 output signal.

It’s very important to add a diode to protect your controller or your IC from any back-EMF.

We a re using a 5VDC relay which has 5 pins as shown in the figure below.

The “COM” is the contact that closes or opens the load circuit based on the coil state, is it energized or not?

The “Normally Closed” (NC)” is the pin that is closed by default when there is no current flowing through the coil, it will get disconnected from the COM pin only when current flows through the coil. “Normally Open” (NO) is the pin that is opened by default when there’s no current flowing through the coil, it will get connected with the COM pin only when current flows through the coil.

Schematic

This circuit works on 12V, not 9V.

PCB Manufacturing

I designed this circuit using Autodesk Eagle software. all the PCB files are open-source you can access it from the following link. Because we love open source.

You can order your own PCB From PCBWay company these guys have a very good reputation in this field and they ship to more than 170 countries around the world with reasonable prices. all you have to do is to open the project PCB files link and press “Add to cart”. That’s it!

Final

I will assume that you built it and you are happy now. CONGRATS FAM! in this tutorial we learned how does the CD4017 decade decoder IC work, also we learned how to use the UA741 op-amp as a comparator, and how to drive an AC voltage load using a simple relay. Lastly, we build a hand-clap AC control switch which is dope!

The post Custom-Made Handclap AC Switch Control Board appeared first on Make Some Stuff.