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
 203         /* 500ms logging interval timer configuration */
 204         OCR1A   = ((F_CPU / 1024) / 2);
 205         TCCR1B  = (1 << WGM12) | (1 << CS12) | (1 << CS10);
 206         TIMSK1  = (1 << OCIE1A);
 207
 208         /* Clear Dataflash sector protections, if enabled */
 209         DataflashManager_ResetDataflashProtections();
 210 }
 211
 212 /** Event handler for the library USB Connection event. */
 213 void EVENT_USB_Device_Connect(void)
 214 {
 215         LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
 216
 217         /* Close the log file so that the host has exclusive filesystem access */
 218         CloseLogFile();
 219 }
 220
 221 /** Event handler for the library USB Disconnection event. */
 222 void EVENT_USB_Device_Disconnect(void)
 223 {
 224         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
 225
 226         /* Mount and open the log file on the dataflash FAT partition */
 227         OpenLogFile();
 228 }
 229
 230 /** Event handler for the library USB Configuration Changed event. */
 231 void EVENT_USB_Device_ConfigurationChanged(void)
 232 {
 233         LEDs_SetAllLEDs(LEDMASK_USB_READY);
 234
 235         if (!(MS_Device_ConfigureEndpoints(&Disk_MS_Interface)))
 236           LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 237
 238         if (!(HID_Device_ConfigureEndpoints(&Generic_HID_Interface)))
 239           LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 240 }
 241
 242 /** Event handler for the library USB Unhandled Control Request event. */
 243 void EVENT_USB_Device_UnhandledControlRequest(void)
 244 {
 245         MS_Device_ProcessControlRequest(&Disk_MS_Interface);
 246         HID_Device_ProcessControlRequest(&Generic_HID_Interface);
 247 }
 248
 249 /** Mass Storage class driver callback function the reception of SCSI commands from the host, which must be processed.
 250  *
 251  *  \param[in] MSInterfaceInfo  Pointer to the Mass Storage class interface configuration structure being referenced
 252  */
 253 bool CALLBACK_MS_Device_SCSICommandReceived(USB_ClassInfo_MS_Device_t* MSInterfaceInfo)
 254 {
 255         bool CommandSuccess;
 256
 257         LEDs_SetAllLEDs(LEDMASK_USB_BUSY);
 258         CommandSuccess = SCSI_DecodeSCSICommand(MSInterfaceInfo);
 259         LEDs_SetAllLEDs(LEDMASK_USB_READY);
 260
 261         return CommandSuccess;
 262 }
 263
 264 /** HID class driver callback function for the creation of HID reports to the host.
 265  *
 266  *  \param[in] HIDInterfaceInfo  Pointer to the HID class interface configuration structure being referenced
 267  *  \param[in,out] ReportID  Report ID requested by the host if non-zero, otherwise callback should set to the generated report ID
 268  *  \param[in] ReportType  Type of the report to create, either REPORT_ITEM_TYPE_In or REPORT_ITEM_TYPE_Feature
 269  *  \param[out] ReportData  Pointer to a buffer where the created report should be stored
 270  *  \param[out] ReportSize  Number of bytes written in the report (or zero if no report is to be sent
 271  *
 272  *  \return Boolean true to force the sending of the report, false to let the library determine if it needs to be sent
 273  */
 274 bool CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, uint8_t* const ReportID,
 275                                          const uint8_t ReportType, void* ReportData, uint16_t* ReportSize)
 276 {
 277         Device_Report_t* ReportParams = (Device_Report_t*)ReportData;
 278
 279         DS1307_GetDate(&ReportParams->Day,  &ReportParams->Month,  &ReportParams->Year);
 280         DS1307_GetTime(&ReportParams->Hour, &ReportParams->Minute, &ReportParams->Second);
 281
 282         ReportParams->LogInterval500MS = LoggingInterval500MS_SRAM;
 283
 284         *ReportSize = sizeof(Device_Report_t);
 285         return true;
 286 }
 287
 288 /** HID class driver callback function for the processing of HID reports from the host.
 289  *
 290  *  \param[in] HIDInterfaceInfo  Pointer to the HID class interface configuration structure being referenced
 291  *  \param[in] ReportID  Report ID of the received report from the host
 292  *  \param[in] ReportData  Pointer to a buffer where the created report has been stored
 293  *  \param[in] ReportSize  Size in bytes of the received HID report
 294  */
 295 void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, const uint8_t ReportID,
 296                                           const void* ReportData, const uint16_t ReportSize)
 297 {
 298         Device_Report_t* ReportParams = (Device_Report_t*)ReportData;
 299
 300         GPIOR0 = ReportParams->Day;
 301         GPIOR1 = ReportParams->Month;
 302         GPIOR2 = ReportParams->Year;
 303
 304         DS1307_SetDate(ReportParams->Day,  ReportParams->Month,  ReportParams->Year);
 305         DS1307_SetTime(ReportParams->Hour, ReportParams->Minute, ReportParams->Second);
 306
 307         /* If the logging interval has changed from its current value, write it to EEPROM */
 308         if (LoggingInterval500MS_SRAM != ReportParams->LogInterval500MS)
 309         {
 310                 LoggingInterval500MS_SRAM = ReportParams->LogInterval500MS;
 311                 eeprom_write_byte(&LoggingInterval500MS_EEPROM, LoggingInterval500MS_SRAM);
 312         }
 313 }