Projects/TemperatureDataLogger/TempDataLogger.c

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2010.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6       www.fourwalledcubicle.com
   7 */
   8
   9 /*
  10   Copyright 2010  Dean Camera (dean [at] fourwalledcubicle [dot] com)
  11
  12   Permission to use, copy, modify, distribute, and sell this
  13   software and its documentation for any purpose is hereby granted
  14   without fee, provided that the above copyright notice appear in
  15   all copies and that both that the copyright notice and this
  16   permission notice and warranty disclaimer appear in supporting
  17   documentation, and that the name of the author not be used in
  18   advertising or publicity pertaining to distribution of the
  19   software without specific, written prior permission.
  20
  21   The author disclaim all warranties with regard to this
  22   software, including all implied warranties of merchantability
  23   and fitness.  In no event shall the author be liable for any
  24   special, indirect or consequential damages or any damages
  25   whatsoever resulting from loss of use, data or profits, whether
  26   in an action of contract, negligence or other tortious action,
  27   arising out of or in connection with the use or performance of
  28   this software.
  29 */
  30
  31 /** \file
  32  *
  33  *  Main source file for the TemperatureDataLogger project. This file contains the main tasks of
  34  *  the project and is responsible for the initial application hardware configuration.
  35  */
  36
  37 #include "TempDataLogger.h"
  38
  39 /** LUFA Mass Storage Class driver interface configuration and state information. This structure is
  40  *  passed to all Mass Storage Class driver functions, so that multiple instances of the same class
  41  *  within a device can be differentiated from one another.
  42  */
  43 USB_ClassInfo_MS_Device_t Disk_MS_Interface =
  44         {
  45                 .Config =
  46                         {
  47                                 .InterfaceNumber           = 0,
  48
  49                                 .DataINEndpointNumber      = MASS_STORAGE_IN_EPNUM,
  50                                 .DataINEndpointSize        = MASS_STORAGE_IO_EPSIZE,
  51                                 .DataINEndpointDoubleBank  = false,
  52
  53                                 .DataOUTEndpointNumber     = MASS_STORAGE_OUT_EPNUM,
  54                                 .DataOUTEndpointSize       = MASS_STORAGE_IO_EPSIZE,
  55                                 .DataOUTEndpointDoubleBank = false,
  56
  57                                 .TotalLUNs                 = 1,
  58                         },
  59         };
  60
  61 /** Buffer to hold the previously generated HID report, for comparison purposes inside the HID class driver. */
  62 uint8_t PrevHIDReportBuffer[GENERIC_REPORT_SIZE];
  63
  64 /** LUFA HID Class driver interface configuration and state information. This structure is
  65  *  passed to all HID Class driver functions, so that multiple instances of the same class
  66  *  within a device can be differentiated from one another.
  67  */
  68 USB_ClassInfo_HID_Device_t Generic_HID_Interface =
  69         {
  70                 .Config =
  71                         {
  72                                 .InterfaceNumber              = 1,
  73
  74                                 .ReportINEndpointNumber       = GENERIC_IN_EPNUM,
  75                                 .ReportINEndpointSize         = GENERIC_EPSIZE,
  76                                 .ReportINEndpointDoubleBank   = false,
  77
  78                                 .PrevReportINBuffer           = PrevHIDReportBuffer,
  79                                 .PrevReportINBufferSize       = sizeof(PrevHIDReportBuffer),
  80                         },
  81         };
  82
  83 /** Non-volatile Logging Interval value in EEPROM, stored as a number of 500ms ticks */
  84 uint8_t EEMEM LoggingInterval500MS_EEPROM;
  85
  86 /** SRAM Logging Interval value fetched from EEPROM, stored as a number of 500ms ticks */
  87 uint8_t LoggingInterval500MS_SRAM;
  88
  89 /** Total number of 500ms logging ticks elapsed since the last log value was recorded */
  90 uint16_t CurrentLoggingTicks;
  91
  92 /** FAT Fs structure to hold the internal state of the FAT driver for the dataflash contents. */
  93 FATFS DiskFATState;
  94
  95 /** FAT Fs structure to hold a FAT file handle for the log data write destination. */
  96 FIL TempLogFile;
  97
  98
  99 /** ISR to handle the 500ms ticks for sampling and data logging */
 100 ISR(TIMER1_COMPA_vect, ISR_BLOCK)
 101 {
 102         uint8_t LEDMask = LEDs_GetLEDs();
 103
 104         /* Check to see if the logging interval has expired */
 105         if (CurrentLoggingTicks++ < LoggingInterval500MS_SRAM)
 106           return;
 107
 108         LEDs_SetAllLEDs(LEDMASK_USB_BUSY);
 109
 110         /* Reset log tick counter to prepare for next logging interval */
 111         CurrentLoggingTicks = 0;
 112
 113         if (USB_DeviceState == DEVICE_STATE_Unattached)
 114         {
 115                 uint8_t Day,  Month,  Year;
 116                 uint8_t Hour, Minute, Second;
 117
 118                 DS1307_GetDate(&Day,  &Month,  &Year);
 119                 DS1307_GetTime(&Hour, &Minute, &Second);
 120
 121                 char     LineBuffer[100];
 122                 uint16_t BytesWritten;
 123
 124                 BytesWritten = sprintf(LineBuffer, "%02d/%02d/20%04d, %02d:%02d:%02d, %d Degrees\r\n",
 125                                                            Day, Month, Year, Hour, Minute, Second, Temperature_GetTemperature());
 126
 127                 f_write(&TempLogFile, LineBuffer, BytesWritten, &BytesWritten);
 128                 f_sync(&TempLogFile);
 129         }
 130
 131         LEDs_SetAllLEDs(LEDMask);
 132 }
 133
 134 /** Main program entry point. This routine contains the overall program flow, including initial
 135  *  setup of all components and the main program loop.
 136  */
 137 int main(void)
 138 {
 139         /* Fetch logging interval from EEPROM */
 140         LoggingInterval500MS_SRAM = eeprom_read_byte(&LoggingInterval500MS_EEPROM);
 141
 142         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
 143
 144         SetupHardware();
 145
 146         /* Mount and open the log file on the dataflash FAT partition */
 147         OpenLogFile();
 148
 149         /* Discard the first sample from the temperature sensor, as it is generally incorrect */
 150         uint8_t Dummy = Temperature_GetTemperature();
 151         (void)Dummy;
 152
 153         for (;;)
 154         {
 155                 MS_Device_USBTask(&Disk_MS_Interface);
 156                 HID_Device_USBTask(&Generic_HID_Interface);
 157                 USB_USBTask();
 158         }
 159 }
 160
 161 /** Opens the log file on the Dataflash's FAT formatted partition according to the current date */
 162 void OpenLogFile(void)
 163 {
 164         char LogFileName[12];
 165
 166         /* Get the current date for the filename as "DDMMYY.csv" */
 167         uint8_t Day, Month, Year;
 168         DS1307_GetDate(&Day, &Month, &Year);
 169         sprintf(LogFileName, "%02d%02d%02d.csv", Day, Month, Year);
 170
 171         /* Mount the storage device, open the file */
 172         f_mount(0, &DiskFATState);
 173         f_open(&TempLogFile, LogFileName, FA_OPEN_ALWAYS | FA_WRITE);
 174         f_lseek(&TempLogFile, TempLogFile.fsize);
 175 }
 176
 177 /** Closes the open data log file on the Dataflash's FAT formatted partition */
 178 void CloseLogFile(void)
 179 {
 180         /* Sync any data waiting to be written, unmount the storage device */
 181         f_sync(&TempLogFile);
 182         f_close(&TempLogFile);
 183 }
 184
 185 /** Configures the board hardware and chip peripherals for the demo's functionality. */
 186 void SetupHardware(void)
 187 {
 188         /* Disable watchdog if enabled by bootloader/fuses */
 189         MCUSR &= ~(1 << WDRF);
 190         wdt_disable();
 191
 192         /* Disable clock division */
 193         clock_prescale_set(clock_div_1);
 194
 195         /* Hardware Initialization */
 196         LEDs_Init();
 197         SPI_Init(SPI_SPEED_FCPU_DIV_2 | SPI_SCK_LEAD_FALLING | SPI_SAMPLE_TRAILING | SPI_MODE_MASTER);
 198         ADC_Init(ADC_REFERENCE_AVCC | ADC_FREE_RUNNING | ADC_PRESCALE_128);
 199         Temperature_Init();
 200         Dataflash_Init();
 201         USB_Init();
 202         TWI_Init();
 203
 204         /* 500ms logging interval timer configuration */
 205         OCR1A   = ((F_CPU / 1024) / 2);
 206         TCCR1B  = (1 << WGM12) | (1 << CS12) | (1 << CS10);
 207         TIMSK1  = (1 << OCIE1A);
 208
 209         /* Clear Dataflash sector protections, if enabled */
 210         DataflashManager_ResetDataflashProtections();
 211 }
 212
 213 /** Event handler for the library USB Connection event. */
 214 void EVENT_USB_Device_Connect(void)
 215 {
 216         LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
 217
 218         /* Close the log file so that the host has exclusive filesystem access */
 219         CloseLogFile();
 220 }
 221
 222 /** Event handler for the library USB Disconnection event. */
 223 void EVENT_USB_Device_Disconnect(void)
 224 {
 225         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
 226
 227         /* Mount and open the log file on the dataflash FAT partition */
 228         OpenLogFile();
 229 }
 230
 231 /** Event handler for the library USB Configuration Changed event. */
 232 void EVENT_USB_Device_ConfigurationChanged(void)
 233 {
 234         LEDs_SetAllLEDs(LEDMASK_USB_READY);
 235
 236         if (!(MS_Device_ConfigureEndpoints(&Disk_MS_Interface)))
 237           LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 238
 239         if (!(HID_Device_ConfigureEndpoints(&Generic_HID_Interface)))
 240           LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 241 }
 242
 243 /** Event handler for the library USB Unhandled Control Request event. */
 244 void EVENT_USB_Device_UnhandledControlRequest(void)
 245 {
 246         MS_Device_ProcessControlRequest(&Disk_MS_Interface);
 247         HID_Device_ProcessControlRequest(&Generic_HID_Interface);
 248 }
 249
 250 /** Mass Storage class driver callback function the reception of SCSI commands from the host, which must be processed.
 251  *
 252  *  \param[in] MSInterfaceInfo  Pointer to the Mass Storage class interface configuration structure being referenced
 253  */
 254 bool CALLBACK_MS_Device_SCSICommandReceived(USB_ClassInfo_MS_Device_t* MSInterfaceInfo)
 255 {
 256         bool CommandSuccess;
 257
 258         LEDs_SetAllLEDs(LEDMASK_USB_BUSY);
 259         CommandSuccess = SCSI_DecodeSCSICommand(MSInterfaceInfo);
 260         LEDs_SetAllLEDs(LEDMASK_USB_READY);
 261
 262         return CommandSuccess;
 263 }
 264
 265 /** HID class driver callback function for the creation of HID reports to the host.
 266  *
 267  *  \param[in] HIDInterfaceInfo  Pointer to the HID class interface configuration structure being referenced
 268  *  \param[in,out] ReportID  Report ID requested by the host if non-zero, otherwise callback should set to the generated report ID
 269  *  \param[in] ReportType  Type of the report to create, either REPORT_ITEM_TYPE_In or REPORT_ITEM_TYPE_Feature
 270  *  \param[out] ReportData  Pointer to a buffer where the created report should be stored
 271  *  \param[out] ReportSize  Number of bytes written in the report (or zero if no report is to be sent
 272  *
 273  *  \return Boolean true to force the sending of the report, false to let the library determine if it needs to be sent
 274  */
 275 bool CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, uint8_t* const ReportID,
 276                                          const uint8_t ReportType, void* ReportData, uint16_t* ReportSize)
 277 {
 278         Device_Report_t* ReportParams = (Device_Report_t*)ReportData;
 279
 280         DS1307_GetDate(&ReportParams->Day,  &ReportParams->Month,  &ReportParams->Year);
 281         DS1307_GetTime(&ReportParams->Hour, &ReportParams->Minute, &ReportParams->Second);
 282
 283         ReportParams->LogInterval500MS = LoggingInterval500MS_SRAM;
 284
 285         *ReportSize = sizeof(Device_Report_t);
 286         return true;
 287 }
 288
 289 /** HID class driver callback function for the processing of HID reports from the host.
 290  *
 291  *  \param[in] HIDInterfaceInfo  Pointer to the HID class interface configuration structure being referenced
 292  *  \param[in] ReportID  Report ID of the received report from the host
 293  *  \param[in] ReportData  Pointer to a buffer where the created report has been stored
 294  *  \param[in] ReportSize  Size in bytes of the received HID report
 295  */
 296 void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, const uint8_t ReportID,
 297                                           const void* ReportData, const uint16_t ReportSize)
 298 {
 299         Device_Report_t* ReportParams = (Device_Report_t*)ReportData;
 300
 301         GPIOR0 = ReportParams->Day;
 302         GPIOR1 = ReportParams->Month;
 303         GPIOR2 = ReportParams->Year;
 304
 305         DS1307_SetDate(ReportParams->Day,  ReportParams->Month,  ReportParams->Year);
 306         DS1307_SetTime(ReportParams->Hour, ReportParams->Minute, ReportParams->Second);
 307
 308         /* If the logging interval has changed from its current value, write it to EEPROM */
 309         if (LoggingInterval500MS_SRAM != ReportParams->LogInterval500MS)
 310         {
 311                 LoggingInterval500MS_SRAM = ReportParams->LogInterval500MS;
 312                 eeprom_write_byte(&LoggingInterval500MS_EEPROM, LoggingInterval500MS_SRAM);
 313         }
 314 }