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