Difficulty:	Easy
Steps:	3
Time Required:	30mins – 1hr

Step 1 _{^{Prepare the base Aluminum extrusions}}

Get two 2040 Aluminum profiles. the length of each profile is 640mm. insert the four slide-in T-nuts into the top of the Aluminum extrusions as shown in the picture.

Make sure that the length of each aluminum extrusion is 640mm and the cut of the extrusion end is 90 degree with no slope or rough areas(clean cut).

It should look like that after inserting the two slide-in T-nuts.

Now, get one 2040 Aluminum profile. the length of the profile is 420mm. insert the four slide-in T-nuts into the Aluminum extrusions as shown in the picture.

The post Cairo30 3d-Printer: Building The Structure appeared first on Make Some Stuff.

Difficulty:	Easy
Steps:	10
Time Required:	30mins – 50mins

Step 1 _{^{Installing The Electronics Box Base 3D-Printed Part}}

Insert two M5 T-nuts into the 2040 aluminum profile as shown in the pictures.

Fix the electronics 3d-printed part into the base aluminum profile using two M5x10mm hex low profile screws.

Make sure that the electronics box base 3d-printed part holes are aligned with the two M5 T-nuts.

After finishing this step, the electronics box 3d-printed part is installed successfully.

Step 2 _{^{Installing The Arduino Mega}}

Install the Arduino Mega board into the electronics box base 3d-printed part and make sure that the Arduino Mega fixing screws are aligned with the electronics box base 3d-printed part fixing holes.

Fix the Arduino Mega board into the electronics box base 3d-printed part with two M3x15mm screws and two M3 nuts. Insert the two M3x15mm screws from the bottom of the electronics box base 3d-printed part then fix it with two M3 nuts as shown in the pictures.

Using two standard M3 nuts fix the Arduino Mega board on the Electronics box.

Step 3 _{^{Installing The Ramps Shield}}

After installing the Arduino Mega inside the electronics box base 3d-printed part, plug the Ramps V1.6 board over the Arduino Mega board. Make sure that the Ramps board and the Arduino board are totally aligned together as shown in the pictures.

Make sure that the Ramps board and the Arduino board are totally aligned together as shown in the pictures.

We are recommending Ramps V1.6 over V1.4 and V1.5. But any Ramps version will work without problems.

Step 4 _{^{Installing The LCD Smart Adapter Connector}}

Now, let’s plug the LCD screen smart adapter connector over the Ramps V1.6 shield. We will use it later to connect the LCD screen cables on.

Step 5  _{^{Installing The Electronics Box Fan}}

We are using a 4040 fan to keep the electronic components cool, install the 4040 fan into the electronics box top 3d-printed part using two M3x20mm screws and two M3 nuts.

Insert the 4040 fan from the bottom of the electronics box top 3d-printed part with two M3x20mm screws. Then fix the 4040 fan into the electronics box top 3d-printed part using two M3 nuts.

After assembling the fan into the electronics box top part, your electronics box 3d-printed top part should look like this.

Don’t close the electronic box now, keep the assembled electronics box top part near you untill we finish out the electronics wiring. we will wire all the electronics parts in the next step!

Step 6  _{^{Connecting the Electronics}}

Let’s connect the electronics components. Wire your electronics as shown in the reference image down below.

You may need to extend the cable wires of some components like the hotend heater, thermistor, and fans. To do that you need a soldering iron, solder and some extra wires to extend your cables.

Don’t forget to set the Vref value of your DRV8825 motor drivers. You will need a multimeter to measure the Vref value and a small screwdriver to adjust the motor driver potentiometer.

Step 7  _{^{Closing The Electronics Box}}

Plug the electronics box 3d-printed top part over the electronics box base 3d-printed part. you can use two M3x20mm screws to secure it to the base part.

Step 8  _{^{Installing The Power Supply Holder}}

Insert four M5 T-nuts into the base aluminum profile as shown in the pictures.

Insert the power supply 3d-printed holder part into the base aluminum profile. Align the four holes of the power supply 3d-printed holder part with the previously inserted four M5 T-nuts. Then use two M5x10mm screws to fix the holder from the front face.

Make sure that the two M5x10mm screws are perfectly aligned with the M5 T-nuts.

Secure the power supply 3d-printed holder part with two M5x10mm screws as shown in the pictures.

Make sure that the two M5x10mm screws are perfectly aligned with the M5 T-nuts.

Step 9  _{^{Installing The Power Supply}}

Insert the 12V 30A power supply into its 3d-printed holder. And fix it with one M4x15mm screw.

Secure the power supply with the second M4x15mm screws

Step 10  _{^{Installing The Power Supply Switch Cover}}

Download the power supply switch holder part from here. And use two M4x15mm screws to secure it to the power supply.

The post Cairo Mini 3d-Printer: Electronics appeared first on Make Some Stuff.

Difficulty:	Easy
Steps:	2
Time Required:	20mins – 30mins

Step 1 ^{_{Installing The Flexible Coupler}}

On one side of the flexible coupler is a 5mm hole and on the opposite side is an 8mm hole. Insert the flexible coupler from the 5mm hole side to the stepper motor shaft as seen in the pictures down below. Slightly tighten the first set screw. Turn the shaft and slightly tighten the second set screw.

There is a flat part on the motor shaft, rotate it similarly to the first picture. See the direction of the arrows. One of the screws must be facing directly against the pad (flat part) on the shaft. Slightly tighten the first screw. Turn the shaft and slightly tighten the second screw.

Step 2 ^{_{Installing The T8 Lead Screw}}

Insert the T8 lead screw into the flexible coupler from the 8mm hole side. Gently tighten the two set screws of the flexible coupler.

Step 3 ^{_{Assemble The X-axis And The Z-axis Together}}

Place the X-axis four V-wheels on the Z-axis Aluminium profile and insert the brass nut into the T8 lead screw. Gently rotate the T8 lead screw so the brass nut gets fully inserted. 

Make sure that all the four solid v-wheels are touching the aluminium profile and moving freely without too much tension.

Also, make sure that the T8 lead screw is inserted into the brass nut and you can rotate it with your hand easily.

Step 4 ^_Checkpoint

You should now have an assembled X and Z axis together.

