Projects/TempDataLogger/TempDataLogger.c

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2010.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6            www.lufa-lib.org
   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         /* Reset log tick counter to prepare for next logging interval */
 109         CurrentLoggingTicks = 0;
 110
 111         LEDs_SetAllLEDs(LEDMASK_USB_BUSY);
 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_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) - 1);
 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         bool ConfigSuccess = true;
 241
 242         ConfigSuccess &= MS_Device_ConfigureEndpoints(&Disk_MS_Interface);
 243         ConfigSuccess &= HID_Device_ConfigureEndpoints(&Generic_HID_Interface);
 244
 245         LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
 246 }
 247
 248 /** Event handler for the library USB Control Request reception event. */
 249 void EVENT_USB_Device_ControlRequest(void)
 250 {
 251         MS_Device_ProcessControlRequest(&Disk_MS_Interface);
 252         HID_Device_ProcessControlRequest(&Generic_HID_Interface);
 253 }
 254
 255 /** Mass Storage class driver callback function the reception of SCSI commands from the host, which must be processed.
 256  *
 257  *  \param[in] MSInterfaceInfo  Pointer to the Mass Storage class interface configuration structure being referenced
 258  */
 259 bool CALLBACK_MS_Device_SCSICommandReceived(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo)
 260 {
 261         bool CommandSuccess;
 262
 263         LEDs_SetAllLEDs(LEDMASK_USB_BUSY);
 264         CommandSuccess = SCSI_DecodeSCSICommand(MSInterfaceInfo);
 265         LEDs_SetAllLEDs(LEDMASK_USB_READY);
 266
 267         return CommandSuccess;
 268 }
 269
 270 /** HID class driver callback function for the creation of HID reports to the host.
 271  *
 272  *  \param[in]     HIDInterfaceInfo  Pointer to the HID class interface configuration structure being referenced
 273  *  \param[in,out] ReportID    Report ID requested by the host if non-zero, otherwise callback should set to the
 274  *                             generated report ID
 275  *  \param[in]     ReportType  Type of the report to create, either HID_REPORT_ITEM_In or HID_REPORT_ITEM_Feature
 276  *  \param[out]    ReportData  Pointer to a buffer where the created report should be stored
 277  *  \param[out]    ReportSize  Number of bytes written in the report (or zero if no report is to be sent
 278  *
 279  *  \return Boolean true to force the sending of the report, false to let the library determine if it needs to be sent
 280  */
 281 bool CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo,
 282                                          uint8_t* const ReportID,
 283                                          const uint8_t ReportType,
 284                                          void* ReportData,
 285                                          uint16_t* const ReportSize)
 286 {
 287         Device_Report_t* ReportParams = (Device_Report_t*)ReportData;
 288
 289         DS1307_GetDate(&ReportParams->Day,  &ReportParams->Month,  &ReportParams->Year);
 290         DS1307_GetTime(&ReportParams->Hour, &ReportParams->Minute, &ReportParams->Second);
 291
 292         ReportParams->LogInterval500MS = LoggingInterval500MS_SRAM;
 293
 294         *ReportSize = sizeof(Device_Report_t);
 295         return true;
 296 }
 297
 298 /** HID class driver callback function for the processing of HID reports from the host.
 299  *
 300  *  \param[in] HIDInterfaceInfo  Pointer to the HID class interface configuration structure being referenced
 301  *  \param[in] ReportID    Report ID of the received report from the host
 302  *  \param[in] ReportType  The type of report that the host has sent, either HID_REPORT_ITEM_Out or HID_REPORT_ITEM_Feature
 303  *  \param[in] ReportData  Pointer to a buffer where the created report has been stored
 304  *  \param[in] ReportSize  Size in bytes of the received HID report
 305  */
 306 void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo,
 307                                           const uint8_t ReportID,
 308                                           const uint8_t ReportType,
 309                                           const void* ReportData,
 310                                           const uint16_t ReportSize)
 311 {
 312         Device_Report_t* ReportParams = (Device_Report_t*)ReportData;
 313
 314         DS1307_SetDate(ReportParams->Day,  ReportParams->Month,  ReportParams->Year);
 315         DS1307_SetTime(ReportParams->Hour, ReportParams->Minute, ReportParams->Second);
 316
 317         /* If the logging interval has changed from its current value, write it to EEPROM */
 318         if (LoggingInterval500MS_SRAM != ReportParams->LogInterval500MS)
 319         {
 320                 LoggingInterval500MS_SRAM = ReportParams->LogInterval500MS;
 321                 eeprom_update_byte(&LoggingInterval500MS_EEPROM, LoggingInterval500MS_SRAM);
 322         }
 323 }
 324