3 month project based on consumer heating. This was a fun project and some is shown below Full report and Appendix.
Rendered Exploded View
Category: Electronics
Arduino – Week 4 – Robot
The final week task was to program a robot which would move by itself and avoid objects
Unfortunately this wasn’t completed due to time constraints, although most of the code for the movements was completed and fully working
The board was attached to the chassis with metal standoff – which did short the board out – however it was sorted out by replacing them with plastic ones
Two stepper motors were used to control the robot, one on each side.
There is a breakout board on top of the arduino, which allows for easy plugging in and out of the stepper motors
Coding
Below is the coding used for the control
Where the breaks are for the left, right, forward, and reverse, the position of the output pins have been changed, so that the stepper motor activated the different magnets in a different order, which changes the direciton.
The left and right have one wheel going forward and one going backwards, therefore turning on the spot, similar to how tanks rotate using their tracks
Here the robot is programmed to run the command for about 16 seconds, after which it will stop moving
/*
Stepper Motor lakelly 02/05/2019
*/
// the setup function runs once when you press reset or power the board
void setup()
{
// initialize digital coil A as an output.
pinMode(10, OUTPUT);
// initialize digital coil B as an output.
pinMode(11, OUTPUT);
// initialize digital coil C as an output.
pinMode(12, OUTPUT);
// initialize digital coil D as an output.
pinMode(13, OUTPUT);
//motor 2
pinMode(6, OUTPUT);
// initialize digital coil B as an output.
pinMode(7, OUTPUT);
// initialize digital coil C as an output.
pinMode(8, OUTPUT);
// initialize digital coil D as an output.
pinMode(9, OUTPUT);
}
int i=0;
void loop() {
while(i < 1000){
right();
i++;
}
}
void forward() //+++++++++++++++++++++++++++++++++++++++++++++++FOWARDS++++++++++++++++++++++++++++++++++++++++++++++
{
//STEP 1
digitalWrite(10, HIGH);
digitalWrite(11, LOW);
digitalWrite(12, LOW);
digitalWrite(13, HIGH);
delay(2); // delay
//STEP 2
digitalWrite(10, HIGH);
digitalWrite(11, HIGH);
digitalWrite(12, LOW);
digitalWrite(13, LOW);
delay(2); // delay
//STEP 3
digitalWrite(10, LOW);
digitalWrite(11, HIGH);
digitalWrite(12, HIGH);
digitalWrite(13, LOW);
delay(2); // delay
//STEP 4
digitalWrite(10, LOW);
digitalWrite(11, LOW);
digitalWrite(12, HIGH);
digitalWrite(13, HIGH);
delay(2); // delay
//motor2
//STEP 1
digitalWrite(6, HIGH);
digitalWrite(7, LOW);
digitalWrite(8, LOW);
digitalWrite(9, HIGH);
delay(2); // delay
//STEP 2
digitalWrite(6, HIGH);
digitalWrite(7, HIGH);
digitalWrite(8, LOW);
digitalWrite(9, LOW);
delay(2); // delay
//STEP 3
digitalWrite(6, LOW);
digitalWrite(7, HIGH);
digitalWrite(8, HIGH);
digitalWrite(9, LOW);
delay(2); // delay
//STEP 4
digitalWrite(6, LOW);
digitalWrite(7, LOW);
digitalWrite(8, HIGH);
digitalWrite(9, HIGH);
delay(2); // delay
}
void backward() //+++++++++++++++++++++++++++++++++++++++++++++++BACKWARDS++++++++++++++++++++++++++++++++++++++++++++++
{
//STEP 1
digitalWrite(10, HIGH);
digitalWrite(11, LOW);
digitalWrite(12, LOW);
digitalWrite(13, HIGH);
delay(2); // delay
//STEP 2
digitalWrite(10, HIGH);
digitalWrite(11, HIGH);
digitalWrite(12, LOW);
digitalWrite(13, LOW);
delay(2); // delay
//STEP 3
digitalWrite(10, LOW);
digitalWrite(11, HIGH);
digitalWrite(12, HIGH);
digitalWrite(13, LOW);
delay(2); // delay
//STEP 4
digitalWrite(10, LOW);
digitalWrite(11, LOW);
digitalWrite(12, HIGH);
digitalWrite(13, HIGH);
delay(2); // delay
//motor2
//STEP 1
digitalWrite(9, HIGH);
digitalWrite(8, LOW);
digitalWrite(7, LOW);
digitalWrite(6, HIGH);
delay(2); // delay
//STEP 2
digitalWrite(9, HIGH);
digitalWrite(8, HIGH);
digitalWrite(7, LOW);
digitalWrite(6, LOW);
delay(2); // delay
//STEP 3
digitalWrite(9, LOW);
digitalWrite(8, HIGH);
digitalWrite(7, HIGH);
digitalWrite(6, LOW);
delay(2); // delay
//STEP 4
digitalWrite(9, LOW);
digitalWrite(8, LOW);
digitalWrite(7, HIGH);
digitalWrite(6, HIGH);
delay(2); // delay
}
void right() //+++++++++++++++++++++++++++++++++++++++++++++++RIGHT++++++++++++++++++++++++++++++++++++++++++++++
{
//STEP 1
digitalWrite(13, HIGH);
digitalWrite(12, LOW);
digitalWrite(11, LOW);
digitalWrite(10, HIGH);
delay(2); // delay
//STEP 2
digitalWrite(13, HIGH);
digitalWrite(12, HIGH);
digitalWrite(11, LOW);
digitalWrite(10, LOW);
delay(2); // delay
//STEP 3
digitalWrite(13, LOW);
digitalWrite(12, HIGH);
digitalWrite(11, HIGH);
digitalWrite(10, LOW);
delay(2); // delay
//STEP 4
digitalWrite(13, LOW);
digitalWrite(12, LOW);
digitalWrite(11, HIGH);
digitalWrite(10, HIGH);
delay(2); // delay
//motor2
//STEP 1
digitalWrite(9, HIGH);
digitalWrite(8, LOW);
digitalWrite(7, LOW);
digitalWrite(6, HIGH);
delay(2); // delay
//STEP 2
digitalWrite(9, HIGH);
digitalWrite(8, HIGH);
digitalWrite(7, LOW);
digitalWrite(6, LOW);
delay(2); // delay
//STEP 3
digitalWrite(9, LOW);
digitalWrite(8, HIGH);
digitalWrite(7, HIGH);
digitalWrite(6, LOW);
delay(2); // delay
//STEP 4
digitalWrite(9, LOW);
digitalWrite(8, LOW);
digitalWrite(7, HIGH);
digitalWrite(6, HIGH);
delay(2); // delay
}
void left() //+++++++++++++++++++++++++++++++++++++++++++++++left++++++++++++++++++++++++++++++++++++++++++++++
{
//STEP 1
digitalWrite(10, HIGH);
digitalWrite(11, LOW);
digitalWrite(12, LOW);
digitalWrite(13, HIGH);
delay(2); // delay
//STEP 2
digitalWrite(10, HIGH);
digitalWrite(11, HIGH);
digitalWrite(12, LOW);
digitalWrite(13, LOW);
delay(2); // delay
//STEP 3
digitalWrite(10, LOW);
digitalWrite(11, HIGH);
digitalWrite(12, HIGH);
digitalWrite(13, LOW);
delay(2); // delay
//STEP 4
digitalWrite(10, LOW);
digitalWrite(11, LOW);
digitalWrite(12, HIGH);
digitalWrite(13, HIGH);
delay(2); // delay
//motor2
//STEP 1
digitalWrite(6, HIGH);
digitalWrite(7, LOW);
digitalWrite(8, LOW);
digitalWrite(9, HIGH);
delay(2); // delay
//STEP 2
digitalWrite(6, HIGH);
digitalWrite(7, HIGH);
digitalWrite(8, LOW);
digitalWrite(9, LOW);
delay(2); // delay
//STEP 3
digitalWrite(6, LOW);
digitalWrite(7, HIGH);
digitalWrite(8, HIGH);
digitalWrite(9, LOW);
delay(2); // delay
//STEP 4
digitalWrite(6, LOW);
digitalWrite(7, LOW);
digitalWrite(8, HIGH);
digitalWrite(9, HIGH);
delay(2); // delay
}
Arduino – Week 3 – Displays and Ultrasonic sensors
Arduino LCD Displays
Wire up the arduino using these following instructions
- VCC (Red) to 5V
- Ground/GND (Black) to GND
- SDA (Blue) to A4
- SCL (Yellow) to A5
The code used was downloaded adn the library installed in the specific location. Ensure that the LCD drivers are included in the same folder
#include <Wire.h> // Comes with Arduino IDE
// Get the LCD I2C Library here:
// https://bitbucket.org/fmalpartida/new-liquidcrystal/downloads
#include <LiquidCrystal_I2C.h>
// set the LCD address to 0x27 for a 20 chars 4 line display
// Set the pins on the I2C chip used for LCD connections:
// addr, en,rw,rs,d4,d5,d6,d7,bl,blpol
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE); // Set the LCD I2C address
void setup() /*----( SETUP: RUNS ONCE )----*/
{
Serial.begin(9600); // Used to type in characters
lcd.begin(20,4); // initialize the lcd for 20 chars 4 lines, turn on backlight
//-------- Write characters on the display ------------------
// NOTE: Cursor Position: Lines and Characters start at 0
// lcd.setCursor(Horizontal position,Line)
lcd.setCursor(4,0); //Start at character 4 on line 0
lcd.print("GO BACK");
lcd.setCursor(4,1); //Next start at character 6 on line 1
lcd.print("TO");
delay(1000);
lcd.setCursor(4,2);
lcd.print("THE");
delay(1000);
lcd.setCursor(4,3);
lcd.print("SHADOWS");
delay(4000);
// Wait and then tell user they can start the Serial Monitor and type in characters to
// Display. (Set Serial Monitor option to "No Line Ending")
lcd.setCursor(0,0); //Start at character 0 on line 0
lcd.clear(); //Clears the screen.
lcd.print("Start Serial Monitor");
lcd.setCursor(0,1);
lcd.print("Type characters");
lcd.setCursor(0,2);
lcd.print("to display");
}/*--(end setup )---*/
void loop() /*----( LOOP: RUNS CONSTANTLY )----*/
{
{
// when characters arrive over the serial port...
if (Serial.available()) {
// wait a bit for the entire message to arrive
delay(100);
// clear the screen
lcd.clear();
// read all the available characters
while (Serial.available() > 0) {
// display each character to the LCD
lcd.write(Serial.read());
}
}
}
}/* --(end main loop )-- */
Displaying ultrasonic measurements on LCD screen
This is the code for running the screen and the ultrasound sensor all as the same time, displaying the range in cm to the LCD screen attached to the the arduino
It is a combination of both the ultrasonic sketch downloaded from student central and the above LCD sketch. The basics behind it is setting up the ultrasonic sensor as an input and keeping the LCD as an output
After some playing around to change the refresh rate (delay) of the LCD and where the stationary text was it looked good and could accurately read the distance if it was within its range
#include <Wire.h> // Comes with Arduino IDE
// Get the LCD I2C Library here:
// https://bitbucket.org/fmalpartida/new-liquidcrystal/downloads
#include <LiquidCrystal_I2C.h>
// set the LCD address to 0x27 for a 20 chars 4 line display
// Set the pins on the I2C chip used for LCD connections:
// addr, en,rw,rs,d4,d5,d6,d7,bl,blpol
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE); // Set the LCD I2C address
#define echoPin 7 // Echo Pin
#define trigPin 8 // Trigger Pin
#define LEDPin 13 // Onboard LED
int maximumRange = 200; // Maximum range needed
int minimumRange = 0; // Minimum range needed
long duration;
long distance; // Duration used to calculate distance
void setup() {
Serial.begin(9600);
lcd.begin(20,4);
pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);
pinMode(LEDPin, OUTPUT);
lcd.setCursor(0,0);
lcd.print("Range Finder");
lcd.setCursor(0,1);
lcd.print("Current Distance : ");
lcd.setCursor(7,2);
lcd.print("cm");
}
void loop() {
/* The following trigPin/echoPin cycle is used to determine the
distance of the nearest object by bouncing soundwaves off of it. */
digitalWrite(trigPin, LOW);
delayMicroseconds(2);
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);
duration = pulseIn(echoPin, HIGH); // Measures the length of a pulse on echoPin in microseconds
//waits for the pin to go HIGH, starts timing, then waits for the pin to go LOW and stops timing.
//Returns the length of the pulse in microseconds.
//Calculate the distance (in cm) based on the speed of sound.
distance = duration/58.2;
if (distance >= maximumRange || distance <= minimumRange){
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Range Finder");
lcd.setCursor(0,1);
lcd.print("Current Distance : ");
lcd.setCursor(4,2);
lcd.print(distance);
lcd.setCursor(7,2);
lcd.print("cm");
delay(300);
digitalWrite(LEDPin, HIGH);
}
else {
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Range Finder");
lcd.setCursor(0,1);
lcd.print("Current Distance : ");
lcd.setCursor(4,2);
lcd.print(distance);
lcd.setCursor(7,2);
lcd.print("cm");
delay(300);
digitalWrite(LEDPin, LOW);
}
delay(500);
}
Arduino – Week 2 – Stepper Motors
What is a stepper motor?
A stepper motor uses opposing electromagnets to create rotation. The different number of steps are determined by the number of poles on each the stator and the rotor.
There are several different types of stepper motor, depending on the use case and the size that is required. The main types are :
Permanent magnet stepper > These use permanent magnets in the rotor and electromagnets in the rotor, using attraction and repulsion to create rotation
Uses
Stepper motors can be used for all sorts of CNC controlled devices such as 3D printer or CNC routers.
Mechanical arms such as those used for assembly of cars etc will use stepper motors to obtain exact position repeatably
Any automated machinery that requires exact positions to be returned to, will use stepper motor as they are very precise int he increments of rotation that they can do.
How to drive a stepper motor
Wave forms that drive a stepper motor
Turning coils on and off > Transistors are electric dimmer switches which can be used as on off switches for stepper motors
Stepper Motors with Arduino – Getting Started with Stepper Motors
Stepper Motor Code
Setup code for the stepper motor initialises which pins are the outputs from the arduino
void setup() {
// initialize digital pin LED_BUILTIN as an output.
pinMode(13, OUTPUT);
pinMode(12, OUTPUT);
pinMode(11, OUTPUT);
pinMode(10, OUTPUT);
}
void loop() {
//STEP 1
digitalWrite(10, HIGH);
digitalWrite(11, LOW);
digitalWrite(12, LOW);
digitalWrite(13, HIGH);
delay(2); // delay
//STEP 2
digitalWrite(10, HIGH);
digitalWrite(11, HIGH);
digitalWrite(12, LOW);
digitalWrite(13, LOW);
delay(2); // delay
//STEP 3
digitalWrite(10, LOW);
digitalWrite(11, HIGH);
digitalWrite(12, HIGH);
digitalWrite(13, LOW);
delay(2); // delay
//STEP 4
digitalWrite(10, LOW);
digitalWrite(11, LOW);
digitalWrite(12, HIGH);
digitalWrite(13, HIGH);
delay(2); // delay
The loop will run through all of the bracketed coded indefinitely
delay(2) is the amount of ms left between that line of code and the next, which determines how fast or slow the motor will turn. The smaller the number, the faster it spins.
Arduino – Week 1 – Software Notes
Pulse Width Modulation
Using ‘unsigned char’ to replace values
> ‘unsigned char’ allows you to control all of the same variables in a sketch by only changing one value
unsigned char DelayTime = 255;
unsigned char LEDoutput = 2;
// the setup function runs once when you press reset or power the board
void setup() {
// initialize digital pin LED_BUILTIN as an output.
pinMode(LED_BUILTIN, OUTPUT);
pinMode(LEDoutput, OUTPUT);
}
// the loop function runs over and over again forever
void loop() {
digitalWrite(LEDoutput, HIGH);
digitalWrite(LED_BUILTIN, HIGH);
delay(DelayTime);
digitalWrite(LEDoutput, LOW);
digitalWrite(LED_BUILTIN, LOW);
delay(DelayTime);
DelayTime = DelayTime - 10;
}
Week 6 – Embedded programmer
The task this week was to program the board that we made using the CNC router. There are several levels to this week, some being ‘simple’ and some being advanced.
The main goal was to upload some sort of program to our Echo Hello World Plus board and ensure that it completed the function that the program was supposed to do.
PROGRAMMING ONLY WORKS ON MACS
Installing Arduino IDE with AtTiny boards
> Install Arduino IDE from here
> On the top menu > Arduino > Preferences > Additional Boards Manager URLs > Enter the below into the box
> https://raw.githubusercontent.com/damellis/attiny/ide-1.6.x-boards-manager/package_damellis_attiny_index.json
This gives you access to the aTtiny boards and programmer
Loading the correct Settings
> Tools > Board > ATtiny24/44/84
> Tools > Processor > ATtiny44
> Tools > Clock > External 20MHz
> Tools > Programmer > USBtinyISP
Plug into a power supply with 5V > GND 1st pin on ISP > +5v is the 3rd on the ISP
Burning the Bootloader
> Tools > Burn Bootloader
This originally didn’t work on Windows and therefore we switched to MAC
Programming
The first sketch tested was the Blink sketch from the > Examples > 01.Basics > Blink
The code required us to define which pin was the LED pin in order for it to work. This was worked out by using the pinout diagram. > Pin PB2 was connected to the LED and therefore the Arduino pin for this was no. 8.
> Change all of the the LED_BUILTIN pins to 8
> Click Upload (Top menu)
Fade
The Fade sketch is very similar to the Blink > Again change all of the LED_BUILTIN to 8
Button Sketch
> Again it is an example sketch
> Change the ledPin on the constants to 8
> Change the buttonPin on the constants to 7 (as worked out from the Pinout Diagram
This is where we encountered problems due to the sketch being uploading but the LED would either flicker or not come on at all.
After some further reading on the following websites, it might be due to not having an internal pullup resistor enabled.
https://fablabbrighton.github.io/digital-fabrication-module/guides/guide-board-programming
https://www.arduino.cc/reference/en/language/functions/digital-io/pinmode/
https://www.arduino.cc/en/Tutorial/DigitalPins
This will be tested later on……
Testing the Changes
Changes made are in bold
// constants won't change. They're used here to set pin numbers: const int buttonPin = 8; // the number of the pushbutton pin const int ledPin = 7; // the number of the LED pin // variables will change: int buttonState = 0; // variable for reading the pushbutton status void setup() { // initialize the LED pin as an output: pinMode(ledPin, OUTPUT); // initialize the pushbutton pin as an input: pinMode(buttonPin, INPUT_PULLUP); } void loop() { // read the state of the pushbutton value: buttonState = digitalRead(buttonPin); // check if the pushbutton is pressed. If it is, the buttonState is HIGH: if (buttonState == HIGH) { // turn LED on: digitalWrite(ledPin, HIGH); } else { // turn LED off: digitalWrite(ledPin, LOW); } }
The only changes made to the existing button sketch was replacing INPUT with INPUT_PULLUP
Two sketches were recorded – one where the switch turned off the LED, and one which turned on the LED when it was pressed
Week 5 : Electronics Design
The task this week was to create the schematic, board layout and then mill the simple LED circuit board.
Autodesk Eagle is the circuit-board software that we used > Installing it was relatively easy as it was just a simple installation but to get the correct components for the FAB LAB, downloading the library of parts was done. This is to ensure that all of the pads are the correct size and can therefore be soldered easily.
This is the guide that I used > https://fablabbrighton.github.io/digital-fabrication-module/guides/guide-draw-circuit-in-eagle
Once you know where the library of parts is, it is relatively simple to use, but keeping it tidy is important to have an easy to read schematic and peace of mind that you have connected everything correctly.
Method for creating a new document
File > New Project > Right Click on the project > New > Schematic — Open in new window
Add Part > Search using *part* > All components that have 1206FAB as an option should be chosen
List of parts required is
- Red LED
- 1KOhm Resistor
- 10 KOhm Resistor
- Un-polarised Capacitor
- Omron Switch
- Resonator
- FTDI Header
- ISP header
- ATtiny44
Add all of the components to the schematic then change the values of the resistors and capacitor.
Right click on the component and click value > Type in the correct value so that you can use you schematic for soldering late on and correctly refer to it.
Moving on to Board
Generate Board > click OK on message box
Move components and rotate them to the orientation that is going to best suit the board layout
Change width of the trace in the top bar when drawing the traces
Change the tolerance : Tools > DRC > Clearance
Check errors : Tools > Errors
If any errors are due to the schematic, then that will need to be altered. However if the errors are due to clearance errors and traces slightly crossing, these will show up and can be fixed relatively easily. Most of the time they can be fixed in EAGLE, by either drawing the trace again and choosing a slightly different path, however if the stepping in the movement of the trace is annoying, Adobe Illustrator can be used to alter the traces.
The next step is to move it to Adobe Illustrator: File > Export > DXF > ensure scale isnt change and you save it in a suitable location.
In Adobe illustrator the main aim is to remove all line and text, leaving only the traces, pads and the outline of the board > The traces may need altering slightly from the EAGLE file so this is when you would do that.
This is when you would add a logo if you wanted to.
The outline width should be set to 3-5mm as this the components and the edge of the board enough clearance
The artboard now needs to be set the artwork size > this can be done in a simple step > Objects > Artboards > Fit to Artwork Bounds
This is a critical step to ensure the two tool paths generated have the same origin point and therefore match.
Print this as PDF to ensure the components fit. I chose to increase the width of the pads for the FTDI header to 5mm as they didn’t fit with the printout.
Save as a PNG > tick the box saying use artboard > 1000dpi > save somewhere you can find it easily
Go to > fabmodules.org > upload you PNG by selecting PNG from the drop down menu
> Select Roland Mill > PCB Traces for the traces and outline for the outline > invert the image
> set the x0 y0 and z0 to 0
> Set the yhome, xhome to 0 and the zhome to 10
> Set the tool Diameter to 0.4mm for traces ; 1mm for outline > no. of offsets to 0 for a test toolpath
The tool path should be generated when you click calculate
This is a critical check to ensure that you board will work > Make sure none of the toolpaths merge together. They can overlap but not merge.
Roland Mill
The mill is very easy to set up and has an automatic tool change which speed up the work.
Setting the x and y origin is simply selecting which axis and using the hand wheel to control how far across the cutter is.
Setting the z origin requires more skill > Turn on the spindle to full speed > select z axis > get it close using the hand wheel > change the step distance to reduce how fast the z-axis moves with the hand wheel > get the spindle to just touching the copper ; you should see a small amount of white power appear when you get close enough
Change the tool bit to the correct one for the operation > menu > click over to the one which says tools > select tool 5 for doing the traces > tool 1 for the outline
Load up the file using the blue square in the bottom corner > add your file to the menu and delete any others >
Send to the cnc and ensure that it doesn’t crash by watching it >
Once finished load the outline file and change the tool bit as above > Start the outline and wait for it to finish
Remove the finished PCB using a scraper and clean up any rough edges
Solder the components on as in last weeks blog.
Week 4 : Electronic Production
Surface mount components are very common and are what the majority of manufacturers will use due to the smaller size, compared to through components. It seems fairly easy to use them, although the mounting of these components, via soldering is vastly different to through hole components.
Through hole components have the obvious advantage of being self locating, so it is easy to manufacture. Surface mount components need to be held in place when soldering and so require skill to also locate them and make them straight.
Method
- Prepare the board for soldering by washing it in soapy water to remove any oxidation that may have occurred since milling.
- Gather all of the components and ensure you know what orientation they are supposed to be.
1x ATtiny45
2x 1kΩ resistors
2x 499Ω resistors
2x 49Ω resistors
2x 3.3v zener diodes
1x red LED
1x green LED
1x 100nF capacitor
1x 2×3 ISP header
- Tin the soldering iron by adding a small amount of solder and removing it using the wet sponge.
- Tin one of the contacts for each of the resistors, capacitors and the diodes.
- Do the same for one of the 6/8 legs of the Tiny Chips and the ISP
- Place the components on top of the solder and use a pair of tweezers to push it towards the board, therefore keeping it still. This is the hardest step, as if you have tinned the pad with too much solder then you will find it difficult to hold the component next to the board.
- Heat up the solder which you tinned onto the board and you should have attached the component onto the board.
- Then solder the other end/legs of that component, going back to add more solder to the other leg/end if there isn’t enough.
- To test the connection you should use a multi-meter on the most sensitive resistance setting. This will check continuity between the component. If the reading is 0 or very near to 0 e.g 0.003 then there is a short whereas if there is a reading of around the size of the resistors measurement then you cave it correctly installed.
- Check the overall circuit by applying 5v volts to the USB as in the diagram. S1 is shorted then the left LED should light up indicating that the circuit works.
Programming this chip requires it to be shorted and then the programming can begin.
*Update on Programming the programmer* 03/03/2019
Using these supporting blogs – Windows specific Installation
Installing the software was harder than following the links due to the lack of clear instruction on what parts are needed, especially for Git. The link for Atmel GNU Toolchain wasnt correct so I am unsure which I needed to install. I typed what the link was supposed to take me to into google and cap up with this website. Download all the files as a zip and then extract them in the desired folder.
I decided to create a different programs folder so I could better keep track of the software on my computer. I didn’t want to destroy anything.
Installations complete – all of the tools are located in F:UNI ProgrammingPrograms
Updating the path
Control Panel > Advanced System Settings > Advanced tab > Environment Variables
Under User Variables > Edit for Path > See below
Next it to download Zadig and run this to install drivers for the USB > where I got stuck
Windows didn’t like the USB and so every attempt failed to install the drivers.
I checked here for shorts between VCC and ground and found nothing amiss so it is a possibility that my PC isn’t compatible and wont recognise the USB.
Checking software installations
> Type make -v in GitBash
> Type avr-gcc –version FAILED
> Type avrdude -c usbtiny -p t45 FAILED
UPDATE 2 > 04/03/2019
Going into the Fab Lab today helped so much after the failed attempts at home. The main different being using an iMac rather than a windows computer. Mike in the Fab Lab also says that Linux works very well, so maybe a possibility of having a separate partition on a hard drive to set up a Linux OS on my PC.
The steps are as follows for Mac with the software installed:
- Download the firmware for the programmer > http://fab.cba.mit.edu/classes/863.16/doc/projects/ftsmin/
- Open the Makefile in a text editor
- Customise the make file > Edit the line with MCU = attiny45
- Customise the clock speed > Edit the line with F_CPU = 16500000UL
- Edit the programmer used to program your board > PROGRAMMER ?= usbtiny
- Plug in your board using a USB extension to not mess up your computer USB ports as well as the programmer > connect their 2 ISP headers with a ribbon cable in the correct orientation
- Open the Terminal > type pwd to check path Enter
- Type cd (space) (and drag the downloaded folder in) Enter
- Type pwd to check > should be the path of your folder Enter
- Type make flash > should come up with loading bars if working Enter
- Type make fuses > should come up with loading bars if working Enter
- Unplug both > re-insert your board > check mac recognises device in the system information > should show usbtiny
- Reattach programmer and ribbon cable
- Type make rstdisbl > blows reset fuse > should come up with loading bars if working Enter
- Remove solder bridge if successful and you should now have a programmer
The programmer was then successfully tested using Andrew’s code to a board containing an LED and switch.
Multiple programs were tested and all were successful.
Work and Personal Portfolio 