The post Cairo Mini 3d-Printer: Assembling The Z-Axis appeared first on Make Some Stuff.

Difficulty:	Easy
Steps:	10
Time Required:	1hr – 2hrs

Step 1 _{^{Installing the aluminium profile}}

Insert three M5 T-nuts into the aluminium profile.

Gently screw the M5x12mm screws onto the T-nuts from the back of the acrylic part. Repeat this procedure with the other two screws.

Now, your x-axis acrylic part and the 2020 aluminium profile are installed.

Step 2 _{^{Installing The X-axis Motor}}

Place the X-axis stepper motor to the X-axis acrylic part and make sure the cable connector of the motor is oriented in the same way as in the picture. Then, secure the motor with four M3x16mm screws.

Step 3  _{^{Installing The GT2 Pulley On The X-axis Motor}}

Place the X-axis stepper motor to the X-axis acrylic part and make sure the cable connector of the motor is oriented in the same way as in the picture. Then, secure the motor with four M3x16mm screws.

Ensure you have the correct orientation of the pulley on the shaft. It can be placed both ways, but only one is correct.

Make sure to make the pulley perfectly aligned with the aluminium profile groove as seen on the last picture.

Step 4  _{^{Installing The V-wheels}}

Insert four M5x45mm screws from the front face of the acrylic part.

Insert two eccentric nuts onto the top and bottom right screws. After the eccentric nuts, insert two
M5x3mm spacers. Then, insert the v-wheels and other M5x9mm spacers after the wheels.

Regarding the two top and bottom left screws, insert two M5x9mm spacers then the V-wheels, then another M5x9mm spacers.

Step 5   _{^{Installing The Second X-axis Part}}

Align the four holes of the X-axis 3d-printed part with the four screws and gently push the X-axis 3d-printed part into it. Secure it using four M5 nuts.

Make sure that all M5 nuts are inserted all the way down into their places. You may need to apply some force on the nuts to fully insert them inside the 3d-printed part. Use the Allen key to push the nuts fully inside.

Place the T8 lead screw brass nut from the bottom of the X-axis 3d-printed part and make sure that the holes are perfectly aligned together.

Secure the T8 lead screw brass nut using four M3x16mm screws and four M3 nuts.

You can use needle-nose pliers or a tweezer to keep the nuts in place.

Step 6   _{^{Assembling The Extruder}}

Install the small bearing to the extruder arm using the screw shown in the pictures.

You don’t need any nuts for installing the bearing.

Install the extruder seat to the 3d printed part and the stepper motor. Insert the M3x16mm screw from the top of the extruder seat into the stepper motor passing through the 3d printed part.

Install the small screw to the extruder seat as shown in the pictures. And make sure to not fully tighten it, leave a 2-3mm gap between the screw and the extruder seat.

Install the gear on the stepper motor shaft. Unscrew the gear two set screws a little bit and insert the gear into the stepper motor shaft.

Here is a flat part on the motor shaft, rotate it similarly to the first picture. See the direction of the arrows. One of the screws must be facing directly against the pad (flat part) on the shaft. Slightly tighten the first screw. Turn the shaft and slightly tighten the second screw.

Ensure you have the correct orientation of the pulley on the shaft. It can be placed both ways, but only one is correct.

Don’t press the pinion against the motor. Leave a 1.5 millimeters gap between both parts. You can use the 1.5mm Allen key to set the gap.

Place the tension spring and the screw as shown in the pictures.

Insert The second spring tension screw as shown in the pictures.

install the extruder arm on the 3d printed part using the M3x25mm screw.

Step 7   _{^{Assembling The Endstop}}

Insert two M3 standard nuts inside the endstop holder part.

Here is a flat part on the motor shaft, rotate it similarly to the first picture. See the direction of the arrows. One of the screws must be facing directly against the pad (flat part) on the shaft. Slightly tighten the first screw. Turn the shaft and slightly tighten the second screw.

Insert the two M5 T-nuts into the 2020 aluminium profile as shown in the pictures. Keep a few millimeters between them. 

Keep a few millimeters between them.

Install the endstop 3d-printed holder part on the aluminium profile using two M5x10mm screws. Make sure that the two M5 t-nuts are correctly aligned with the two M5x10mm screws.

Install the endstop on the 3d-printed holder part using two M3x10mm screws. Make sure of the endstop cable orientation as shown on the images.

The distance between the 2020 aluminium profile left end and the left end of the endstop holder part should be 39mm.

Step 8   _{^{Installing the hotend unit}}

Simply, you need to gently slide the hotend unit into the 2020 aluminium profile. 

You should now have an assembly like that. we still need to install the idler pulley on the right end of the Aluminium profile. see next steps to continue.

The eccentric nuts allow you to adjust the tension of your V-wheels. The general is to tension the wheel against the rail enough to initiate contact, but not too much to cause them to crush.

When you rotat these eccentric nuts they will move the wheels closer to the aluminium profile or away from the aluminium profile. don’t rotate the eccentric nuts all the way because that will cause the wheels to deform. Just rotate the eccentric nuts until you get rid of any wobble.

Step 9   _{^{Installing Idler Pulley}}

Firstly, Insert two M5 t-nuts into the aluminium profile as shown in the pictures. Then install the pulley holder acrylic plate on the aluminium profile using two M5x12mm screws.

The distance between the acrylic part and the right end of the aluminium profile should be 20mm. you can adjust this distance later to tighten or untighten the X-axis belt.

Fix the M5x25mm screws on the pulley holder plate using one standard 5mm nut.

Insert the M5x2mm spacer and the idler pulley into the M5x25mm screw, then tighten the M5 acorn nut.

Make sure to not fully tighten the M5 acorn nut. You need to leave it a little bit loose to allow the pulley holder to rotate freely.

Step 10   _^Checkpoint

You should now have a fully assembled X-axis. The next step is to assemble the X-axis with the Z-axis. Check out the Z-axis assembly guide page for instructions.

The post Cairo Mini 3d-Printer: Building The X-Axis appeared first on Make Some Stuff.

Difficulty:	Easy
Steps:	10
Time Required:	1hr – 2hrs

Step 1 ^{_{Assembling the V-wheels Set}}

