Projects/TempDataLogger/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 = DEFAULT_LOG_INTERVAL;
  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         /* Only log when not connected to a USB host */
 114         if (USB_DeviceState == DEVICE_STATE_Unattached)
 115         {
 116                 uint8_t Day,  Month,  Year;
 117                 uint8_t Hour, Minute, Second;
 118
 119                 DS1307_GetDate(&Day,  &Month,  &Year);
 120                 DS1307_GetTime(&Hour, &Minute, &Second);
 121
 122                 char     LineBuffer[100];
 123                 uint16_t BytesWritten;
 124
 125                 BytesWritten = sprintf(LineBuffer, "%02d/%02d/20%04d, %02d:%02d:%02d, %d Degrees\r\n",
 126                                                            Day, Month, Year, Hour, Minute, Second, Temperature_GetTemperature());
 127
 128                 f_write(&TempLogFile, LineBuffer, BytesWritten, &BytesWritten);
 129                 f_sync(&TempLogFile);
 130         }
 131
 132         LEDs_SetAllLEDs(LEDMask);
 133 }
 134
 135 /** Main program entry point. This routine contains the overall program flow, including initial
 136  *  setup of all components and the main program loop.
 137  */
 138 int main(void)
 139 {
 140         SetupHardware();
 141
 142         /* Fetch logging interval from EEPROM */
 143         LoggingInterval500MS_SRAM = eeprom_read_byte(&LoggingInterval500MS_EEPROM);
 144
 145         /* Check if the logging interval is invalid (0xFF) indicating that the EEPROM is blank */
 146         if (LoggingInterval500MS_SRAM == 0xFF)
 147           LoggingInterval500MS_SRAM = DEFAULT_LOG_INTERVAL;
 148
 149         /* Mount and open the log file on the dataflash FAT partition */
 150         OpenLogFile();
 151
 152         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
 153         sei();
 154
 155         /* Discard the first sample from the temperature sensor, as it is generally incorrect */
 156         volatile uint8_t Dummy = Temperature_GetTemperature();
 157         (void)Dummy;
 158
 159         for (;;)
 160         {
 161                 MS_Device_USBTask(&Disk_MS_Interface);
 162                 HID_Device_USBTask(&Generic_HID_Interface);
 163                 USB_USBTask();
 164         }
 165 }
 166
 167 /** Opens the log file on the Dataflash's FAT formatted partition according to the current date */
 168 void OpenLogFile(void)
 169 {
 170         char LogFileName[12];
 171
 172         /* Get the current date for the filename as "DDMMYY.csv" */
 173         uint8_t Day, Month, Year;
 174         DS1307_GetDate(&Day, &Month, &Year);
 175         sprintf(LogFileName, "%02d%02d%02d.csv", Day, Month, Year);
 176
 177         /* Mount the storage device, open the file */
 178         f_mount(0, &DiskFATState);
 179         f_open(&TempLogFile, LogFileName, FA_OPEN_ALWAYS | FA_WRITE);
 180         f_lseek(&TempLogFile, TempLogFile.fsize);
 181 }
 182
 183 /** Closes the open data log file on the Dataflash's FAT formatted partition */
 184 void CloseLogFile(void)
 185 {
 186         /* Sync any data waiting to be written, unmount the storage device */
 187         f_sync(&TempLogFile);
 188         f_close(&TempLogFile);
 189 }
 190
 191 /** Configures the board hardware and chip peripherals for the demo's functionality. */
 192 void SetupHardware(void)
 193 {
 194         /* Disable watchdog if enabled by bootloader/fuses */
 195         MCUSR &= ~(1 << WDRF);
 196         wdt_disable();
 197
 198         /* Disable clock division */
 199         clock_prescale_set(clock_div_1);
 200
 201         /* Hardware Initialization */
 202         LEDs_Init();
 203         SPI_Init(SPI_SPEED_FCPU_DIV_2 | SPI_SCK_LEAD_FALLING | SPI_SAMPLE_TRAILING | SPI_MODE_MASTER);
 204         ADC_Init(ADC_REFERENCE_AVCC | ADC_FREE_RUNNING | ADC_PRESCALE_128);
 205         Temperature_Init();
 206         Dataflash_Init();
 207         USB_Init();
 208         TWI_Init();
 209
 210         /* 500ms logging interval timer configuration */
 211         OCR1A   = ((F_CPU / 1024) / 2);
 212         TCCR1B  = (1 << WGM12) | (1 << CS12) | (1 << CS10);
 213         TIMSK1  = (1 << OCIE1A);
 214
 215         /* Clear Dataflash sector protections, if enabled */
 216         DataflashManager_ResetDataflashProtections();
 217 }
 218
 219 /** Event handler for the library USB Connection event. */
 220 void EVENT_USB_Device_Connect(void)
 221 {
 222         LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
 223
 224         /* Close the log file so that the host has exclusive filesystem access */
 225         CloseLogFile();
 226 }
 227
 228 /** Event handler for the library USB Disconnection event. */
 229 void EVENT_USB_Device_Disconnect(void)
 230 {
 231         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
 232
 233         /* Mount and open the log file on the dataflash FAT partition */
 234         OpenLogFile();
 235 }
 236
 237 /** Event handler for the library USB Configuration Changed event. */
 238 void EVENT_USB_Device_ConfigurationChanged(void)
 239 {
 240         LEDs_SetAllLEDs(LEDMASK_USB_READY);
 241
 242         if (!(MS_Device_ConfigureEndpoints(&Disk_MS_Interface)))
 243           LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 244
 245         if (!(HID_Device_ConfigureEndpoints(&Generic_HID_Interface)))
 246           LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 247 }
 248
 249 /** Event handler for the library USB Unhandled Control Request event. */
 250 void EVENT_USB_Device_UnhandledControlRequest(void)
 251 {
 252         MS_Device_ProcessControlRequest(&Disk_MS_Interface);
 253         HID_Device_ProcessControlRequest(&Generic_HID_Interface);
 254 }
 255
 256 /** Mass Storage class driver callback function the reception of SCSI commands from the host, which must be processed.
 257  *
 258  *  \param[in] MSInterfaceInfo  Pointer to the Mass Storage class interface configuration structure being referenced
 259  */
 260 bool CALLBACK_MS_Device_SCSICommandReceived(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo)
 261 {
 262         bool CommandSuccess;
 263
 264         LEDs_SetAllLEDs(LEDMASK_USB_BUSY);
 265         CommandSuccess = SCSI_DecodeSCSICommand(MSInterfaceInfo);
 266         LEDs_SetAllLEDs(LEDMASK_USB_READY);
 267
 268         return CommandSuccess;
 269 }
 270
 271 /** HID class driver callback function for the creation of HID reports to the host.
 272  *
 273  *  \param[in]     HIDInterfaceInfo  Pointer to the HID class interface configuration structure being referenced
 274  *  \param[in,out] ReportID    Report ID requested by the host if non-zero, otherwise callback should set to the
 275  *                             generated report ID
 276  *  \param[in]     ReportType  Type of the report to create, either REPORT_ITEM_TYPE_In or REPORT_ITEM_TYPE_Feature
 277  *  \param[out]    ReportData  Pointer to a buffer where the created report should be stored
 278  *  \param[out]    ReportSize  Number of bytes written in the report (or zero if no report is to be sent
 279  *
 280  *  \return Boolean true to force the sending of the report, false to let the library determine if it needs to be sent
 281  */
 282 bool CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, uint8_t* const ReportID,
 283                                          const uint8_t ReportType, void* ReportData, uint16_t* const ReportSize)
 284 {
 285         Device_Report_t* ReportParams = (Device_Report_t*)ReportData;
 286
 287         DS1307_GetDate(&ReportParams->Day,  &ReportParams->Month,  &ReportParams->Year);
 288         DS1307_GetTime(&ReportParams->Hour, &ReportParams->Minute, &ReportParams->Second);
 289
 290         ReportParams->LogInterval500MS = LoggingInterval500MS_SRAM;
 291
 292         *ReportSize = sizeof(Device_Report_t);
 293         return true;
 294 }
 295
 296 /** HID class driver callback function for the processing of HID reports from the host.
 297  *
 298  *  \param[in] HIDInterfaceInfo  Pointer to the HID class interface configuration structure being referenced
 299  *  \param[in] ReportID    Report ID of the received report from the host
 300  *  \param[in] ReportType  The type of report that the host has sent, either REPORT_ITEM_TYPE_Out or REPORT_ITEM_TYPE_Feature
 301  *  \param[in] ReportData  Pointer to a buffer where the created report has been stored
 302  *  \param[in] ReportSize  Size in bytes of the received HID report
 303  */
 304 void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, const uint8_t ReportID,
 305                                           const uint8_t ReportType, const void* ReportData, const uint16_t ReportSize)
 306 {
 307         Device_Report_t* ReportParams = (Device_Report_t*)ReportData;
 308
 309         DS1307_SetDate(ReportParams->Day,  ReportParams->Month,  ReportParams->Year);
 310         DS1307_SetTime(ReportParams->Hour, ReportParams->Minute, ReportParams->Second);
 311
 312         /* If the logging interval has changed from its current value, write it to EEPROM */
 313         if (LoggingInterval500MS_SRAM != ReportParams->LogInterval500MS)
 314         {
 315                 LoggingInterval500MS_SRAM = ReportParams->LogInterval500MS;
 316                 eeprom_update_byte(&LoggingInterval500MS_EEPROM, LoggingInterval500MS_SRAM);
 317         }
 318 }