![](/media/cache/group/default_image.jpg.50x50_q85.jpg)
lab 7
Dependencies: SDFileSystem mbed
Revision 0:f6d3b930f382, committed 2016-12-10
- Comitter:
- jedh
- Date:
- Sat Dec 10 21:08:30 2016 +0000
- Commit message:
- jgk
Changed in this revision
diff -r 000000000000 -r f6d3b930f382 DS1307/ds1307.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/DS1307/ds1307.cpp Sat Dec 10 21:08:30 2016 +0000 @@ -0,0 +1,288 @@ +#include "ds1307.h" + +DS1307::DS1307(PinName sda, PinName scl ) : ds1307i2c(sda,scl) { + ds1307i2c.frequency(DS1307_freq); +} + +DS1307::~DS1307() { +} + +int DS1307::read( int addr, int quantity, char *data) { + // note the char array at data must contain 63 locations or unpredictable behavior will happen + // addr must be 0 - 62 as the 64th(or 63rd as indexed from 0) ram location is clobered in this method of access + // quantity must be 1 - 63 as the 64th ram location is clobered in this method of access + int test = 0 ; + char temp_data[65]; + + if (addr > DS1307_lastram) return (1); // fail because address greater then what chip has to read from + if (addr < 0 ) return (1); // fail because address less then 0 is not available + if (quantity > DS1307_lastreg) return (1); // fail because quantity greater then what can be read + if ((addr + quantity) > DS1307_lastreg ) return (1); // fail because cant read past reg 63 + if ( quantity == 0 ) return (1); // fail because zero quantity wanted + temp_data[0] = DS1307_lastreg ; // note this ram location is used to set the addressing pointer in DS1307 + temp_data[1] = 0; // just junk to clober this address with + test = ds1307i2c.write(DS1307_addr,temp_data,2); + if (test == 1) return (1); // the write operation failed + ds1307i2c.stop(); // now the DS1307 is pointing to the first register + if ( addr != 0 ) test = ds1307i2c.read(DS1307_addr,temp_data,addr); // now the DS1307 address pointer is pointing to correct address + if (test == 1) return (1); // the read operation failed + test = ds1307i2c.read(DS1307_addr,data,quantity); // read the DS1307 registers now + if (test == 1) return (1); // read operation failed + return(0); // looks like the data read was good +} + +int DS1307::read(int addr, int *data) { + // addr must be 0 - 62 as the 64th(or 63rd as indexed from 0) ram location is clobered in this method of access + int test = 0; + char temp_data[65]; + test = DS1307::read(addr, 1, &temp_data[0]); + if (test == 1) return(1); // fail because read to DS1307 failed + *data = (int)temp_data[0]; // returing the read data by pointer + return (0); // the single read is successfull +} + +int DS1307::write( int addr, int quantity, char *data) { + // note the char array at data must contain 63 locations or unpredictable behavior will happen + // addr must be 0 - 62 as the 64th(or 63rd as indexed from 0) ram location is clobered in this method of access + // quantity must be 1 - 63 as the 64th ram location is clobered in this method of access + int test = 0 ; + char temp_data[65] ; + int loop = 0; + + if (addr > DS1307_lastram) return (1); // fail because address greater then what chip has to read from + if (addr < 0 ) return (1); // fail because address less then 0 is not available + if (quantity > DS1307_lastreg) return (1); // fail because quantity greater then what can be read + if (quantity == 0) return (1); // fail because zero quantity is wanted + if ((addr + quantity) > DS1307_lastreg ) return (1); // fail because cant read past reg 63 + + temp_data[0] = (char)addr; + for ( ; loop < quantity ; loop++ ) { + temp_data[loop+1] = *(data + loop); + } + test = ds1307i2c.write(DS1307_addr, temp_data, (quantity + 1)); + ds1307i2c.stop(); + return(test); // 0 for success 1 for failure to write +} + +int DS1307::write( int addr, int data ) { + // addr must be 0 - 62 as the 64th(or 63rd as indexed from 0) ram location is clobered in this method of access + int test = 0 ; + char temp_data[2] ; + + temp_data[0] = (char)addr; + temp_data[1] = (char)data; + if (addr > DS1307_lastram) return (1); // fail because address greater then what chip has to read from + if (addr < 0 ) return (1); // fail because address less then 0 is not available + test = ds1307i2c.write(DS1307_addr, temp_data, 2); + ds1307i2c.stop(); + return(test); +} + +int DS1307::start_clock(void) { // start the clock + int test = 0; + int junk = 0; + + test = DS1307::read(DS1307_sec, &junk); + if (test == 1) return(1); // fail because read to DS1307 failed + junk = ( 0x7F & junk); // basicaly i mask bit 8 to set it to zero + test = DS1307::write(DS1307_sec,junk); // now write the seconds back to register and because bit 8 is zero this starts clock. + if (test == 1) return(1); // fail because read to DS1307 failed + return(test); // +} + +int DS1307::stop_clock(void) { // stop clock + int test = 0; + int junk = 0; + + test = DS1307::read(DS1307_sec, &junk); + if (test == 1) return(1); // fail because read to DS1307 failed + junk = ( 0x7F & junk); // basicaly i mask bit 8 to set it to zero but keep all other bits + junk = ( 0x80 | junk); // basicaly i mask bit 8 to set it to one + test = DS1307::write(DS1307_sec,junk); // now write the seconds back to register and because bit 8 is one this starts clock. + if (test == 1) return(1); // fail because read to DS1307 failed + return(test); // +} + +int DS1307::twelve_hour(void) { // set 12 hour mode + int test = 0; + int junk = 0; + + test = DS1307::read(DS1307_hour, &junk); + if (test == 1) return(1); // fail because read to DS1307 failed + if ((junk & 0x40) == 0x40) return(0); // return because 12 mode is active now all done! + + junk = ( junk & 0x3F); // only use 24 hour time values + if (junk == 0x00) + junk = 0x12; + else if (junk >= 0x13) + if (junk < 0x20) { + junk = junk - 0x12; + junk = (junk | 0x20); // add back the pm indicator + } else + switch (junk) { + case 0x20: + junk = 0x28; + break; + case 0x21: + junk = 0x29; + break; + case 0x22: + junk = 0x30; + break; + case 0x23: + junk = 0x31; + break; + } + + test = DS1307::write(DS1307_hour,(0x40 | junk)); // set bit 6 with the new 12 hour time converted from the 24 hour time + if (test == 1) return(1); // fail because read to DS1307 failed + + return(0); +} + +int DS1307::twentyfour_hour(void) { // set 24 hour mode + int test = 0; + int junk = 0; + + test = DS1307::read(DS1307_hour, &junk); + if (test == 1) return(1); // fail because read to DS1307 failed + if ((junk & 0x40) == 0) return(0); // return because 24 mode is active now all done! + + junk = (junk & 0xBF); // get value bits and am/pm indicator bit but drop 12/24 hour bit + + if (junk > 0x12) + if ( junk <= 0x27 ) + junk = junk - 0x0E; + else + junk = junk - 0x08; + + test = DS1307::write(DS1307_hour,( 0xBF & junk)); // clear bit 6 and set the new 24 hour time converted from 12 hour time + if (test == 1) return(1); // fail because read to DS1307 failed + + return(0); +} + +int DS1307::settime(int sec, int min, int hour, int day, int date, int month, int year) { // to set the current time and start clock + // sec = 0 to 59, min = 0 to 59, hours = 0 to 23 ( 24 hour mode only ), day = 1 to 7 ( day of week ), date = 1 to 31, month = 1 to 12, year 0 to 99 ( this is for 2000 to 2099) + DS1307::stop_clock(); + + if (1 == DS1307::hilow_check( 59, 0, sec)) { + return(1); // failed because recieved value is not in bounds + } else { + if (1 == (DS1307::write(DS1307_sec,DS1307::dectobcd(sec)))) return(1); // failed to write for some reason + } + + if (1 == DS1307::hilow_check( 59, 0, min)) { + return(1); // failed because recieved value is not in bounds + } else { + if (1 == (DS1307::write(DS1307_min,DS1307::dectobcd(min)))) return(1); // failed to write for some reason + } + + if (1 == DS1307::twentyfour_hour()) return(1); // failed to set 24 hour format + if (1 == DS1307::hilow_check( 23, 0, hour)) { // note setting 24 hour mode befor and after writing the hour value ensures 24 hour mode is set + return(1); // failed because recieved value is not in bounds + } else { + if (1 == (DS1307::write(DS1307_hour,DS1307::dectobcd(hour)))) return(1); // failed to write for some reason + } + if (1 == DS1307::twentyfour_hour()) return(1); // failed to set 24 hour format + + if (1 == DS1307::hilow_check( 7, 1, day)) { + return(1); // failed because recieved value is not in bounds + } else { + if (1 == (DS1307::write(DS1307_day,DS1307::dectobcd(day)))) return(1); // failed to write for some reason + } + + if (1 == DS1307::hilow_check( 31, 1, date)) { + return(1); // failed because recieved value is not in bounds + } else { + if (1 == (DS1307::write(DS1307_date,DS1307::dectobcd(date)))) return(1); // failed to write for some reason + } + + if (1 == DS1307::hilow_check( 12, 1, month)) { + return(1); // failed because recieved value is not in bounds + } else { + if (1 == (DS1307::write(DS1307_month,DS1307::dectobcd(month)))) return(1); // failed to write for some reason + } + + if (1 == DS1307::hilow_check( 99, 0, year)) { + return(1); // failed because recieved value is not in bounds + } else { + if (1 == (DS1307::write(DS1307_year,DS1307::dectobcd(year)))) return(1); // failed to write for some reason + } + + DS1307::start_clock(); + return (0); // time is now set +} + +int DS1307::gettime(int *sec, int *min, int *hour, int *day, int *date, int *month, int *year) { // to get the current time information + // sec = 0 to 59, min = 0 to 59, hours = 0 to 23 ( 24 hour mode only ), day = 1 to 7 ( day of week ), date = 1 to 31, month = 1 to 12, year 0 to 99 ( this is for 2000 to 2099) + if (1 == DS1307::read(DS1307_sec,sec)) return(1); // failed to read for some reason + *sec = (*sec & 0x7F ); // drop the clock start stop bit + *sec = DS1307::bcdtodec( *sec); // bcd is now dec value + + if (1 == DS1307::read(DS1307_min,min)) return(1); // failed to read for some reason + *min = (*min & 0x7F ); // drop bit 7 because it should be 0 anyways + *min = DS1307::bcdtodec( *min); // bcd is now dec value + + if (1 == DS1307::read(DS1307_hour,hour)) return(1); // failed to read for some reason + if ((*hour & 0x40) == 0x40) { // if true then 12 hour mode is set currently so change to 24 hour, read value, and return to 12 hour mode + if (1 == DS1307::twentyfour_hour()) return(1); // failed to set 24 hour mode for some reason + if (1 == DS1307::read(DS1307_hour,hour)) return(1); // failed to read for some reason + *hour = (*hour & 0x3F ); // drop bit 7 & 6 they are not used for 24 hour mode reading + *hour = DS1307::bcdtodec( *hour); // bcd is now dec value + if (1 == DS1307::twelve_hour()) return(1); // failed to return to 12 hour mode for some reason + } else { // in 24 hour mode already so just read the hour value + if (1 == DS1307::read(DS1307_hour,hour)) return(1); // failed to read for some reason + *hour = (*hour & 0x3F ); // drop bit 7 & 6 they are not used for 24 hour mode reading + *hour = DS1307::bcdtodec( *hour); // bcd is now dec value + } + + if (1 == DS1307::read(DS1307_day,day)) return(1); // failed to read for some reason + *day = (*day & 0x07 ); // drop the non used bits + *day = DS1307::bcdtodec( *day); // bcd is now dec value + + if (1 == DS1307::read(DS1307_date,date)) return(1); // failed to read for some reason + *date = (*date & 0x3F ); // drop bit 6 and 7 not used for date value + *date = DS1307::bcdtodec( *date); // bcd is now dec value + + if (1 == DS1307::read(DS1307_month,month)) return(1); // failed to read for some reason + *month = (*month & 0x1F ); // drop bit 5, 6 and 7 not used for month value + *month = DS1307::bcdtodec( *month); // bcd is now dec value + + if (1 == DS1307::read(DS1307_year,year)) return(1); // failed to read for some reason + *year = DS1307::bcdtodec( *year); // bcd is now dec value + + return (0); // data returned is valid +} + + +int DS1307::dectobcd( int dec) { + int low = 0; + int high = 0; + + high = dec / 10; // this gives the high nibble value + low = dec - (high * 10); // this gives the lower nibble value + return ((high *16) + low); // this is the final bcd value but in interger format +} + +int DS1307::bcdtodec( int bcd) { + int low = 0; + int high = 0; + + high = bcd / 16; + low = bcd - (high * 16); + return ((high * 10) + low); + +} + +int DS1307::hilow_check( int hi, int low, int value) { + if ((value >= low)&(value <= hi)) + return(0); // value is equal to or inbetween hi and low + else + return(1); // value is not equal to or inbetween hi and low +} + + + + +
diff -r 000000000000 -r f6d3b930f382 DS1307/ds1307.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/DS1307/ds1307.h Sat Dec 10 21:08:30 2016 +0000 @@ -0,0 +1,224 @@ +#ifndef DS1307_H +#define DS1307_H + +/* mbed Dallas Semiconductor DS1307 serial real time clock +* Copyright (c) 2012 pksmith +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to deal +* in the Software without restriction, including without limitation the rights +* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +* copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +* THE SOFTWARE. +*/ + +#include "mbed.h" + +#define DS1307_addr 0xD0 // this is fixed by Dallas +#define DS1307_freq 100000 // this is the Dallas spec for operating i2c for this device +#define DS1307_sec 0x00 // seconds +#define DS1307_min 0x01 // min +#define DS1307_hour 0x02 // hours +#define DS1307_day 0x03 // day +#define DS1307_date 0x04 // date +#define DS1307_month 0x05 // month +#define DS1307_year 0x06 // year +#define DS1307_sqrout 0x07 // square output register +#define DS1307_ramstart 0x08 // register address that ram starts at +#define DS1307_lastreg 0x3F // this is the last register in the device (note also this register is used to address everything so it gets clobbered) +#define DS1307_lastram 0x3E // last usable ram by this class as the lastreg is clobbered by code for normal operation + +/** DS1307 control and communication class using mbed's i2c class + * + * Example: + * @code + * // show how the DS1307 class works + * #include "ds1307.h" + * #include "mbed.h" + * + * Serial pc(USBTX, USBRX); // tx, rx for debug and usb pc comunications + * + * DS1307 my1307(p9,p10); // start DS1307 class and give it pins for connections of the DS1307 device + * + * int sec = 0; + * int min = 0; + * int hours = 0; + * int day = 0; + * int date = 0; + * int month = 0; + * int year = 0; + * + * void test_rw(int test) { + * if (test == 0) pc.printf("Last R/W operaion passed!\n\r"); + * else pc.printf("Last R/W operation failed!\n\r"); + * } + * + * int main() { + * int junk = 0; + * + * sec = 24; // 24 seconds + * min = 13; // 13 min + * hours = 13; // 1 pm + * day = 4; // wednesday + * date = 20; // June 20 + * month = 6; + * year = 12; // 2012 + * // set time to these values on the ds1307 connected device + * + * test_rw(my1307.settime( sec, min, hours, day, date, month, year)); + * pc.printf("seconds set are %.2D \n\r",sec); + * pc.printf("min set are %.2D \n\r",min); + * pc.printf("hour set are %.2D \n\r",hours); + * pc.printf("day set are %.2D \n\r",day); + * pc.printf("date set are %.2D \n\r",date); + * pc.printf("month set are %.2D \n\r",month); + * pc.printf("year set are %.2D \n\r",year); + * wait(3); + * // now read the time of the DS1307 device and see what time it is + * // note that because of the 3 second wait this time should be 3 seconds past what it was set to earlier + * + * test_rw(my1307.gettime( &sec, &min, &hours, &day, &date, &month, &year)); + * pc.printf("seconds read are %.2D \n\r",sec); + * pc.printf("min read are %.2D \n\r",min); + * pc.printf("hour read are %.2D \n\r",hours); + * pc.printf("day read are %.2D \n\r",day); + * pc.printf("date read are %.2D \n\r",date); + * pc.printf("month read are %.2D \n\r",month); + * pc.printf("year read are %.2D \n\r",year); + * + * junk = 0x39; // just a junk value do read and write test to DS1307 ram + * test_rw(my1307.write( 0x20, junk)); // this should write the value of junk to register 0x20 (a ram location) in the ds1307. + * pc.printf("Value written to register 0x20 %.2X \n\r",junk); + * junk = 0; // clear junk to show that when the register is read from the correct value is obtained + * test_rw(my1307.read( 0x20, &junk)); // this should read register 0x20 + * pc.printf("Value read from register 0x20 %.2X \n\r",junk); + * } + * @endcode + */ +class DS1307 { +public: + /** Create object connected to DS1307 pins ( remember both pins need pull up resisters) + * + * Ensure the pull up resistors are used on these pins. Also note there is no checking on + * if you use thes pins p9, p10, p27, p28 so ensure you only use these ones on the LPC1768 device + * + * @param sda pin that DS1307 connected to (p9 or p28 as defined on LPC1768) + * @param slc pin that DS1307 connected to (p10 or p27 ad defined on LPC1768) + */ + DS1307( PinName sda, PinName slc) ; // constructor + + ~DS1307(); // destructor + + /** Bulk read of several registers at a time + * + * Ensure the variable data pointer passed to this function has the room needed to recieve the quantity! + * + * @param addr the address to read from + * @param quantity the amount of registers to read from + * @param data the place to put the values read + * @param returns 0 if read worked 1 if the read of DS1307 failed for some reason + */ + int read( int addr, int quantity, char *data); // to read some of the 63 bytes from DS1307 + + /** Read one register of DS1307 device + * + * @param addr the address to read from + * @param data read from the one register + * @param returns 0 if read worked 1 if the read of DS1307 failed for some reason + */ + int read(int addr, int *data); // to read one byte only + + /** Bulk write of several registers at a time + * + * @param addr the address to write to + * @param quantity the amount of registers to write to + * @param data that contains the values to be written to the registers + * @param returns 0 if write worked 1 if the write to DS1307 failed for some reason + */ + int write( int addr, int quantity, char *data); // to write bytes to some of the 63 locations in the DS1307 + + /** Write one register of DS1307 device + * + * @param addr the address to write to + * @param data to write to register + * @param returns 0 if write worked 1 if the write to DS1307 failed for some reason + */ + int write( int addr, int data ); // to write one byte only + + /** Start DS1307 clock + * + * @param returns 0 if clock started 1 if the write command to DS1307 failed for some reason + */ + int start_clock(void); // start the clock + + /** Stop DS1307 clock + * + * @param returns 0 if clock stopped 1 if the write command to DS1307 failed for some reason + */ + int stop_clock(void); // stop clock + + /** Set twelve hour mode on DS1307 (note this also converts 24 hour time to 12 time if needed on DS1307) + * + * Note this will convert DS1307 time values in registers to 12 hour values from 24 hour values if needed + * + * @param returns 0 if DS1307 is now in 12 hour mode 1 if the command to DS1307 failed for some reason + */ + int twelve_hour(void); // set 12 hour mode + + /** Set twenty four hour mode on DS1307 + * + * Note this will convert DS1307 time values in registers to 24 hour values from 12 hour values if needed + * + * @param returns 0 if DS1307 is now in 24 hour mode 1 if the command to DS1307 failed for some reason + */ + int twentyfour_hour(void); // set 24 hour mode + + /** Set the time to some current or other value ( note that this will start the clock after it is set!) + * + * Note this will return 1 if any of the values passed to this function are not as listed below! + * + * @param sec the seconds value (0 - 59) + * @param min the minute value (0 - 59) + * @param hour the hour value (0 - 23) always in 24 hour + * @param day the day value ( sunday is 1 ) + * @param date the date value (1 - 31) + * @param month the month value (1-12) + * @param year the year value (00 - 99) this is for 2000 to 2099 only as i understand it! + * @param returns 0 if time is set 1 if the time setting failed in some way + */ + int settime(int sec, int min, int hour, int day, int date, int month, int year); // to set the current time and start clock + + /** Read the current time of the DS1307 + * + * @param sec the seconds value (0 - 59) + * @param min the minute value (0 - 59) + * @param hour the hour value (0 - 23) always in 24 hour + * @param day the day value ( sunday is 1 ) + * @param date the date value (1 - 31) + * @param month the month value (1-12) + * @param year the year value (00 - 99) this is for 2000 to 2099 only as i understand it! + * @param returns 0 if time is read correctly 1 if the time was not recieved correctly for some reason + */ + int gettime(int *sec, int *min, int *hour, int *day, int *date, int *month, int *year); // to get the current time information + + +protected: + I2C ds1307i2c; + int dectobcd( int ); + int bcdtodec( int ); + int hilow_check( int, int, int); + +}; + +#endif
diff -r 000000000000 -r f6d3b930f382 EE3420_time.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/EE3420_time.h Sat Dec 10 21:08:30 2016 +0000 @@ -0,0 +1,217 @@ +#ifndef EE3420_TIME_H +#define EE3420_TIME_H + +#include "mbed.h" + + +/*support for internal RTC of Freedom KL46Z uses the time_t and tm data types */ +#include <time.h> +time_t EE3420_time; +struct tm * EE3420_timeinfo; +/* +tm_sec int seconds after the minute 0-61* +tm_min int minutes after the hour 0-59 +tm_hour int hours since midnight 0-23 +tm_mday int day of the month 1-31 +tm_mon int months since January 0-11 +tm_year int years since 1900 +tm_wday int days since Sunday 0-6 +tm_yday int days since January 1 0-365 +tm_isdst int Daylight Saving Time flag +*/ + + +/* support for DS1307 uses DS1307_data type */ + +#include "ds1307.h" + +DS1307 EE3420_DS1307(PTE0,PTE1); // start DS1307 class and give it pins for connections of the DS1307 device + +typedef struct ds1307_data +{ +int sec; +int min; +int hours; +int day; +int date; +int month; +int year; +} DS1307_DATA; + +DS1307_DATA EE3420_DS1307_data; + +char * EE3420_weekday_names[7] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"}; +char * EE3420_month_names[12] = {"January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"}; + +void show_clock_24(DS1307_DATA *tdata) +{ +pc.printf("%02i:%02i:%02i, %s, %s %i, %i\r\n",tdata->hours,tdata->min,tdata->sec,EE3420_weekday_names[(tdata->day)-1],EE3420_month_names[(tdata->month)-1],tdata->date,(tdata->year)+2000 ); + +} + +void format_time_string_24(DS1307_DATA *tdata, char *time_str) +{ +sprintf(time_str,"%02i:%02i:%02i, %s, %s %i, %i\r\n",tdata->hours,tdata->min,tdata->sec,EE3420_weekday_names[(tdata->day)-1],EE3420_month_names[(tdata->month)-1],tdata->date,(tdata->year)+2000 ); +} + +void show_clock_12(DS1307_DATA *tdata) +{ +char ap='a'; +int hr=0; + +if (tdata->hours >= 12) {ap='p';} else {ap='a';} +hr=(tdata->hours)%12; +if (hr==0) {hr=12;} +pc.printf("%02i:%02i:%02i %c.m., %s, %s %i, %i\r\n",hr,tdata->min,tdata->sec,ap,EE3420_weekday_names[(tdata->day)-1],EE3420_month_names[(tdata->month)-1],tdata->date,(tdata->year)+2000 ); +} + +void format_time_string_12(DS1307_DATA *tdata, char *time_str) +{ +char ap='a'; +int hr=0; + +if (tdata->hours >= 12) {ap='p';} else {ap='a';} +hr=(tdata->hours)%12; +if (hr==0) {hr=12;} +sprintf(time_str,"%02i:%02i:%02i %c.m., %s, %s %i, %i\r\n",hr,tdata->min,tdata->sec,ap,EE3420_weekday_names[(tdata->day)-1],EE3420_month_names[(tdata->month)-1],tdata->date,(tdata->year)+2000 ); +} + + + +void prompt_for_time(DS1307_DATA *tdata) +{ + +pc.printf("\r\nEnter the time you want to set as prompted.\r\n"); + +tdata->year=100; +while( (tdata->year < 0) || (tdata->year > 99)) +{ +pc.printf("Enter the year as a number 0-99 to represent the year 2000-2099: "); +pc.scanf("%i",&tdata->year); +pc.printf("\r\n"); +} + +tdata->month=100; +while( (tdata->month < 1) || (tdata->month > 12)) +{ +pc.printf("Enter the month as a number 1-12 for January - December: "); +pc.scanf("%i",&tdata->month); +pc.printf("\r\n"); +} + +tdata->date=100; +while( (tdata->date < 1) || (tdata->date > 31)) +{ +pc.printf("Enter the day of the month as a number 1-31 to represent the day of the month: "); +pc.scanf("%i",&tdata->date); +pc.printf("\r\n"); +if((tdata->month==2) && (tdata->date > 29)) +{ + tdata->date=33; + pc.printf("February has 29 days at most.\r\n"); +} +if((tdata->month==2) && (tdata->date == 29) && ((tdata->year%4) !=0) && (tdata->year !=0)) +{ + tdata->date=33; + pc.printf("February has 28 days at most in non-leap years.\r\n"); +} +} + +tdata->day=100; +while( (tdata->day < 1) || (tdata->day > 7)) +{ +pc.printf("Enter the day of the week as a number 1-7 for Sunday - Saturday: "); +pc.scanf("%i",&tdata->day); +pc.printf("\r\n"); +} + +int ampm=2; +tdata->hours=100; +while((tdata->hours < 0) || (tdata->hours > 23)) +{ +pc.printf("Enter the hour as 0-23: "); +pc.scanf("%i",&tdata->hours); +pc.printf("\r\n"); +if((tdata->hours >=1 ) && (tdata->hours <= 12) ) +{ + ampm=2; + while((ampm<0) || (ampm > 1)) + { + pc.printf("Enter 0 for a.m. and 1 for p.m.: "); + pc.scanf("%i",&m); + pc.printf("\r\n"); + } + tdata->hours = (tdata->hours + (ampm*12)) % 24 ; +} +} + +tdata->min=100; +while( (tdata->min < 0) || (tdata->min > 59)) +{ +pc.printf("Enter the minute as 0-59: "); +pc.scanf("%i",&tdata->min); +pc.printf("\r\n"); +} + +tdata->sec=100; +while( (tdata->sec < 0) || (tdata->sec > 59)) +{ +pc.printf("Enter the second as 0-59: "); +pc.scanf("%i",&tdata->sec); +pc.printf("\r\n"); +} + +} + +void set_DS1307_time(DS1307_DATA *tdata) +{ + +if(0!=EE3420_DS1307.twentyfour_hour()) +{ + pc.printf("Failed to set 24-hour mode on DS1307.\r\n"); + exit(-1); +} + +if(0!=EE3420_DS1307.settime( tdata->sec, tdata->min, tdata->hours, tdata->day, tdata->date, tdata->month, tdata->year)) +{ + pc.printf("Failed to set time on DS1307.\r\n"); + exit(-1); +} + +} + +void get_DS1307_time(DS1307_DATA *tdata) +{ +if(0!=EE3420_DS1307.gettime( &tdata->sec, &tdata->min, &tdata->hours, &tdata->day, &tdata->date, &tdata->month, &tdata->year)) +{ + pc.printf("Unable to read DS1307 time\r\n"); + exit(-1); +} +} + +void set_KL46Z_RTC_from_DS1307() +{ +get_DS1307_time(&EE3420_DS1307_data); +time(&EE3420_time); +EE3420_timeinfo = localtime ( &EE3420_time ); +EE3420_timeinfo->tm_sec=EE3420_DS1307_data.sec; +EE3420_timeinfo->tm_min=EE3420_DS1307_data.min; +EE3420_timeinfo->tm_hour=EE3420_DS1307_data.hours; +EE3420_timeinfo->tm_mday=EE3420_DS1307_data.date; +EE3420_timeinfo->tm_mon=(EE3420_DS1307_data.month)-1; +EE3420_timeinfo->tm_year=(EE3420_DS1307_data.year)+100; +EE3420_timeinfo->tm_wday=(EE3420_DS1307_data.day)-1; +//timeinfo->tm_isdst=-1; +EE3420_time=mktime(EE3420_timeinfo); +set_time(EE3420_time); + +} + + + #endif /* EE3420_TIME_H */ + + + + + +
diff -r 000000000000 -r f6d3b930f382 Freedom_headers.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Freedom_headers.h Sat Dec 10 21:08:30 2016 +0000 @@ -0,0 +1,456 @@ +#ifndef FREEDOM__HEADERS_H +#define FREEDOM__HEADERS_H + +#include "mbed.h" + +/* +The USB connections are on this end of the board + + J2_19 OO J2_20 + J2_17 OO J2_18 + J2_15 OO J2_16 + J2_13 OO J2_14 +J3_2 OO J3_1 J2_11 OO J2_12 +J3_4 OO J3_3 J2_9 OO J2_10 +J3_6 OO J3_5 J2_7 OO J2_8 +J3_8 OO J3_7 J2_5 OO J2_6 +J3_10 OO J3_9 J2_3 OO J2_4 +J3_12 OO J3_11 J2_1 OO J2_2 +J3_14 OO J3_13 +J3_16 OO J3_15 J1_15 OO J1_16 + J1_13 OO J1_14 +J4_2 OO J4_1 J1_11 OO J1_12 +J4_4 OO J4_3 J1_9 OO J1_10 +J4_6 OO J4_5 J1_7 OO J1_8 +J4_8 OO J4_7 J1_5 OO J1_6 +J4_10 OO J4_9 J1_3 OO J1_4 +J4_12 OO J4_11 J1_1 OO J1_2 + +*/ + +#if defined (TARGET_KL46Z) +PinName const J1_1 = PTB18 ; +PinName const J1_2 = PTA1 ; +PinName const J1_3 = PTB19 ; +PinName const J1_4 = PTA2 ; +PinName const J1_5 = PTC0 ; +PinName const J1_6 = PTD3 ; +PinName const J1_7 = PTC4 ; +PinName const J1_8 = PTA12 ; +PinName const J1_9 = PTC6 ; +PinName const J1_10 = PTA4 ; +PinName const J1_11 = PTC7 ; +PinName const J1_12 = PTA5 ; +PinName const J1_13 = PTC10 ; +PinName const J1_14 = PTC8 ; +PinName const J1_15 = PTC11 ; +PinName const J1_16 = PTC9 ; + +PinName const J2_1 = PTC13 ; +PinName const J2_2 = PTA13 ; +PinName const J2_3 = PTC16 ; +PinName const J2_4 = PTD2 ; +PinName const J2_5 = PTA7 ; +PinName const J2_6 = PTD4 ; +PinName const J2_7 = PTA6 ; +PinName const J2_8 = PTD6 ; +PinName const J2_9 = PTA14 ; +PinName const J2_10 = PTD7 ; +PinName const J2_11 = PTA15 ; +PinName const J2_12 = PTD5 ; +PinName const J2_13 = PTA16 ; +PinName const J2_14 = NC ; //GND +PinName const J2_15 = PTA17 ; +PinName const J2_16 = NC ; //AREF +PinName const J2_17 = PTB9 ; +PinName const J2_18 = PTE0 ; +PinName const J2_19 = NC ; //NC +PinName const J2_20 = PTE1 ; + +PinName const J3_1 = PTE31 ; +PinName const J3_2 = NC ; //SDA_PTD5 +PinName const J3_3 = PTE19 ; +PinName const J3_4 = NC ; //3.3V +PinName const J3_5 = PTE18 ; +PinName const J3_6 = PTA20 ; //RESET +PinName const J3_7 = PTE17 ; +PinName const J3_8 = NC ; //3.3V +PinName const J3_9 = PTE16 ; +PinName const J3_10 = NC ; //5V +PinName const J3_11 = PTE6 ; +PinName const J3_12 = NC ; //GND +PinName const J3_13 = PTE3 ; +PinName const J3_14 = NC ; //GND +PinName const J3_15 = PTE2 ; +PinName const J3_16 = NC ; //VIN + +PinName const J4_1 = PTE20 ; +PinName const J4_2 = PTB0 ; +PinName const J4_3 = PTE21 ; +PinName const J4_4 = PTB1 ; +PinName const J4_5 = PTE22 ; +PinName const J4_6 = PTB2 ; +PinName const J4_7 = PTE23 ; +PinName const J4_8 = PTB3 ; +PinName const J4_9 = PTB20 ; +PinName const J4_10 = PTC2 ; +PinName const J4_11 = PTE30 ; +PinName const J4_12 = PTC1 ; + + +#elif defined (TARGET_KL25Z) + +PinName const J1_1 = PTC7 ; +PinName const J1_2 = PTA1 ; //? +PinName const J1_3 = PTBC0 ; +PinName const J1_4 = PTA2 ; //? +PinName const J1_5 = PTC3 ; +PinName const J1_6 = PTD4 ; +PinName const J1_7 = PTC4 ; +PinName const J1_8 = PTA12 ; +PinName const J1_9 = PTC5 ; +PinName const J1_10 = PTA4 ; +PinName const J1_11 = PTC6 ; +PinName const J1_12 = PTA5 ; +PinName const J1_13 = PTC10 ; +PinName const J1_14 = PTC8 ; +PinName const J1_15 = PTC11 ; +PinName const J1_16 = PTC9 ; + +PinName const J2_1 = PTC12 ; +PinName const J2_2 = PTA13 ; +PinName const J2_3 = PTC13 ; +PinName const J2_4 = PTD5 ; +PinName const J2_5 = PTC16 ; +PinName const J2_6 = PTD0 ; +PinName const J2_7 = PTC17 ; +PinName const J2_8 = PTD2 ; +PinName const J2_9 = PTA16 ; +PinName const J2_10 = PTD3 ; +PinName const J2_11 = PTA17 ; +PinName const J2_12 = PTD1 ; +PinName const J2_13 = PTE31 ; +PinName const J2_14 = NC ; //GND +PinName const J2_15 = NC ; //NC +PinName const J2_16 = NC ; //AREF +PinName const J2_17 = PTD6 ; +PinName const J2_18 = PTE0 ; +PinName const J2_19 = PTD7 ; +PinName const J2_20 = PTE1 ; + +PinName const J3_1 = PTB8 ; +PinName const J3_2 = NC ; //SDA_PTD5 +PinName const J3_3 = PTB9 ; +PinName const J3_4 = NC ; //3.3V +PinName const J3_5 = PTB10 ; +PinName const J3_6 = PTA20 ; //RESET +PinName const J3_7 = PTB11 ; +PinName const J3_8 = NC ; //3.3V +PinName const J3_9 = PTE2 ; +PinName const J3_10 = NC ; //5V +PinName const J3_11 = PTE3 ; +PinName const J3_12 = NC ; //GND +PinName const J3_13 = PTE4 ; +PinName const J3_14 = NC ; //GND +PinName const J3_15 = PTE5 ; +PinName const J3_16 = NC ; //VIN + +PinName const J4_1 = PTE20 ; +PinName const J4_2 = PTB0 ; +PinName const J4_3 = PTE21 ; +PinName const J4_4 = PTB1 ; +PinName const J4_5 = PTE22 ; +PinName const J4_6 = PTB2 ; +PinName const J4_7 = PTE23 ; +PinName const J4_8 = PTB3 ; +PinName const J4_9 = PTE29 ; +PinName const J4_10 = PTC2 ; +PinName const J4_11 = PTE30 ; +PinName const J4_12 = PTC1 ; + +#elif defined (TARGET_KL05Z) + +PinName const J1_1 = NC ; +PinName const J1_2 = PTB2 ; //? +PinName const J1_3 = NC ; +PinName const J1_4 = PTB1 ; //? +PinName const J1_5 = NC ; +PinName const J1_6 = PTA11 ; +PinName const J1_7 = NC ; +PinName const J1_8 = PTB5 ; +PinName const J1_9 = NC ; +PinName const J1_10 = PTA10 ; +PinName const J1_11 = NC ; +PinName const J1_12 = PTA12 ; +PinName const J1_13 = NC ; +PinName const J1_14 = PTB6 ; +PinName const J1_15 = NC ; +PinName const J1_16 = PTB7 ; + +PinName const J2_1 = NC ; +PinName const J2_2 = PTB10 ; +PinName const J2_3 = NC ; +PinName const J2_4 = PTB11 ; +PinName const J2_5 = NC ; +PinName const J2_6 = PTA5 ; +PinName const J2_7 = NC ; +PinName const J2_8 = PTA7 ; +PinName const J2_9 = NC ; +PinName const J2_10 = PTA6 ; +PinName const J2_11 = NC ; +PinName const J2_12 = PTB0 ; +PinName const J2_13 = NC ; +PinName const J2_14 = NC ; //GND +PinName const J2_15 = NC ; //NC +PinName const J2_16 = NC ; //AREF +PinName const J2_17 = NC ; +PinName const J2_18 = PTB4 ; +PinName const J2_19 = NC ; +PinName const J2_20 = PTB3 ; + +PinName const J3_1 = NC ; +PinName const J3_2 = NC ; //SDA_PTD5 +PinName const J3_3 = NC ; +PinName const J3_4 = NC ; //3.3V +PinName const J3_5 = NC ; +PinName const J3_6 = NC ; //RESET +PinName const J3_7 = NC ; +PinName const J3_8 = NC ; //3.3V +PinName const J3_9 = NC ; +PinName const J3_10 = NC ; //5V +PinName const J3_11 = NC ; +PinName const J3_12 = NC ; //GND +PinName const J3_13 = NC ; +PinName const J3_14 = NC ; //GND +PinName const J3_15 = NC ; +PinName const J3_16 = NC ; //VIN + +PinName const J4_1 = NC ; +PinName const J4_2 = PTB8 ; +PinName const J4_3 = NC ; +PinName const J4_4 = PTB9 ; +PinName const J4_5 = NC ; +PinName const J4_6 = PTA8 ; +PinName const J4_7 = NC ; +PinName const J4_8 = PTA0 ; +PinName const J4_9 = NC ; +PinName const J4_10 = PTA9 ; +PinName const J4_11 = NC ; +PinName const J4_12 = PTB13 ; + +#elif defined (TARGET_K22F) + +PinName const J1_1 = PTA5 ; +PinName const J1_2 = PTD2 ; //? +PinName const J1_3 = PTA13 ; +PinName const J1_4 = PTD3 ; //? +PinName const J1_5 = PTA12 ; +PinName const J1_6 = PTB16 ; +PinName const J1_7 = PTC8 ; +PinName const J1_8 = PTA2 ; +PinName const J1_9 = PTC9 ; +PinName const J1_10 = PTA4 ; +PinName const J1_11 = PTC7 ; +PinName const J1_12 = PTB10 ; +PinName const J1_13 = PTC10 ; +PinName const J1_14 = PTC3 ; +PinName const J1_15 = PTC5 ; +PinName const J1_16 = PTC6 ; + +PinName const J2_1 = NC ; +PinName const J2_2 = PTB19 ; +PinName const J2_3 = NC ; +PinName const J2_4 = PTA1 ; +PinName const J2_5 = PTC0 ; +PinName const J2_6 = PTD4 ; +PinName const J2_7 = PTC11 ; +PinName const J2_8 = PTD6 ; +PinName const J2_9 = NC ; +PinName const J2_10 = PTD7 ; +PinName const J2_11 = NC ; +PinName const J2_12 = PTD5 ; +PinName const J2_13 = NC ; +PinName const J2_14 = NC ; //GND +PinName const J2_15 = NC ; //NC +PinName const J2_16 = NC ; //AREF +PinName const J2_17 = NC ; +PinName const J2_18 = PTE0 ; +PinName const J2_19 = NC ; +PinName const J2_20 = PTE1 ; + +PinName const J3_1 = NC ; +PinName const J3_2 = NC ; //SDA_PTD5 +PinName const J3_3 = NC ; +PinName const J3_4 = NC ; //3.3V +PinName const J3_5 = NC ; +PinName const J3_6 = NC ; //RESET +PinName const J3_7 = NC ; +PinName const J3_8 = NC ; //3.3V +PinName const J3_9 = NC ; +PinName const J3_10 = NC ; //5V +PinName const J3_11 = NC ; +PinName const J3_12 = NC ; //GND +PinName const J3_13 = NC ; +PinName const J3_14 = NC ; //GND +PinName const J3_15 = NC ; +PinName const J3_16 = NC ; //VIN + +PinName const J4_1 = NC ; //ADC0_DP0 +PinName const J4_2 = PTB0 ; +PinName const J4_3 = NC ; //ADC0_DM0 +PinName const J4_4 = PTB1 ; +PinName const J4_5 = NC ; //ADC0_DP3 +PinName const J4_6 = PTC1 ; +PinName const J4_7 = NC ; //ADC0_DM3 +PinName const J4_8 = PTC2 ; +PinName const J4_9 = PTC4 ; +PinName const J4_10 = PTB3 ; +PinName const J4_11 = NC ; //DAC0_OUT +PinName const J4_12 = PTB2 ; + +#elif defined (TARGET_K20D50M) + +PinName const J1_1 = PTD0 ; +PinName const J1_2 = PTE1 ; //? +PinName const J1_3 = PTC11 ; +PinName const J1_4 = PTE0 ; //? +PinName const J1_5 = PTC5 ; +PinName const J1_6 = PTA5 ; +PinName const J1_7 = PTC6 ; +PinName const J1_8 = PTD4 ; +PinName const J1_9 = PTC7 ; +PinName const J1_10 = PTC8 ; +PinName const J1_11 = PTA4 ; +PinName const J1_12 = PTA1 ; +PinName const J1_13 = PTD7 ; +PinName const J1_14 = PTC3 ; +PinName const J1_15 = PTC9 ; +PinName const J1_16 = PTC4 ; + +PinName const J2_1 = PTC13 ; +PinName const J2_2 = PTA12 ; +PinName const J2_3 = PTC10 ; +PinName const J2_4 = PTA2 ; +PinName const J2_5 = NC ; +PinName const J2_6 = PTC2 ; +PinName const J2_7 = NC ; +PinName const J2_8 = PTD2 ; +PinName const J2_9 = NC ; +PinName const J2_10 = PTD3 ; +PinName const J2_11 = NC ; +PinName const J2_12 = PTD1 ; +PinName const J2_13 = NC ; +PinName const J2_14 = NC ; //GND +PinName const J2_15 = NC ; //NC +PinName const J2_16 = NC ; //AREF +PinName const J2_17 = NC ; +PinName const J2_18 = PTB3 ; +PinName const J2_19 = NC ; +PinName const J2_20 = PTB2 ; + +PinName const J3_1 = NC ; +PinName const J3_2 = NC ; //SDA_PTD5 +PinName const J3_3 = NC ; +PinName const J3_4 = NC ; //3.3V +PinName const J3_5 = NC ; +PinName const J3_6 = NC ; //RESET +PinName const J3_7 = NC ; +PinName const J3_8 = NC ; //3.3V +PinName const J3_9 = NC ; +PinName const J3_10 = NC ; //5V +PinName const J3_11 = NC ; +PinName const J3_12 = NC ; //GND +PinName const J3_13 = NC ; +PinName const J3_14 = NC ; //GND +PinName const J3_15 = NC ; +PinName const J3_16 = NC ; //VIN + +PinName const J4_1 = NC ; //CMP1_IN5 +PinName const J4_2 = PTC0 ; +PinName const J4_3 = NC ; //CMP1_IN3 +PinName const J4_4 = PTC1 ; +PinName const J4_5 = NC ; //ADC0_DP3 +PinName const J4_6 = PTD6 ; +PinName const J4_7 = NC ; //ADC0_DM3 +PinName const J4_8 = PTD5 ; +PinName const J4_9 = NC ; //ADC0_DP0 +PinName const J4_10 = PTB1 ; +PinName const J4_11 = NC ; //ADC0_DM0; +PinName const J4_12 = PTB0 ; + +#elif defined (TARGET_K64F) + +PinName const J1_1 = PTB10 ; +PinName const J1_2 = PTC16 ; //? +PinName const J1_3 = PTB19 ; +PinName const J1_4 = PTC17 ; //? +PinName const J1_5 = PTC1 ; +PinName const J1_6 = PTB9 ; +PinName const J1_7 = PTC8 ; +PinName const J1_8 = PTA1 ; +PinName const J1_9 = PTC9 ; +PinName const J1_10 = PTB23 ; +PinName const J1_11 = PTC0 ; +PinName const J1_12 = PTA2 ; +PinName const J1_13 = PTC7 ; +PinName const J1_14 = PTC2 ; +PinName const J1_15 = PTC5 ; +PinName const J1_16 = PTC3 ; + +PinName const J2_1 = PTE26 ; +PinName const J2_2 = PTA0 ; +PinName const J2_3 = NC ; +PinName const J2_4 = PTC4 ; +PinName const J2_5 = NC ; //ADC0_DP0 +PinName const J2_6 = PTD0 ; +PinName const J2_7 = NC ; //ADC0_DM0 +PinName const J2_8 = PTD2 ; +PinName const J2_9 = NC ; +PinName const J2_10 = PTD3 ; +PinName const J2_11 = NC ; //ADC1_DP0 +PinName const J2_12 = PTD1 ; +PinName const J2_13 = NC ; //ADC1_DM0 +PinName const J2_14 = NC ; //GND +PinName const J2_15 = NC ; //NC +PinName const J2_16 = NC ; //AREF +PinName const J2_17 = NC ; //ADC1_SE18 +PinName const J2_18 = PTE25 ; +PinName const J2_19 = NC ; +PinName const J2_20 = PTE24 ; + +PinName const J3_1 = NC ; +PinName const J3_2 = NC ; //SDA_PTD5 +PinName const J3_3 = NC ; +PinName const J3_4 = NC ; //3.3V +PinName const J3_5 = NC ; +PinName const J3_6 = NC ; //RESET +PinName const J3_7 = NC ; +PinName const J3_8 = NC ; //3.3V +PinName const J3_9 = NC ; +PinName const J3_10 = NC ; //5V +PinName const J3_11 = NC ; +PinName const J3_12 = NC ; //GND +PinName const J3_13 = NC ; +PinName const J3_14 = NC ; //GND +PinName const J3_15 = NC ; +PinName const J3_16 = NC ; //VIN + +PinName const J4_1 = NC ; //ADC0_DP1 +PinName const J4_2 = PTB2 ; +PinName const J4_3 = NC ; //ADCO_DM1 +PinName const J4_4 = PTB3 ; +PinName const J4_5 = NC ; //ADC1_DP1 +PinName const J4_6 = PTB10 ; +PinName const J4_7 = NC ; //ADC1_DM1 +PinName const J4_8 = PTB11 ; +PinName const J4_9 = PTB20 ; +PinName const J4_10 = PTC11 ; +PinName const J4_11 = NC ; //DAC0_OUT +PinName const J4_12 = PTC10 ; + +#else + #error TARGET NOT DEFINED +#endif + + +#endif // FREEDOM__HEADERS_H
diff -r 000000000000 -r f6d3b930f382 SDFileSystem.lib --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/SDFileSystem.lib Sat Dec 10 21:08:30 2016 +0000 @@ -0,0 +1,1 @@ +http://developer.mbed.org/users/mbed_official/code/SDFileSystem/#7b35d1709458
diff -r 000000000000 -r f6d3b930f382 mbed.bld --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mbed.bld Sat Dec 10 21:08:30 2016 +0000 @@ -0,0 +1,1 @@ +http://mbed.org/users/mbed_official/code/mbed/builds/99a22ba036c9 \ No newline at end of file
diff -r 000000000000 -r f6d3b930f382 simple_fifo.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/simple_fifo.h Sat Dec 10 21:08:30 2016 +0000 @@ -0,0 +1,808 @@ +#ifndef SIMPLE_FIFO_H +#define SIMPLE_FIFO_H + +/* +SIMPLE_FIFO was designed as an example of a FIFO construct using "char" data. +The defined type structure called SIMPLE_FIFO uses an array of type "char" and +two integer pointers "write_pointer" and "read_pointer" to form a circuular buffer. +The number of elements in the circular buffer is defined by SIMPLE_FIFO_SIZE. + +The following functions are defined for the SIMPLE_FIFO type: +void simple_fifo_init(SIMPLE_FIFO *f) +int simple_fifo_writeable(SIMPLE_FIFO *f) +int simple_fifo_readable(SIMPLE_FIFO *f) +int simple_fifo_write(SIMPLE_FIFO *f, char c) +int simple_fifo_read(SIMPLE_FIFO *f, char *c) +char simple_fifo_putc(SIMPLE_FIFO *f, char c) +char simple_fifo_getc(SIMPLE_FIFO *f, char *c) +void simple_fifo_puts(SIMPLE_FIFO *f, char str[]) +void simple_fifo_gets(SIMPLE_FIFO *f, char str[], int count) + +The function simple_fifo_init initializes both pointers to 0 and initializes all data in the fifo to 0. +The function simple_fifo_writeable returns true if space is available in the fifo and returns false if the fifo is full. +The function simple_fifo_readable returns true if data is available in the fifo and returns false if the fifo is empty. +The function simple_fifo_write returns true if if data was successfully written to the fifo and returns false if the fifo is full. +The function simple_fifo_read returns true if if data was successfully read from the fifo and returns false if the fifo is empty. +The function simple_fifo_putc blocks until the fifo is writeable then writes a single character to the fifo. The return value is the character written. +The function simple_fifo_getc blocks until the fifo is readable then reads a single character from the fifo. The return value is the character read. +The function simple_fifo_puts blocks until the fifo is writeable then writes a single character to the fifo. This is repeated until all characters in the null-terminated string out written to the fifo. +The function simple_fifo_getc blocks until the fifo is readable then reads a single character from the fifo. This is repeated until the carriage return character is encountered. The resulting string is returned as null-terminated without the carriage return caracter included. +*/ + +#ifndef TRUE +#define TRUE ( 1 == 1 ) +#endif + +#ifndef FALSE +#define FALSE ( 1 == 0 ) +#endif + +#ifndef SIMPLE_FIFO_SIZE +#define SIMPLE_FIFO_SIZE 16 +#endif + +#ifndef SIMPLE_FIFO +typedef struct simple_fifo +{ +char buffer[SIMPLE_FIFO_SIZE]; +int write_pointer; +int read_pointer; +} SIMPLE_FIFO; +#endif + +void simple_fifo_init(SIMPLE_FIFO *f) +{ + f->write_pointer=0; + f->read_pointer=0; + for(int i=0; i<SIMPLE_FIFO_SIZE; i++) + { + f->buffer[i]=0; + } +} + +int simple_fifo_writeable(SIMPLE_FIFO *f) +{ + if(((f->write_pointer+1)% SIMPLE_FIFO_SIZE) == f->read_pointer) + { + return(FALSE); /* buffer full, can't write */ + } + return(TRUE); +} + +int simple_fifo_readable(SIMPLE_FIFO *f) +{ + if(f->read_pointer == f->write_pointer) + { + return(FALSE); /* buffer empty, can't read */ + } + return(TRUE); +} + +int simple_fifo_write(SIMPLE_FIFO *f, char c) +{ + if(((f->write_pointer+1)% SIMPLE_FIFO_SIZE) == f->read_pointer) + { + return(FALSE); /* buffer full, can't write */ + } + f->buffer[f->write_pointer] = c; + f->write_pointer = (f->write_pointer+1)% SIMPLE_FIFO_SIZE; + return(TRUE); +} + +int simple_fifo_read(SIMPLE_FIFO *f, char *c) +{ + if(f->read_pointer == f->write_pointer) + { + return(FALSE); /* buffer empty, can't read */ + } + *c = f->buffer[f->read_pointer]; + f->read_pointer = (f->read_pointer+1)% SIMPLE_FIFO_SIZE; + return(TRUE); +} + +char simple_fifo_putc(SIMPLE_FIFO *f, char c) +{ + while(!simple_fifo_writeable(f)) {} + simple_fifo_write(f, c); + return(c); +} + +char simple_fifo_getc(SIMPLE_FIFO *f, char *c) +{ + while(!simple_fifo_readable(f)) {} + simple_fifo_read(f, c); + return(*c); + +} + +void simple_fifo_puts(SIMPLE_FIFO *f, char str[]) +{ + for(int i=0; str[i]!='\0';i++) + { + simple_fifo_putc(f, str[i]); + } +} + +void simple_fifo_gets(SIMPLE_FIFO *f, char str[], int count) +{ + for(int i=0; i<count; i++) + { + simple_fifo_getc(f, &str[i]); + if(str[i] == '\r' || str[i] == '\n') + { + str[i]='\0'; + break; + } + } + str[count-1]='\0'; +} + +/* +In addition to the SIMPLE_FIFO type, a number of similar fifo types are constructed for various data types. +The following fifo types are defined: +FIFO_CHAR //for character data, similar to SIMPLE_FIFO above +FIFO_INT //for default integer type +FIFO_U8 //for uint8_t data +FIFO_U16 //for uint16_t data +FIFO_U32 //for uint32_t data +FIFO_I8 //for int8_t data +FIFO_I16 //for int16_t data +FIFO_I32 //for int32_t data +FIFO_FLOAT //for float data +FIFO_DOUBLE //for double data + +The following functions are defined for the FIFO_?? types: +void fifo_??_init(FIFO_?? *f) +int fifo_??_writeable(FIFO_?? *f) +int fifo_??_readable(FIFO_?? *f) +int fifo_??_write(FIFO_?? *f, char c) +int fifo_??_read(FIFO_?? *f, char *c) + +The function fifo_??_init initializes both pointers to 0 and initializes all data in the fifo to 0. +The function fifo_??_writeable returns true if space is available in the fifo and returns false if the fifo is full. +The function fifo_??_readable returns true if data is available in the fifo and returns false if the fifo is empty. +The function fifo_??_write returns true if if data was successfully written to the fifo and returns false if the fifo is full. +The function sfifo_??_read returns true if if data was successfully read from the fifo and returns false if the fifo is empty. +*/ + +#include <stdint.h> + + +#ifndef FIFO_CHAR +typedef struct fifo_char +{ +char buffer[SIMPLE_FIFO_SIZE]; +int write_pointer; +int read_pointer; +} FIFO_CHAR; +#endif + +void fifo_char_init(FIFO_CHAR *f) +{ + f->write_pointer=0; + f->read_pointer=0; + for(int i=0; i<SIMPLE_FIFO_SIZE; i++) + { + f->buffer[i]=0; + } +} + +int fifo_char_writeable(FIFO_CHAR *f) +{ + if(((f->write_pointer+1)% SIMPLE_FIFO_SIZE) == f->read_pointer) + { + return(FALSE); /* buffer full, can't write */ + } + return(TRUE); +} + +int fifo_char_readable(FIFO_CHAR *f) +{ + if(f->read_pointer == f->write_pointer) + { + return(FALSE); /* buffer empty, can't read */ + } + return(TRUE); +} + +int fifo_char_write(FIFO_CHAR *f, char c) +{ + if(((f->write_pointer+1)% SIMPLE_FIFO_SIZE) == f->read_pointer) + { + return(FALSE); /* buffer full, can't write */ + } + f->buffer[f->write_pointer] = c; + f->write_pointer = (f->write_pointer+1)% SIMPLE_FIFO_SIZE; + return(TRUE); +} + +int fifo_char_read(FIFO_CHAR *f, char *c) +{ + if(f->read_pointer == f->write_pointer) + { + return(FALSE); /* buffer empty, can't read */ + } + *c = f->buffer[f->read_pointer]; + f->read_pointer = (f->read_pointer+1)% SIMPLE_FIFO_SIZE; + return(TRUE); +} + +char fifo_char_putc(FIFO_CHAR *f, char c) +{ + while(!fifo_char_writeable(f)) {} + fifo_char_write(f, c); + return(c); +} + +char fifo_char_getc(FIFO_CHAR *f, char *c) +{ + while(!fifo_char_readable(f)) {} + fifo_char_read(f, c); + return(*c); + +} + +void fifo_char_puts(FIFO_CHAR *f, char str[]) +{ + for(int i=0; str[i]!='\0';i++) + { + fifo_char_putc(f, str[i]); + } +} + +void fifo_char_gets(FIFO_CHAR *f, char str[], int count) +{ + for(int i=0; i<count; i++) + { + fifo_char_getc(f, &str[i]); + if(str[i] == '\r' || str[i] == '\n') + { + str[i]='\0'; + break; + } + } + str[count-1]='\0'; +} + + + +#ifndef FIFO_INT +typedef struct fifo_int +{ +int buffer[SIMPLE_FIFO_SIZE]; +int write_pointer; +int read_pointer; +} FIFO_INT; +#endif + +void fifo_int_init(FIFO_INT *f) +{ + f->write_pointer=0; + f->read_pointer=0; + for(int i=0; i<SIMPLE_FIFO_SIZE; i++) + { + f->buffer[i]=0; + } +} + +int fifo_int_writeable(FIFO_INT *f) +{ + if(((f->write_pointer+1)% SIMPLE_FIFO_SIZE) == f->read_pointer) + { + return(FALSE); /* buffer full, can't write */ + } + return(TRUE); +} + +int fifo_int_readable(FIFO_INT *f) +{ + if(f->read_pointer == f->write_pointer) + { + return(FALSE); /* buffer empty, can't read */ + } + return(TRUE); +} + +int fifo_int_write(FIFO_INT *f, int c) +{ + if(((f->write_pointer+1)% SIMPLE_FIFO_SIZE) == f->read_pointer) + { + return(FALSE); /* buffer full, can't write */ + } + f->buffer[f->write_pointer] = c; + f->write_pointer = (f->write_pointer+1)% SIMPLE_FIFO_SIZE; + return(TRUE); +} + +int fifo_int_read(FIFO_INT *f, int *c) +{ + if(f->read_pointer == f->write_pointer) + { + return(FALSE); /* buffer empty, can't read */ + } + *c = f->buffer[f->read_pointer]; + f->read_pointer = (f->read_pointer+1)% SIMPLE_FIFO_SIZE; + return(TRUE); +} + +#ifndef FIFO_U8 +typedef struct fifo_u8 +{ +uint8_t buffer[SIMPLE_FIFO_SIZE]; +int write_pointer; +int read_pointer; +} FIFO_U8; +#endif + +void fifo_u8_init(FIFO_U8 *f) +{ + f->write_pointer=0; + f->read_pointer=0; + for(int i=0; i<SIMPLE_FIFO_SIZE; i++) + { + f->buffer[i]=0; + } +} + +int fifo_u8_writeable(FIFO_U8 *f) +{ + if(((f->write_pointer+1)% SIMPLE_FIFO_SIZE) == f->read_pointer) + { + return(FALSE); /* buffer full, can't write */ + } + return(TRUE); +} + +int fifo_u8_readable(FIFO_U8 *f) +{ + if(f->read_pointer == f->write_pointer) + { + return(FALSE); /* buffer empty, can't read */ + } + return(TRUE); +} + +int fifo_u8_write(FIFO_U8 *f, uint8_t c) +{ + if(((f->write_pointer+1)% SIMPLE_FIFO_SIZE) == f->read_pointer) + { + return(FALSE); /* buffer full, can't write */ + } + f->buffer[f->write_pointer] = c; + f->write_pointer = (f->write_pointer+1)% SIMPLE_FIFO_SIZE; + return(TRUE); +} + +int fifo_u8_read(FIFO_U8 *f, uint8_t *c) +{ + if(f->read_pointer == f->write_pointer) + { + return(FALSE); /* buffer empty, can't read */ + } + *c = f->buffer[f->read_pointer]; + f->read_pointer = (f->read_pointer+1)% SIMPLE_FIFO_SIZE; + return(TRUE); +} + +#ifndef FIFO_U16 +typedef struct fifo_u16 +{ +uint16_t buffer[SIMPLE_FIFO_SIZE]; +int write_pointer; +int read_pointer; +} FIFO_U16; +#endif + +void fifo_u16_init(FIFO_U16 *f) +{ + f->write_pointer=0; + f->read_pointer=0; + for(int i=0; i<SIMPLE_FIFO_SIZE; i++) + { + f->buffer[i]=0; + } +} + +int fifo_u16_writeable(FIFO_U16 *f) +{ + if(((f->write_pointer+1)% SIMPLE_FIFO_SIZE) == f->read_pointer) + { + return(FALSE); /* buffer full, can't write */ + } + return(TRUE); +} + +int fifo_u16_readable(FIFO_U16 *f) +{ + if(f->read_pointer == f->write_pointer) + { + return(FALSE); /* buffer empty, can't read */ + } + return(TRUE); +} + +int fifo_u16_write(FIFO_U16 *f, uint16_t c) +{ + if(((f->write_pointer+1)% SIMPLE_FIFO_SIZE) == f->read_pointer) + { + return(FALSE); /* buffer full, can't write */ + } + f->buffer[f->write_pointer] = c; + f->write_pointer = (f->write_pointer+1)% SIMPLE_FIFO_SIZE; + return(TRUE); +} + +int fifo_u16_read(FIFO_U16 *f, uint16_t *c) +{ + if(f->read_pointer == f->write_pointer) + { + return(FALSE); /* buffer empty, can't read */ + } + *c = f->buffer[f->read_pointer]; + f->read_pointer = (f->read_pointer+1)% SIMPLE_FIFO_SIZE; + return(TRUE); +} + +#ifndef FIFO_U32 +typedef struct fifo_u32 +{ +uint32_t buffer[SIMPLE_FIFO_SIZE]; +int write_pointer; +int read_pointer; +} FIFO_U32; +#endif + +void fifo_u32_init(FIFO_U32 *f) +{ + f->write_pointer=0; + f->read_pointer=0; + for(int i=0; i<SIMPLE_FIFO_SIZE; i++) + { + f->buffer[i]=0; + } +} + +int fifo_u32_writeable(FIFO_U32 *f) +{ + if(((f->write_pointer+1)% SIMPLE_FIFO_SIZE) == f->read_pointer) + { + return(FALSE); /* buffer full, can't write */ + } + return(TRUE); +} + +int fifo_u32_readable(FIFO_U32 *f) +{ + if(f->read_pointer == f->write_pointer) + { + return(FALSE); /* buffer empty, can't read */ + } + return(TRUE); +} + +int fifo_u32_write(FIFO_U32 *f, uint32_t c) +{ + if(((f->write_pointer+1)% SIMPLE_FIFO_SIZE) == f->read_pointer) + { + return(FALSE); /* buffer full, can't write */ + } + f->buffer[f->write_pointer] = c; + f->write_pointer = (f->write_pointer+1)% SIMPLE_FIFO_SIZE; + return(TRUE); +} + +int fifo_u32_read(FIFO_U32 *f, uint32_t *c) +{ + if(f->read_pointer == f->write_pointer) + { + return(FALSE); /* buffer empty, can't read */ + } + *c = f->buffer[f->read_pointer]; + f->read_pointer = (f->read_pointer+1)% SIMPLE_FIFO_SIZE; + return(TRUE); +} + +#ifndef FIFO_I8 +typedef struct fifo_i8 +{ +int8_t buffer[SIMPLE_FIFO_SIZE]; +int write_pointer; +int read_pointer; +} FIFO_I8; +#endif + +void fifo_i8_init(FIFO_I8 *f) +{ + f->write_pointer=0; + f->read_pointer=0; + for(int i=0; i<SIMPLE_FIFO_SIZE; i++) + { + f->buffer[i]=0; + } +} + +int fifo_i8_writeable(FIFO_I8 *f) +{ + if(((f->write_pointer+1)% SIMPLE_FIFO_SIZE) == f->read_pointer) + { + return(FALSE); /* buffer full, can't write */ + } + return(TRUE); +} + +int fifo_i8_readable(FIFO_I8 *f) +{ + if(f->read_pointer == f->write_pointer) + { + return(FALSE); /* buffer empty, can't read */ + } + return(TRUE); +} + +int fifo_i8_write(FIFO_I8 *f, int8_t c) +{ + if(((f->write_pointer+1)% SIMPLE_FIFO_SIZE) == f->read_pointer) + { + return(FALSE); /* buffer full, can't write */ + } + f->buffer[f->write_pointer] = c; + f->write_pointer = (f->write_pointer+1)% SIMPLE_FIFO_SIZE; + return(TRUE); +} + +int fifo_i8_read(FIFO_I8 *f, int8_t *c) +{ + if(f->read_pointer == f->write_pointer) + { + return(FALSE); /* buffer empty, can't read */ + } + *c = f->buffer[f->read_pointer]; + f->read_pointer = (f->read_pointer+1)% SIMPLE_FIFO_SIZE; + return(TRUE); +} + + +#ifndef FIFO_I16 +typedef struct fifo_i16 +{ +int16_t buffer[SIMPLE_FIFO_SIZE]; +int write_pointer; +int read_pointer; +} FIFO_I16; +#endif + +void fifo_i16_init(FIFO_I16 *f) +{ + f->write_pointer=0; + f->read_pointer=0; + for(int i=0; i<SIMPLE_FIFO_SIZE; i++) + { + f->buffer[i]=0; + } +} + +int fifo_i16_writeable(FIFO_I16 *f) +{ + if(((f->write_pointer+1)% SIMPLE_FIFO_SIZE) == f->read_pointer) + { + return(FALSE); /* buffer full, can't write */ + } + return(TRUE); +} + +int fifo_i16_readable(FIFO_I16 *f) +{ + if(f->read_pointer == f->write_pointer) + { + return(FALSE); /* buffer empty, can't read */ + } + return(TRUE); +} + +int fifo_i16_write(FIFO_I16 *f, int16_t c) +{ + if(((f->write_pointer+1)% SIMPLE_FIFO_SIZE) == f->read_pointer) + { + return(FALSE); /* buffer full, can't write */ + } + f->buffer[f->write_pointer] = c; + f->write_pointer = (f->write_pointer+1)% SIMPLE_FIFO_SIZE; + return(TRUE); +} + +int fifo_i16_read(FIFO_I16 *f, int16_t *c) +{ + if(f->read_pointer == f->write_pointer) + { + return(FALSE); /* buffer empty, can't read */ + } + *c = f->buffer[f->read_pointer]; + f->read_pointer = (f->read_pointer+1)% SIMPLE_FIFO_SIZE; + return(TRUE); +} + +#ifndef FIFO_I32 +typedef struct fifo_i32 +{ +int32_t buffer[SIMPLE_FIFO_SIZE]; +int write_pointer; +int read_pointer; +} FIFO_I32; +#endif + +void fifo_i32_init(FIFO_I32 *f) +{ + f->write_pointer=0; + f->read_pointer=0; + for(int i=0; i<SIMPLE_FIFO_SIZE; i++) + { + f->buffer[i]=0; + } +} + +int fifo_i32_writeable(FIFO_I32 *f) +{ + if(((f->write_pointer+1)% SIMPLE_FIFO_SIZE) == f->read_pointer) + { + return(FALSE); /* buffer full, can't write */ + } + return(TRUE); +} + +int fifo_i32_readable(FIFO_I32 *f) +{ + if(f->read_pointer == f->write_pointer) + { + return(FALSE); /* buffer empty, can't read */ + } + return(TRUE); +} + +int fifo_i32_write(FIFO_I32 *f, int32_t c) +{ + if(((f->write_pointer+1)% SIMPLE_FIFO_SIZE) == f->read_pointer) + { + return(FALSE); /* buffer full, can't write */ + } + f->buffer[f->write_pointer] = c; + f->write_pointer = (f->write_pointer+1)% SIMPLE_FIFO_SIZE; + return(TRUE); +} + +int fifo_i32_read(FIFO_I32 *f, int32_t *c) +{ + if(f->read_pointer == f->write_pointer) + { + return(FALSE); /* buffer empty, can't read */ + } + *c = f->buffer[f->read_pointer]; + f->read_pointer = (f->read_pointer+1)% SIMPLE_FIFO_SIZE; + return(TRUE); +} + + +#ifndef FIFO_FLOAT +typedef struct fifo_float +{ +float buffer[SIMPLE_FIFO_SIZE]; +int write_pointer; +int read_pointer; +} FIFO_FLOAT; +#endif + +void fifo_float_init(FIFO_FLOAT *f) +{ + f->write_pointer=0; + f->read_pointer=0; + for(int i=0; i<SIMPLE_FIFO_SIZE; i++) + { + f->buffer[i]=0; + } +} + +int fifo_float_writeable(FIFO_FLOAT *f) +{ + if(((f->write_pointer+1)% SIMPLE_FIFO_SIZE) == f->read_pointer) + { + return(FALSE); /* buffer full, can't write */ + } + return(TRUE); +} + +int fifo_float_readable(FIFO_FLOAT *f) +{ + if(f->read_pointer == f->write_pointer) + { + return(FALSE); /* buffer empty, can't read */ + } + return(TRUE); +} + +int fifo_float_write(FIFO_FLOAT *f, float c) +{ + if(((f->write_pointer+1)% SIMPLE_FIFO_SIZE) == f->read_pointer) + { + return(FALSE); /* buffer full, can't write */ + } + f->buffer[f->write_pointer] = c; + f->write_pointer = (f->write_pointer+1)% SIMPLE_FIFO_SIZE; + return(TRUE); +} + +int fifo_float_read(FIFO_FLOAT *f, float *c) +{ + if(f->read_pointer == f->write_pointer) + { + return(FALSE); /* buffer empty, can't read */ + } + *c = f->buffer[f->read_pointer]; + f->read_pointer = (f->read_pointer+1)% SIMPLE_FIFO_SIZE; + return(TRUE); +} + + +#ifndef FIFO_DOUBLE +typedef struct fifo_double +{ +double buffer[SIMPLE_FIFO_SIZE]; +int write_pointer; +int read_pointer; +} FIFO_DOUBLE; +#endif + +void fifo_double_init(FIFO_DOUBLE *f) +{ + f->write_pointer=0; + f->read_pointer=0; + for(int i=0; i<SIMPLE_FIFO_SIZE; i++) + { + f->buffer[i]=0; + } +} + +int fifo_double_writeable(FIFO_DOUBLE *f) +{ + if(((f->write_pointer+1)% SIMPLE_FIFO_SIZE) == f->read_pointer) + { + return(FALSE); /* buffer full, can't write */ + } + return(TRUE); +} + +int fifo_double_readable(FIFO_DOUBLE *f) +{ + if(f->read_pointer == f->write_pointer) + { + return(FALSE); /* buffer empty, can't read */ + } + return(TRUE); +} + +int fifo_double_write(FIFO_DOUBLE *f, double c) +{ + if(((f->write_pointer+1)% SIMPLE_FIFO_SIZE) == f->read_pointer) + { + return(FALSE); /* buffer full, can't write */ + } + f->buffer[f->write_pointer] = c; + f->write_pointer = (f->write_pointer+1)% SIMPLE_FIFO_SIZE; + return(TRUE); +} + +int fifo_double_read(FIFO_DOUBLE *f, double *c) +{ + if(f->read_pointer == f->write_pointer) + { + return(FALSE); /* buffer empty, can't read */ + } + *c = f->buffer[f->read_pointer]; + f->read_pointer = (f->read_pointer+1)% SIMPLE_FIFO_SIZE; + return(TRUE); +} + + + + + + +#endif /* #ifndef SIMPLE_FIFO_H */
diff -r 000000000000 -r f6d3b930f382 software_osc.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/software_osc.cpp Sat Dec 10 21:08:30 2016 +0000 @@ -0,0 +1,156 @@ +#include "stdio.h" +#include "stdint.h" +#include "mbed.h" +#include "Freedom_headers.h" + +#define USE_PC TRUE +/* UNCOMMENT THE FOLLOWING LINE TO ENABLE SD CARD FILESYSTEM VIA DEFAULT SPI */ +#define USE_SD_CARD TRUE +/* UNCOMMENT THE FOLLOWING LINE TO ENABLE DS1307 REAL-TIME CLOCK VIA IIC */ +#define USE_DS1307 TRUE +/* UNCOMMENT THE FOLLOWING LINE TO ENABLE SIMPLE FIFO FUNCTIONS */ +#define USE_SIMPLE_FIFO TRUE + +#ifdef USE_PC +Serial pc(USBTX,USBRX); + +#ifdef USE_SD_CARD +#include "SDFileSystem.h" +#define SD_MOSI PTD6 +#define SD_MISO PTD7 +#define SD_SCK PTD5 +#define SD_CS PTD4 +char sd_root_name[]="sd"; +char filename[80]; +SDFileSystem sd(SD_MOSI, SD_MISO, SD_SCK, SD_CS, sd_root_name); /* MOSI,MISO,SCK,CS, "Name of directory structure" */ + +#endif /* #ifdef USE_SD_CARD*/ + +#ifdef USE_DS1307 +#include "EE3420_time.h" + +#endif /* #ifdef USE_DS1307*/ + +#ifdef USE_SIMPLE_FIFO + +/* comment out the folloing definitions to use the library defaults */ +#define SIMPLE_FIFO_SIZE 32 + +#include "simple_fifo.h" + +#endif /* #ifdef USE_SIMPLE_FIFO*/ + +FIFO_FLOAT scope_data; +int samples_active=0; +float voltage_level; +float ftemp; +char timestr[80]; + +int sample_count=0; + +AnalogIn voltage_sensor(PTB0); +InterruptIn left_button(PTC12); /* button labeled SW3, wired active-low needing pull-up */ +Ticker t; +#define SAMPLE_FREQUENCY 5000.0 + +void take_sample() +{ + if(samples_active==1) + { + voltage_level=voltage_sensor.read(); + /*if(fifo_float_writable(&scope_data)) + { + fifo_float_write(&scope_data,voltage_level); + } + else + { + printf("fifo overrun\n"); + samples_active=0; + }*/ + + + sample_count++; + } + if(sample_count>= 2000) + { + samples_active=0; + } +} + +void start_sample() +{ + if(samples_active==0) + { + fifo_float_init(&scope_data); + sample_count=0; + samples_active=1; + } + else + { + samples_active=0; + } + +} + +int main() +{ + +#ifdef USE_PC + pc.baud(115200); /* set serial port speed to 115200 - must be matched in terminal emulator */ +#endif +#ifdef USE_SLCD + slcd.All_Segments(0); +#endif +#ifdef USE_CHARACTER_LCD + character_lcd_initialize(); +#endif + + fifo_float_init(&scope_data); + +#ifdef USE_PC + pc.printf("\n"); +#endif + + get_DS1307_time(&EE3420_DS1307_data); + set_KL46Z_RTC_from_DS1307(); + + sprintf(filename,"/sd/voltage.csv"); + + FILE *fp = fopen(filename, "w"); + if(fp == NULL) + { + error("Could not open file ""%s"" for write\n", filename); + } + fprintf(fp,"date, time, scopes\n"); + fclose(fp); + + samples_active=0; + + left_button.mode(PullUp); + left_button.fall(&start_sample); + + t.attach(&take_sample,1.0/SAMPLE_FREQUENCY); + +while(true) +{ + + if(fifo_float_readable(&scope_data)) + { + + fp = fopen(filename, "a"); + while(fifo_float_readable(&scope_data)) + { + //get_DS1307_time(&EE3420_DS1307_data); + //format_time_string_24(&EE3420_DS1307_data, timestr); + fifo_float_read(&scope_data,&ftemp); + //fprintf(fp, "20%02i/%02i/%02i, %02i:%02i:%02i, %f\n",EE3420_DS1307_data.year,EE3420_DS1307_data.month, + //EE3420_DS1307_data.day,EE3420_DS1307_data.hours,EE3420_DS1307_data.min,EE3420_DS1307_data.sec,ftemp); + fprintf(fp, "%f\n",ftemp); + pc.printf("%f\n",ftemp); + } + fclose(fp); + } +} +} //end of main() + +