Insert one solid V-wheel, one M5x6mm spacer, one M5 eccentric nut into the M5x30mm screw as shown in the pictures. Repeat that step one more time to assemble a second set.

Now, insert one solid V-wheel, one M5x12mm standard spacer into the M5x30mm screw as shown in the pictures. Repeat that step one more time to assemble a second set.

We will use these four sets to install the heated-bed seat on the y-axis aluminum profile.

Step 2 ^{_{Installing The V-wheel Sets to the Heated Bed Acrylic Seat}}

Insert the two sets that contain the Eccentric nuts into the heated bed acrylic seat as shown in the picture. and fix them on the heated bed acrylic seat using two M5 standard nuts.

Then insert the other two sets that contain the M5x12mm spacers into the heated bed acrylic seat as shown in the picture. Fix them on the acrylic heated bed seat using two M5 standard nuts.

Make sure that the two sets that have eccentric nuts are installed together on one side either the right or left side of the heated-bed seat. It does not matter. The eccentric nuts allow you to adjust the tension of your V-wheels. The general is to tension the wheel against the rail enough to initiate contact, but not too much to cause them to crush.

Step 3  ^{_{Installing the y-axis heated-bed seat}}

Gently slide the 20x20xm heated-bed acrylic seat to the y-axis aluminum profile.

You should now be able to slide the heated bed acrylic seat back and forth smoothly on the Y-axis aluminium profile. If you feel that there is any sort of a wobble on the bed or you feel that the grip between the solid V-wheels and the Y-axis aluminium profile is lose. you can rotate the two eccentric nuts of the solid v-wheels to adjust the grip between the solid v-wheels and the Y-axis aluminum profile until you get rid of any kind of wobble.

When you rotat these eccentric nuts they will move the wheels closer to the aluminium profile or away from the aluminium profile. don’t rotate the eccentric nuts all the way because that will cause the wheels to deform. Just rotate the eccentric nuts until you get rid of any wobble.

Step 4  ^{_{Installing the y-axis heated-bed seat}}

First, you need to insert four t-nuts into the y-axis aluminium profile front face as shown in the pictures.

Then, gently slide the idler pulley 3d-printed holder part into the aluminium profile until the four holes of the idler pulley 3d-printed holder part meet the four t-nuts. Make sure that they are all aligned.

Fix the idler pulley 3d-printed holder part with four M5x12mm screws.

Step 5  ^{_{Installing the y-axis idler pulley}}

Install the M5x55mm hex screw along with two M5x16mm spacers and the idler pulley. You can refer to the images to see the proper order of this set assembly.

Use one M5 acorn nut to fix the M5x55mm in place

Now, you have an assembled y-axis idler pulley set.

Step 5  ^{_{Assembling the Y-axis motor acrylic plate}}

Insert two T-nuts into the aluminium profile back side as shown in the pictures.

Secure the Y-axis stepper motor plate on the aluminium profile using two M5x12mm hex screws.

Step 6  ^{_{Assembling the Y-axis ideller pulley}}

Install the M5x35mm hex screw along with one M5x16mm spacer, the idler pulley, and one M5 acorn nut. Refer to the pictures to see the proper arrangement.

make sure to not fully tighten the M5 acorn nut. You need to leave it a little bit loose to allow the pulley holder to rotate freely.

Step 7  ^{_{Assembling the Y-axis stepper motor}}

install the Y-axis stepper motor on the Y-axis acrylic part and make sure the cable connector of the motor is oriented to the inside of the machine. Then, secure the motor with four M3x12mm screws.

There is a flat part on the stepper motor shaft, rotate it similarly to the first picture. See the direction of the arrows.

One of the GT2 pulley screws must be facing directly against the pad (flat part) on the motor shaft. Slightly tighten the GT2 pulley first screw. Turn the shaft and slightly tighten the second screw.

Ensure you have the correct orientation of the pulley on the shaft. It can be placed both ways, but only one is correct.

Make sure to make the pulley perfectly aligned with the aluminium profile groove as seen on the last picture.

Step 8  ^{_{Assembling the Y-axis end-stop holder}}

Insert two T-nuts into the aluminium profile back side as shown in the pictures.

Secure the end-stop 3d-printed holder part on the Y-axis aluminium profile using two M5x10mm hex screws.

Step 9  ^{_{Assembling the Y-axis end-stop}}

Insert two M3 standard nuts inside the end-stop holder part.

Always make sure that all M3 nuts are inserted all the way down into the holes. You may need to apply some force on the nuts to fully insert them inside the 3d-printed part. Use the Allen key to push the nuts fully inside.

Place the mechanical endstop on the top of the 3d-printed part with the same orientation shown in the pictures. Then secure the endstop on the 3d-printed part using two M3x10mm screws.

Make sure that the mechanical end-stop switch is perfectly aligned with the acrylic Heated bed seat

Step 10  ^_Checkpoint

Now, you should have a fully assembled Y-axis.

The post Cairo Mini 3d-Printer: Building The Y-Axis appeared first on Make Some Stuff.

Difficulty:	Easy
Steps:	3
Time Required:	30mins – 1hr

Step 1 _{^{Connecting Base and Y profiles}}

Insert the two M5 T-nuts into the Y-axis aluminum profile.

Place the Y-axis Aluminium profile on top of the base Aluminium profile maintaining the shown distance.

This is an important step as other steps will rely on the accuracy of this assembly.

Then insert two 40mm hex screws and gently screw them.

Then insert two 40mm hex screws and gently screw them.

As you have noticed, there are two 5mm drills in the base Aluminium profile. We used these two drills to connect the base Aluminium profile with the Y-axis Aluminium profile.

Step 2 _{^{Assembling The Z-axis Extrusion}}

Place the Z-axis Aluminium profile vertically on the base Aluminium profile.

In the base Aluminium profile, there are two M5 threaded drills. Gently screw the two M5x60mm screws into it.

As you have noticed, there are two 5mm drills in the base Aluminium profile. We used these two drills to connect the base Aluminium profile with the Z-axis Aluminium profile.

You now assembled the main Aluminium profile structure.

Step 3 _{^{Assembling The Z-axis Stepper Motor}}

Insert Two M5 T-nuts into the Z-axis Aluminium profile from the top face of the profile.

