To start to get familiar with c-code I went back to the echo board and had a go at uploading the echo code using the tutorial that Neil provided. I managed to get it working and then found some C-code which would get the LED I added to blink with a few adjustments. The code is below:



Now that I had some of my own c code I just had to recall the steps to get it on the board. They are as follows:

Make a folder with the name of the project (I called mine blink)

Inside that folder you need the c code file and the make file. They have the extensions .c and .c.make respectively. Take a look:



I used the make file Neil wrote. All I needed to change was the name of the file to match mine and in the code just replace the project name with the name of the c code file (minus the extension).

Now it is time to go to the terminal. With the ISP and circuit board correctly connected you need to tell the computer to use the .c.make file to convert the c code into something that the micro controller can use and put it on the board. To do this we type the following command:



The command used was "sudo make -f blink.c.make". You can see the two new files in the folder.

Now to put the code on the board you need to run the same command but also type "program-usbtiny" so the full command is "sudo make -f blink.c.make program-usbtiny"



The final result:



Now that I know the procedure, it is time for me to make the third version of my board and adapt the c-code that Neil has written for the two inputs so that it works with the atiny-44 controller. Using the c code may be a bit abitious for me so i may resort to arduino if it gets tough.

I milled the third version of my board and got to work on recycling the components from the second board using a heat gun. In no time at all the board was soldered. To my annoyance I had failed to correct the issue about the hall effect sensor not being connected to a pin on the mocro controller so I focused on getting the phototransistor to work as time was ticking.



It was now time to get some code on the board. I started with arduino and burned the bootloader with the necesary settings. Next was to write some arduino code. I adapted an if statement template so that the RBG would light up in dark conditions. However, the code wasn't working. I asked Emma, one of the instructors for some help and it turns out that for the arduino to work correctly, it needs a much more accurate clock than the default one, or one with less of a percentage error. A way around this would have been to add an external 20MHZ clock but it was a bit late for that. I didn't add the clock because I intended to use c code which wouldn't have a problem with this. Thankfully there was a solution to the temporary issue in the for of another arduino program written by Zaerc, our coding guru. He wrote a fantastic bit of code which indicade the line of code required to make the clock accurate. The code is as follows:

 

//HardwareSerial mySerial=Serial;  // RX==0, TX==1

//TinyDebugSerial mySerial=Serial; // RX!=4, TX==3

#include "SoftwareSerial.h"
SoftwareSerial mySerial( 7, 4); // RX, TX

//#include <SoftSerial.h>
//#include <TinyPinChange.h>
//SoftSerial mySerial( 0, 1); // RX, TX (like UsiSerial)
//SoftSerial mySerial( 5, 2); // RX, TX (tinyFly)
//SoftSerial mySerial( 1, 2); // RX, TX (FTDI breakout)
//SoftSerial mySerial( 4, 3); // RX, TX (TinyTuner)
//#include <EEPROM.h>
//#include <TinyOscCal.h>

//#include <UsiSerial.h>
//USISerial mySerial=UsiSerial; // RX==0, TX==1

//#define BAUD
//#define BAUD   300
//#define BAUD  9600
#define BAUD 19200

byte factory;
int offset;
char dir;


void setup()
{ 

  //Initialize serial and wait for port to open:
  mySerial.begin( BAUD);

//TinyOscCal.init( &mySerial, 0, 1);
//  TinyOscCal.init( &mySerial, 0, 0);

/** /
  mySerial.println("\nHello serial!");
  mySerial.print("OSCCAL=0x");
  mySerial.println(OSCCAL, HEX);
/**/


  factory=OSCCAL;
  offset=0;
  dir=1;

//  tinyCal();
}

void loop()
{
  tinyCal();
/*
  if (mySerial.available())
    mySerial.write(mySerial.read());
*/
}

void tinyCal()
{
/**/
  if( offset < -20 )
    dir=1;
  if( offset > 20 )
    dir=-1;
/**/
  offset+=dir;
  
  OSCCAL=byte(factory+offset);
  delay( 10);

  mySerial.print( "OSCCAL= 0x");
//  mySerial.print( factory+offset, HEX);
  mySerial.print( OSCCAL, HEX);
  mySerial.println( " hit <Enter>");
  delay( 1000);
  
}

Below is what shows in the serial montior when the code is run completely once. The lines starting with "OSCCAL" are the lines which have correctly calibrated the clock well enough for the serial communication to work and can then be used in other code. Zaerc said it is best to pick one from the centre of the pack. I picked "OSCCAL= 0x8B"

SoftwareSerial mySerial(7, 4);
// These constants won't change:
const int analogPin = 5;    // pin that the sensor is attached to
const int ledPin = 3;       // pin that the LED is attached to
const int threshold = 400;   // an arbitrary threshold level that's in the range of the analog input

void setup() {
  OSCCAL= 0x8B;
  // initialize the LED pin as an output:
  pinMode(1, OUTPUT);
  pinMode(2, OUTPUT);
  pinMode(5, INPUT);
  pinMode(3, OUTPUT);  // initialize serial communications:
  mySerial.begin(9600);
  delay(1);
}

void loop() {
  // read the value of the potentiometer:
  int analogValue = analogRead(5);

  // if the analog value is high enough, turn on the LED:
  if (analogValue > threshold) {
    digitalWrite(3, LOW);
     digitalWrite(2, LOW);
      digitalWrite(1, LOW);
  }
  else {
    digitalWrite(3, HIGH);
     digitalWrite(2, HIGH);
      digitalWrite(1, HIGH);
  }

  // print the analog value:
  mySerial.println(analogValue);
  delay(1);        // delay in between reads for stability
}