Friday, 22 November 2013

Knock Clock with DS1307 continued!

Last post we designed a circuit to make a knock clock....Here is the circuit construction process:

1.  Obtain copper clad circuit board and print out bottom layer reversed on 120gm glossy paper using a laser printer.

2.  Using a clothes Iron to transfer bottom layer design to copper clad board.


3.  Once the design has been transferred soak off the excess paper with water to leave only the required copper.  Then etch the PCB using the preferred etchant - I used Ferric Chloride.


4.  After twenty minutes or so the copper should be etched away - monitor the process closely


5.  Once the etching is complete clean off the black ink using something abrasive - I used steel wool.  


6.  Finally drill out the holes using suitable drill sizes.  I used 0.8mm for every hole and then increased the FET, regulator and screw terminal holes to 1mm.

7.  Next populate the PCB with the components.  Make sure the IC socket (if you are using one) is orientated correctly along with the FET and the regulator and diode.  All of the other components are reversible.


Once that is complete we are onto the next stage.  I have to admit at this point I applied 12Vdc to the input to see if the red LED would light - it shows all of the power supply section is working - it was after I removed the LED and connected it with the correct polarity.  I always seem to get something wrong!

Next I flashed the arduino bootloader onto the ATMEL 328p chip using a dedicated ATMEL chip programmer.  There are loads of instructions available on how to achieve this:

How to flash a bootloader onto an ATMEL 328p

Once that was complete I loaded blink onto the target IC and connected an LED between MOSI and GND.  The LED flashed on and off - SUCCESS!

After that moment of awesomeness I loaded the code that I have developed earlier to achieve the knock clock functionality required.  I have to admit I had already done this as I breadboarded the circuit before populating the PCB...

Before doing all of this I populated the DS1307 adafruit RTC kit following the instructions on their website. I also then set the time on device using the serial terminal.  The instructions for doing this are:

Adafruit DS1307-real-time-clock-breakout-board-kit

The final Knock Clock code was developed from several libraries and some fairly standard programming.

Here is the code:

/*
 * Langster's Knock Clock Code
 * Forked from the TimeRTC Library example
 * The Knock Sensor Example from the Arduino Library
 * and some simple code to drive the solenoid from  
 * the FET - 22-11-2013
 */

#include <Time.h>       // Include time.h library
#include <Wire.h>       // Include Wire.h
#include <DS1307RTC.h>  // Include DS1307.h Library

byte val = 0;           // Variable to store a byte value

int solenoidPin = 9;    // FET solenoid Gate is connected to Digital pin 9
int knockSensor = A0;   // Piezo sensor attached to analogue zero            
int THRESHOLD = 10;     // integer variable that sets knock sensitivity
int hoursLoop = 0;      // integer variable for hours loop
int minutesLoop = 0;    // integer variable for minutes loop


void setup()  {
  Serial.begin(9600);         // start serial terminal at 9600 baud for debugging
  while (!Serial) ;           // wait until Arduino Serial Monitor opens
  setSyncProvider(RTC.get);   // the function to get the time from the RTC
  if(timeStatus()!= timeSet) 
     Serial.println("Unable to sync with the RTC");
  else
     Serial.println("RTC has set the system time");

  pinMode(solenoidPin, OUTPUT); //Set solenoid pin as a digital output    
}

void loop()
{
    val = analogRead(knockSensor);     // check for a knock!
    if (val >= THRESHOLD) 
    {
      Serial.println("Knock!");        // knock detected!
      if (timeStatus() == timeSet) 
      {
        digitalClockDisplay();         // display the time on the serial terminal
        actuateSolenoid();             // Drive the FET to actuate the solenoid
      } 
    else 
      {
        Serial.println("The time has not been set.  Please run the Time");
        Serial.println("TimeRTCSet example, or DS1307RTC SetTime example.");
        Serial.println();
        delay(4000);
      }
    }  
}

void digitalClockDisplay(){
  // digital clock display of the time
  Serial.print(hour());
  printDigits(minute());
  printDigits(second());
  Serial.println(); 
  delay(500);
}

void printDigits(int digits){
  // utility function for digital clock display: prints preceding colon and leading 0
  Serial.print(":");
  if(digits < 10)
    Serial.print('0');
  Serial.print(digits);
}

void actuateSolenoid()
{
int convertHours = hour();  //convert from 24hour clock to 12 hour clock 
    if (convertHours > 12)
        {
          convertHours = convertHours - 12;
        }
  
  Serial.print("convertHours: ");
  Serial.print(convertHours);
  Serial.println(" ");
  
  //drive FET to actuate solenoid for number of hours
  
  for (hoursLoop=1; hoursLoop <= convertHours; hoursLoop++)
    {
       Serial.print(hoursLoop);
       Serial.println(" ");
       digitalWrite(solenoidPin, HIGH);
       delay(500);
       digitalWrite(solenoidPin, LOW);
       delay(500);
    } 
    
    delay(1000);  //pause between hours knocks and minutes knock

  int convertMinutes = minute();         //convert minutes to tens of minutes
  convertMinutes = convertMinutes / 10;
  
  Serial.print("convertMinutes: ");
  Serial.print(convertMinutes);
  Serial.println(" ");
  
  //drive FET to actuate solenoid for number of minutes
    
    for (minutesLoop=1; minutesLoop <= convertMinutes; minutesLoop++)
    {
       Serial.print(minutesLoop);
       Serial.println(" ");
       digitalWrite(solenoidPin, HIGH);
       delay(500);
       digitalWrite(solenoidPin, LOW);
       delay(500);
    }

}

The code pretty simple and the comments should explain each section clearly.  Essentially the arduino constantly polls the piezo sensor for a knock.  If a knock is detected the time is read from the real time clock device (DS1307).  The Hour data is then converted from 24 Hour clock format to 12 Hour format and the Solenoid is actuated for the number of Hours.  There is a short delay and then the minutes data is converted to tens of minutes and again the solenoid is actuated for the number of minutes.  The program then loops back to the start polling the piezo sensor for another Knock!

I will post a video of the circuit working when I get a chance!  The next post will discuss making a laser cut box for the Knock Clock before final assembly!  That is it for now though - Enjoy Langster!