Install the Z-axis stepper motor holder on the bottom end of the Z-axis Aluminium profile using two M5x12mm screws. Make sure that the stepper motor holder holes are aligned with the two M5 T-nuts.

Install the Z-axis stepper motor on the motor holder 3d-printed part using two M3x20mm screws.

Make sure that the stepper motor cable connector is oriented to the outside of the machine as shown in the pictures.

Step 4 _^Checkpoint

You now have assembled the main Aluminium profile structure with the Z-axis stepper motor. Congratulations!

The post Cairo Mini 3d-Printer: Building The Structure appeared first on Make Some Stuff.

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.

For someone who loves to shoot some random hobbyist videos, it’s somehow expensive to buy a motorized camera slider. So, I built my own. In this tutorial, we will go through each step to build your own Bluetooth-controlled motorized camera slider.

Hardware Components

Used Software

Project Overview

Today we will build a motorized camera slider that we can control it wirelessly over Bluetooth from a custom-made android mobile app. I used the “MIT App inventor” tool to make the app which gives us the ability to control a lot of stuff like the slider movement speed, traveling distance, acceleration/deceleration rate and a lot more. The mobile app is very robust, inside the app you can set your camera slider length which you are using. which means, you are free to build your actual camera slider with any length up to 10 meters without worrying about the app.

We used a NEMA17 stepper motor as an actuator so we can control how many steps do we need the camera slider to move. To control a stepper motor using the Arduino board, we need a translator that takes commands from the Arduino board and translate it to the language that the stepper motor understands. Here comes the A4988 Pololu stepper motor driver role, which gives us five different microstep resolutions (down to 1/16 step) to achieve the maximum moving accuracy and movement smoothness.

This project Designed with makeability in a fablab/makerspace/hackerspace in mind.

CAD And 3d Modeling

We used Fusion360 to design the camera slider, we chose to use very well-known, easy-to-find mechanical components that you can buy easily from almost any online or offline store no matter where you live.

We are using Openbuilds hardware to build the mechanical structure, the V-slot 2040 linear rail as a guide for the camera to move on. Two pulleys, one on the stepper motor shaft. And the other one, on an 8mm linear rail shaft on the opposite side of the slider with an open timing belt between them to convert from the stepper motor rotary motion to linear motion.

The 8mm linear rail shaft is installed between two Self-aligning Pillow Flange Block Bearings that are installed on the top and bottom plate by four M5 screws.

We are using four Delrin V-Slot solid wheels they ride down in the V-groove of the V-Slot rail to make the camera movement extremely smooth. The middle of the camera plate has a 1/4 inch diameter hole for a standard tripod screw so you can mount your camera easily.

Lastly, an enclosure for the electronics, All the camera slider parts are fixed together by m3*16mm screws and nuts.

Digital Fabrication (3d Printing)

All of the camera slider body is 3D-printed with 0.2 layer height, 20% infill, except the Camera slider left and right leg, which are printed with 0.2 layer height, 50% infill.

You can download the STL files from this link.

V-Wheel Kit Assembly

The assembly process is very easy man, come on! In the first step, we need to assemble the four Solid V-Wheels. The solid V-wheel kit comes with a rubber wheel, two bearings, two percision shims, and a lock nut.

Insert the bearing from one side of the rubber wheel and flip the wheel around, then insert one precision shim inside the rubber wheel, lastly insert the second bearing from the second face side.

Camera Slider Mechanical Assembly

First, We need to assemble the camera plate and the four solid V-Wheels. using the 9mm aluminum spacer, the precision shim, and the lock nut.

We are going to repeat the previous step with the other three wheels. in the two right wheels we’re going to use the 9mm spacer. And the other two left wheels we’re going to use the eccentric spacer with a 3mm spacer instead of the 9mm spacer.

Now, insert the camera holder plate in the V-slot profile. If you found that the plate is loose and wiggling, you can tighten the Eccentric nut until you get a solid plate.

Let’s insert two drop-in tee nuts in each end of the V-slot profile. we need to connect the V-slot profile with the right and left legs of the camera slider.

Get the two camera slider legs and push them into the V-slot profile.

bring four M5X10mm screws, and fix the two legs with the V-slot profile.

We need to install the NEMA 17 stepper motor on its plate. then, using four M3X16mm screws we are gonna fix the motor in place.

On the left leg, insert two nuts inside the left leg top nuts place.

Bring the NEMA 17 motor plate ad fix it on the top of the left leg. and, using two M3X16mm screws we are gonna fix the plate on the left leg.

To be able to convert the stepper motor rotational movement into linear movement, we need to install a GT2 Bore 5mm pulley on the motor shaft. and using the Allen key, tighten the pulley set screw to keep it in place.

Let’s go to the camera slider right leg, insert four M3 nuts in the leg nuts place.

Then, put the right leg bearings two plates on the top of the camera slider right leg.

Using four M3X16mm screws, fix the two plates on the camera slider right leg to keep them in place.

Bring one of the 8mm flange block bearings and install it on the top right leg plate. using two M5X20mm screws and two M5 nuts.

We need to repeat the previous step with the second 8mm flange bearing block to fix it on the camera slider right leg bottom plate.

Insert the 8mm linear rail shaft in the 8mm flange bearing block from it’s bottom side, ad push it to the top. Then, insert the 8mm bore pulley into the linear rail shaft and fix it by tightening the pulley’s set screw.

Checkpoint, Now we assembled all the camera slider mechanism except one thing. the timing belt. Let’s do it.

rotate the 6mm timing belt on the NEMA17 motor 5mm bore pulley. Also, on the right leg 8mm bore pulley. Lastly, tighten the belt with the camera plate.

It’s time to assemble the control board. insert the Cairo Camera Slider Arduino shield on the top of the Arduino board.

Insert the Arduino board and the Cairo Camera Slider shield inside the control board enclosure.

insert two M3 nuts inside the left leg nuts place.

install the control board enclosure to the Cairo Camera Slider left leg with M3X16mm screws.

close the enclosure box top face with two M3 screws and nuts, and that’s it!

Stepper Motor Test Control

After assembling all the parts together, We need to test it to make sure that everything is installed in its place correctly. Now, we need to connect the stepper motor with the Arduino board through the A4988 stepper motor driver and write some code to run that thing.

A4988 stepper motor driver

To control any stepper motor using the Arduino board or any microcontroller, you will need a stepper motor driver which works as a translator, takes commands from the Arduino board and translate it to the language that the motor understands.

there are a lot of stepper motor drivers out there but we will use the A4988 driver. This driver allows us to control one bipolar motor at up to 2A output current per coil, it’s very simple to interface with the Arduino board you only need two digital pins to fully control your motor step and direction, which allows you to control the maximum current output easily with an onboard potentiometer, and gives you a micro-step resolution down to 1/16 micro-step.

VMOT, GND: It’s the power connection pins for the stepper motor itself, it can be 8V-35V. In our case, we are connecting a 12V 3A power source on those pins with a 100uf decoupling capacitor to protect the A4998 board from any power spikes.

2B, 2A: the output pins for the stepper motor first coil which can deliver up to 2A.

1A, 1B: the output pins for the stepper motor second coil which can deliver up to 2A as well.

VDD, GND: Used for driving the internal logic circuitry, it can be 3V to 5.5V. It’s totally isolated from the VMOT pin.

EN: Stands for “Enable” it’s an active LOW(0V) input pin, which means when this pin pulled LOW(0V) the A4988 chip is enabled. And when pulled HIGH(5V) the A4988 chip is disabled. By default, this pin is pulled LOW(0V) . So, the chip is always enabled unless you pull it HIGH(5V).

MS1, MS2, MS3: Through these pins, you can select your motor microstepping resolution(step size). The A4988 gives you five different microstep resolutions (full step, half step, quarter step, Eighth step, Sixteenth step). By applying appropriate logic levels to these three pins we can set the motors to one of the five step resolutions.

By default, the MS1, MS2, MS3 pins have internal pull-down resistors. So leaving these three microstep selection pins disconnected results in full-step mode.

RST, SLP: The “Reset” pin is an active LOW(0V) input pin, which means when it pulled LOW(0V), all the step inputs are ignored it also resets the translator itself until you pull it HIGH(5V). The “Sleep” pin also an active LOW pin, pulling it LOW, puts the driver in the sleep mode minimizing the power consumption. By default, the “Sleep” pin is pulled HIGH(5V).

STP, DIR: The “Step” pin is responsible for controlling the number of steps that the motor is rotating, each pulse to the “Step” pin corresponds for one microstep in the direction selected by the “Direction” pin, the faster the pulses, the faster the motor will rotate. By applying logic value HIGH(5V) on the “Direction” pin it makes the motor rotate clockwise, by applying LOW(0V) it makes the motor rotate counterclockwise(it may differs from one to another according to your motor wiring with the driver).

NEMA17 Stepper Motor

Stepper motors are DC motors that can rotate in precise increments, they are used in many applications like 3D printers to align the printhead and CNC machines to control the movement of the cutting tool and this is because they are very accurate and precise.

Unlike DC motors, stepper motors are controlled by applying DC electrical pulses to their internal coils. Each pulse makes the shaft advance by one step or a fraction of step which is called “Microstepping”. So, you can control precisely how many steps or even fraction steps you want the motor shaft to move. Another great advantage of using stepper motors is that it can move very precisely and accurately at very slow speeds without even stalling.

The type of motor we are using in this project is the NEMA 17 Bipolar stepper motor. The bipolar stepper motor has two internal coils and it usually has four wires, two wires per coil. unlike the Bipolar stepper motor which has five wires. The “Step Angle” of the motor is 1.8° which indicates how much the shaft advances in each full step, the motor works on 9V but if you want to get the maximum power of it use a 12V power source.

So, by connecting the stepper motor with the A4988 stepper motor driver, we can control how many steps we need the motor to move and in what direction. Also, we can set the “microstep” mode is it full step, half step, quarter step, ….. Let’s take a look at the wiring diagram.

Wiring Diagram

As we stated before, we need to make a small check to make sure that everything we assembled before is right in its place and moving properly. Now, we will wire all the hardware together, the NEMA 17 stepper motor with the A4988 stepper motor driver to the brain, the Arduino board. And using a 12V 3A Lithium-Ion battery to feed the motors with the power it needs.

Arduino Code

AccelStepper Library Installation

The Installation is pretty simple, we need to open Arduino IDE. From the “Sketch” menu select Include Library –> Manage Libraries…

A new window should appear, search for “AccelStepper” and install the library made by “Mike McCauley”. Easy right!

After installing the AccelStepper library, you should see it in the examples menu.

I wanna make sure that the AccelStepper library is installed correctly and my stepper motor connection with the A4988 motor driver is right and my power management is fine. So, let’s write some lines of code to run our stepper motor forward and backward.

// Bounce stepper test program
// Make a single stepper bounce from one limit to another
// Copyright (C) 2020 makesomestuff.org

#include <AccelStepper.h>

#define stepPin 2
#define dirPin 3

// Define a stepper and the pins it will use
AccelStepper stepper(AccelStepper::DRIVER, stepPin, dirPin);       //create an object. the pin "2" is the step pin, "3" is the direction pin.

void setup()
{  
  // Change these to suit your stepper if you want
  stepper.setMaxSpeed(100);
  stepper.setAcceleration(20);
  stepper.moveTo(500);
}

void loop()
{
    // If at the end of travel go to the other end
    if (stepper.distanceToGo() == 0)
      stepper.moveTo(-stepper.currentPosition());

    stepper.run();
}

The code logic is pretty straightforward, we initialized an object from the AccelStepper library, we defined two constants (stepPin, dirPin) that two digital pins is used by the A4988 stepper motor driver to control the movement of the motor itself.

#include <AccelStepper.h>

#define stepPin 2
#define dirPin 3

// Define a stepper and the pins it will use
AccelStepper stepper(AccelStepper::DRIVER, stepPin, dirPin);       //create an object. the pin "2" is the step pin, "3" is the direction pin.

Inside the void setup function, we set the Max. speed of the stepper motor to 100 steps/sec. Also, we set the acceleration/deceleration rate to 20 steps/sec. lastly, we used the moveTo() function to tell the motor to move 500 steps.

void setup()
{  
  // Change these to suit your stepper if you want
  stepper.setMaxSpeed(100);
  stepper.setAcceleration(20);
  stepper.moveTo(500);
}

Inside the void loop function, we are checking if the motor reached it’s position or not. If it reached the position, it will bounce back. and if it didn’t reach it’s position yet, it will keep running.

void loop()
{
    // If at the end of travel go to the other end
    if (stepper.distanceToGo() == 0)
      stepper.moveTo(-stepper.currentPosition());

    stepper.run();
}

Camera Slider Full Wireless Control

We have done great things so far. Let’s continue! The next step after testing everything is to work on the mobile app that we will use to control the camera slider movement and send the orders to it. Also, we need to work on the Arduino code that will receive the data from the mobile app and according to these data, it will take some actions like moving the motor, changing speed, acceleration, and so on…

Building The Mobile App

To build the mobile app, I used the MIT App inventor tool that allows you to create mobile apps that run on any Android smartphone. The tool is pretty simple since you only drag and drop some pre-made code blocks to build the logic of your program, also you use some premade blocks to build the app user interface. You can access the source of the mobile app from the link down below. Feel free to edit and share, it’s open-source.

The image down below, a brief explanation for each button function and how it works.

That mobile app will communicate with the Cairo camera slider wirelessly over Bluetooth communication. So, the next step is to connect a Bluetooth module to the last circuit we built before and upload some lines of code to the Arduino board to be able to establish the communication between the mobile app and the Cairo camera slider.

Wiring Diagram

It’s time to connect all things together, previously we connected the stepper motor, stepper motor driver, Arduino UNO, and the battery together and tested the circuit and it worked fine. Now, and after building the mobile app, we need to connect the HC-05 Bluetooth module to our circuit.

To make it wireless we will use the HC-05 Bluetooth module which has wide use, it can be set as slave or master as well (unlike the HC-06 module which can work only as a slave) which means that you can make a Bluetooth connection between two different Arduino boards. the HC-05 Bluetooth module is an SPP (Serial Port Protocol) module, which means that it communicates with the Arduino board via Serial communication. You only need to connect the Tx and the Rx pins between the HC-05 module and the Arduino UNO board.

Schematic and PCB Fabrication

Man! I don’t like breadboarding a big circuit like this. So, I designed a super pretty Arduino UNO shield PCB board that keeps all my components in place without worrying about the jumper wires or even the connections. All you need to do is to place your component on the Arduino shield PCB, insert the HC-05 Bluetooth module, A4988 stepper motor driver, and the battery in their places. and install the shield on top of the Arduino board. that’s it!

I fabricated my PCB at PCBWay the quality was very good, in a few days the package arrived in Egypt safely. and I paid just 5$ for the fabrication which is amazing. The coolest thing was that I was able to check the order fabrication and processing status online on my account panel and track everything happening to my baby board like I was there inside the factory.

you can download the PCB design source files or even order the Cairo Camera Slider Arduino Shield PCB from the PCBWay website.

Arduino Code And Bluetooth Communication

#include <MultiStepper.h>
#include <AccelStepper.h>

#define stepPin 2
#define dirPin 3

bool homingPositionFlag = false;
int startupSetupFlag = 0;
bool delayedStart = false;

int incomingData = 0;
int movementDistance = 50;
long steps = 0;       //50cm rail by default @1/8 microstepping.
int microStepResolution = 0;    //4  or  16
long railLength = 0;
int sliderSpeed = 10;

AccelStepper stepper(AccelStepper::DRIVER, stepPin, dirPin);       //create an object. the pin "2" is the step pin, "3" is the direction pin.

void setup() {
  pinMode(stepPin, OUTPUT);
  pinMode(dirPin, OUTPUT);
  Serial.begin(9600);

  stepper.setMaxSpeed(10.00);        //The fastest motor speed that can be reliably supported is about 4000 steps per second at a clock frequency of 16 MHz on Arduino such as Uno
  stepper.setAcceleration(500.00);     //1600 (40%) (Medium Acceleration rate)

  while (startupSetupFlag < 3) {
    if (Serial.available() > 1) {
      unsigned int dataOne = Serial.read();
      unsigned int dataOne1 = Serial.read();
      unsigned int incomingData = (dataOne1 * 256) + dataOne;

      //**************************************************************Motor Homing Part**************************************************
      if (incomingData == 16) {      //left end homing position.
        stepper.setCurrentPosition(steps);
        homingPositionFlag = false;
        startupSetupFlag++;
      } else if (incomingData == 17) {    //right end homing position.
        stepper.setCurrentPosition(-(steps));
        homingPositionFlag = true;
        startupSetupFlag++;
      }
      //**************************************************************microstep resolution Part**************************************************
      if (incomingData == 18) {
        microStepResolution = 4;                   //50cm rail length @1/4 microstep resolution.
        startupSetupFlag++;
      } else if (incomingData == 19) {
        microStepResolution = 16;                  //50cm rail length @1/16 microstep resolution.
        startupSetupFlag++;
      }

      if (incomingData >= 1301 && incomingData <= 2300) {
        railLength = incomingData - 1300; //from raw data to cm.
        if (microStepResolution == 4) {
          steps = ((6100L * railLength) / 50L);
          startupSetupFlag++;
        }
        else if (microStepResolution == 16) {
          steps = ((25000L * railLength) / 50L);
          startupSetupFlag++;
        }
      }
    }
    //Serial.println(startupSetupFlag);
  }
  /*
   * *********** *********** **********For Debugging Purposes* *********** *********** **********
    Serial.print("rail length: ");
    Serial.print(railLength);
    Serial.print("    number of steps:  ");
    Serial.print(steps);
    Serial.print("    Homing position: ");
    Serial.print(stepper.currentPosition());
    Serial.print("    microstep resolution: ");
    Serial.println(microStepResolution);*/
}

void loop() {

  if (Serial.available() > 1) {

    unsigned int dataOne = Serial.read();
    unsigned int dataOne1 = Serial.read();
    unsigned int incomingData = (dataOne1 * 256) + dataOne;
    //Serial.print("raw data:     ");
    //Serial.println(incomingData);

    //**************************************************************Motor Control Part**************************************************
    if (incomingData == 1 && stepper.isRunning() == false && stepper.currentPosition() != 6050 && homingPositionFlag == true) {
      if (delayedStart == true) { //use millis to delay 15 seconds.
        delay(15000);     //wait 15 seconds.
      }
      stepper.setCurrentPosition(0);
      stepper.moveTo(steps);             //from end to end (@ 1/4 step).
      homingPositionFlag = false;

      /*Serial.print("rail length: ");
        Serial.print(railLength);
        Serial.print("    number of steps:  ");
        Serial.print(steps);
        Serial.print("    Homing position: ");
        Serial.print(stepper.currentPosition());
        Serial.print("    microstep resolution: ");
        Serial.println(microStepResolution);*/
    }

    else if (incomingData == 2 && stepper.isRunning() == false && stepper.currentPosition() != -6050 && homingPositionFlag == false) {
      if (delayedStart == true) { //use millis to delay 15 seconds.
        delay(15000);     //wait 15 seconds.
      }
      stepper.setCurrentPosition(0);
      stepper.moveTo(-(steps));             //from end to end (@ 1/4 step).
      homingPositionFlag = true;

      /*Serial.print("rail length: ");
        Serial.print(railLength);
        Serial.print("    number of steps:  ");
        Serial.print(steps);
        Serial.print("    Homing position: ");
        Serial.print(stepper.currentPosition());
        Serial.print("    microstep resolution: ");
        Serial.println(microStepResolution);*/
    }

    else if (incomingData == 3 && stepper.isRunning() == true) {
      homing();
    }

    //**************************************************************Set Max. Speed Part**************************************************
    else if (incomingData >= 5001 && incomingData <= 9000) {
      sliderSpeed = incomingData - 5000;
      stepper.setMaxSpeed(sliderSpeed);
    }

    //**************************************************************Set Delayed Start Part**************************************************
    else if (incomingData == 7) {   //delayed start (15 seconds) is checked "true"
      delayedStart = true;
    }
    else if (incomingData == 8) {   //delayed start (15 seconds) is not checked "false"
      delayedStart = false;
    }

    //**************************************************************Set movement distance Part**************************************************
    else if (incomingData >= 201 && incomingData <= 1200) {  //convertin from rail length into number of steps. (upto 10 meters)
      movementDistance = incomingData - 200; //from raw data to cm.
      if (microStepResolution == 4) {
        steps = ((6100L * movementDistance) / 50L);
      }
      else if (microStepResolution == 16) {
        steps = ((25000L * movementDistance) / 50L);
      }
      /*Serial.print("rail length:  ");
        Serial.print(movementDistance);
        Serial.print("      number of steps:  ");
        Serial.println(steps);*/
    }

    //**************************************************************Set Acceleration Part**************************************************
    else if (incomingData == 11 && stepper.isRunning() == false) {          //HIGH
      stepper.setAcceleration(3000);
    }

    else if (incomingData == 12 && stepper.isRunning() == false) {          //Medium
      stepper.setAcceleration(1000);
    }

    else if (incomingData == 13 && stepper.isRunning() == false) {          //Low
      stepper.setAcceleration(500);
    }

    else if (incomingData == 14 && stepper.isRunning() == false) {          //Very High
      stepper.setAcceleration(4000);
    }

    else if (incomingData == 15 && stepper.isRunning() == false) {          //Very Low
      stepper.setAcceleration(10);
    }
  }
  stepper.run();
}

void homing() {
  if (stepper.currentPosition() > 0) {
    homingPositionFlag = true;
  } else {
    homingPositionFlag = false;
  }
  stepper.moveTo(0);
}

Code Logic

We’re using the amazing AccelStepper Arduino library that provides an object-oriented interface for 2, 3, 4 pins stepper motors to control it’s movement precisely.

#define stepPin 2
#define dirPin 3

bool homingPositionFlag = false;
int startupSetupFlag = 0;
bool delayedStart = false;

int incomingData = 0;
int movementDistance = 50;
long steps = 0;       //50cm rail by default @1/8 microstepping.
int microStepResolution = 0;    //4  or  16
long railLength = 0;
int sliderSpeed = 10;

AccelStepper stepper(AccelStepper::DRIVER, stepPin, dirPin);       //create an object. the pin "2" is the step pin, "3" is the direction pin.

when you open the mobile app and get connected to the Cairo camera slider it will ask you about the micro-stepping mode that you set the A4988 motor driver to work at. it’s very important to choose the correct micro-stepping mode. The Cairo camera slider only supports the 1/4 and 1/16 micro-step resolution. If you chose a wrong micro-step mode it will affect the distance calculations causing the camera carriage to hit the slider limits. So, be careful!

      //**************************************************************microstep resolution Part**************************************************
      if (incomingData == 18) {
        microStepResolution = 4;                   //50cm rail length @1/4 microstep resolution.
        startupSetupFlag++;
      } else if (incomingData == 19) {
        microStepResolution = 16;                  //50cm rail length @1/16 microstep resolution.
        startupSetupFlag++;
      }

It sets the camera slider homing if it’s left or right side homing. the homing position, once you click on right or left side homing a specific piece of data will get sent from the mobile app to the Arduino board according to the homing position that you have chosen.

void setup() {
  pinMode(stepPin, OUTPUT);
  pinMode(dirPin, OUTPUT);
  Serial.begin(9600);

  stepper.setMaxSpeed(10.00);        //The fastest motor speed that can be reliably supported is about 4000 steps per second at a clock frequency of 16 MHz on Arduino such as Uno
  stepper.setAcceleration(500.00);     //1600 (40%) (Medium Acceleration rate)

  while (startupSetupFlag < 3) {
    if (Serial.available() > 1) {
      unsigned int dataOne = Serial.read();
      unsigned int dataOne1 = Serial.read();
      unsigned int incomingData = (dataOne1 * 256) + dataOne;

      //**************************************************************Motor Homing Part**************************************************
      if (incomingData == 16) {      //left end homing position.
        stepper.setCurrentPosition(steps);
        homingPositionFlag = false;
        startupSetupFlag++;
      } else if (incomingData == 17) {    //right end homing position.
        stepper.setCurrentPosition(-(steps));
        homingPositionFlag = true;
        startupSetupFlag++;
      }

now it sets how many steps should the stepper motor moves without hitting the camera carriage with the camera slider right or left legs. it reads and saves the rail length according to the value that the user enters in the mobile app. So, depending on the micro-step resolution that the user selected before, and the rail length I can calculate the number of steps that the motor should rotate to reach the limits of the slider rail without hitting the right or left legs.

if (incomingData >= 1301 && incomingData <= 2300) {
        railLength = incomingData - 1300; //from raw data to cm.
        if (microStepResolution == 4) {
          steps = ((6100L * railLength) / 50L);
          startupSetupFlag++;
        }
        else if (microStepResolution == 16) {
          steps = ((25000L * railLength) / 50L);
          startupSetupFlag++;
        }
      }
    }
    //Serial.println(startupSetupFlag);
  }

inside the loop function, it reads the mobile app incoming data and according to these data it takes different actions, like moving the stepper motor clockwise, moving anti-clockwise, stop and return back to the starting point, and changing the travelling speed, so on…

void loop() {

  if (Serial.available() > 1) {

    unsigned int dataOne = Serial.read();
    unsigned int dataOne1 = Serial.read();
    unsigned int incomingData = (dataOne1 * 256) + dataOne;
    //Serial.print("raw data:     ");
    //Serial.println(incomingData);

    //**************************************************************Motor Control Part**************************************************
    if (incomingData == 1 && stepper.isRunning() == false && stepper.currentPosition() != 6050 && homingPositionFlag == true) {
      if (delayedStart == true) { //use millis to delay 15 seconds.
        delay(15000);     //wait 15 seconds.
      }
      stepper.setCurrentPosition(0);
      stepper.moveTo(steps);             //from end to end (@ 1/4 step).
      homingPositionFlag = false;

      /*Serial.print("rail length: ");
        Serial.print(railLength);
        Serial.print("    number of steps:  ");
        Serial.print(steps);
        Serial.print("    Homing position: ");
        Serial.print(stepper.currentPosition());
        Serial.print("    microstep resolution: ");
        Serial.println(microStepResolution);*/
    }

    else if (incomingData == 2 && stepper.isRunning() == false && stepper.currentPosition() != -6050 && homingPositionFlag == false) {
      if (delayedStart == true) { //use millis to delay 15 seconds.
        delay(15000);     //wait 15 seconds.
      }
      stepper.setCurrentPosition(0);
      stepper.moveTo(-(steps));             //from end to end (@ 1/4 step).
      homingPositionFlag = true;

      /*Serial.print("rail length: ");
        Serial.print(railLength);
        Serial.print("    number of steps:  ");
        Serial.print(steps);
        Serial.print("    Homing position: ");
        Serial.print(stepper.currentPosition());
        Serial.print("    microstep resolution: ");
        Serial.println(microStepResolution);*/
    }

    else if (incomingData == 3 && stepper.isRunning() == true) {
      homing();
    }

    //**************************************************************Set Max. Speed Part**************************************************
    else if (incomingData >= 5001 && incomingData <= 9000) {
      sliderSpeed = incomingData - 5000;
      stepper.setMaxSpeed(sliderSpeed);
    }

    //**************************************************************Set Delayed Start Part**************************************************
    else if (incomingData == 7) {   //delayed start (15 seconds) is checked "true"
      delayedStart = true;
    }
    else if (incomingData == 8) {   //delayed start (15 seconds) is not checked "false"
      delayedStart = false;
    }

    //**************************************************************Set movement distance Part**************************************************
    else if (incomingData >= 201 && incomingData <= 1200) {  //convertin from rail length into number of steps. (upto 10 meters)
      movementDistance = incomingData - 200; //from raw data to cm.
      if (microStepResolution == 4) {
        steps = ((6100L * movementDistance) / 50L);
      }
      else if (microStepResolution == 16) {
        steps = ((25000L * movementDistance) / 50L);
      }
      /*Serial.print("rail length:  ");
        Serial.print(movementDistance);
        Serial.print("      number of steps:  ");
        Serial.println(steps);*/
    }

    //**************************************************************Set Acceleration Part**************************************************
    else if (incomingData == 11 && stepper.isRunning() == false) {          //HIGH
      stepper.setAcceleration(3000);
    }

    else if (incomingData == 12 && stepper.isRunning() == false) {          //Medium
      stepper.setAcceleration(1000);
    }

    else if (incomingData == 13 && stepper.isRunning() == false) {          //Low
      stepper.setAcceleration(500);
    }

    else if (incomingData == 14 && stepper.isRunning() == false) {          //Very High
      stepper.setAcceleration(4000);
    }

    else if (incomingData == 15 && stepper.isRunning() == false) {          //Very Low
      stepper.setAcceleration(10);
    }
  }
  stepper.run();
}

void homing() {
  if (stepper.currentPosition() > 0) {
    homingPositionFlag = true;
  } else {
    homingPositionFlag = false;
  }
  stepper.moveTo(0);
}

Cairo Camera Slider User Guide & troubleshooting

After connecting the 12V power source to the Arduino UNO board that distributes power to the Cairo camera slider Arduino shield as well, turn on the Bluetooth on your mobile, search for new devices, pair with the HC-05 device, and open the mobile app then press on the “Press here to connect with Cairo camera slider” button. It will show up the menu of the paired Bluetooth devices, select the HC-05 Bluetooth device.

After connecting successfully with the Control board, the mobile app will ask you some questions to set up some parameters. The first question will ask you about the micro-step resolution of the stepper motor driver if it’s smooth(1/4 micro-step), or very smooth(1/16 micro-step). select the mode According to the micro-stepping resolution mode that you set the A4988 driver at. If you selected a wrong mode The Cairo camera slider will not work correctly.

Then, it will ask you about the aluminum rail length that you are using in your camera slider. Enter the distance in CM. in my case I’m using a 50cm rail length.

Lastly, it will ask you about the camera carriage homing position, It’s very important to place the camera carriage on one of the two rail ends, the right end or the left end. In my case, the camera carriage is on the left end. So, I selected the left end homing.

If you started the Cairo camera slider and the camera carriage is on the middle of the rail or not on one of the two rail ends it will cause the carriage to hit the limits when it moves.

After you finish the set-up process, It will show you the parameters that you have set. And once you click OK, you will be ready to play around with your lovely Cairo camera slider.

Cairo Camera Slider In-Action

The post Arduino Motorized Camera Slider 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.