Paparazzi UAS  v7.0_unstable
Paparazzi is a free software Unmanned Aircraft System.
sdlog_chibios.c
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2013-2015 Gautier Hattenberger, Alexandre Bustico
3  *
4  * This file is part of paparazzi.
5  *
6  * paparazzi is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2, or (at your option)
9  * any later version.
10  *
11  * paparazzi is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with paparazzi; see the file COPYING. If not, write to
18  * the Free Software Foundation, 59 Temple Place - Suite 330,
19  * Boston, MA 02111-1307, USA.
20  */
21 
22 /*
23  * @file modules/loggers/sdlog_chibios.c
24  * @brief sdlog process with battery monitoring
25  *
26  */
27 
28 #include <ch.h>
29 #include <hal.h>
35 #include "mcu_periph/adc.h"
36 #include "mcu.h"
37 #include "led.h"
38 
39 #if HAL_USE_RTC
40 #include <hal_rtc.h>
41 #include <time.h>
42 #include "modules/gps/gps.h"
43 #endif
44 
45 // Delay before starting SD log
46 #ifndef SDLOG_START_DELAY
47 #define SDLOG_START_DELAY 30
48 #endif
49 
50 // Auto-flush period (in seconds)
51 #ifndef SDLOG_AUTO_FLUSH_PERIOD
52 #define SDLOG_AUTO_FLUSH_PERIOD 10
53 #endif
54 
55 // Contiguous storage memory (in Mo)
56 #ifndef SDLOG_CONTIGUOUS_STORAGE_MEM
57 #define SDLOG_CONTIGUOUS_STORAGE_MEM 50
58 #endif
59 
60 #if (!defined USE_ADC_WATCHDOG) || (USE_ADC_WATCHDOG == 0)
61 #error sdlog_chibios need USE_ADC_WATCHDOG in order to properly close files when power is unplugged
62 #endif
63 
64 #define DefaultAdcOfVoltage(voltage) ((uint32_t) (voltage/(DefaultVoltageOfAdc(1))))
65 static const uint16_t V_ALERT = DefaultAdcOfVoltage(5.5f);
66 static const char PPRZ_LOG_NAME[] = "pprzlog_";
67 static const char PPRZ_LOG_DIR[] = "PPRZ";
68 
69 /*
70  * Start log thread
71  */
72 static IN_DMA_SECTION(THD_WORKING_AREA(wa_thd_startlog, 4096));
73 static __attribute__((noreturn)) void thd_startlog(void *arg);
74 
75 /*
76  * Bat survey thread
77  */
78 static THD_WORKING_AREA(wa_thd_bat_survey, 1024);
79 static __attribute__((noreturn)) void thd_bat_survey(void *arg);
80 static void powerOutageIsr(void);
81 event_source_t powerOutageSource;
82 event_listener_t powerOutageListener;
83 
84 bool sdOk = false;
85 
87 
89 
90 #if FLIGHTRECORDER_SDLOG
91 static const char FLIGHTRECORDER_LOG_NAME[] = "fr_";
92 static const char FR_LOG_DIR[] = "FLIGHT_RECORDER";
93 FileDes flightRecorderLogFile = -1;
94 #endif
95 
98 static enum {
103 
106 static char chibios_sdlog_filenames[68];
107 static char NO_FILE_NAME[] = "none";
108 
109 #if PREFLIGHT_CHECKS
110 /* Preflight checks */
112 static struct preflight_check_t sdlog_pfc;
113 
114 static void sdlog_preflight(struct preflight_result_t *result) {
116 #ifdef SDLOG_PREFLIGHT_ERROR
117  preflight_error(result, "SDLogger is not running [%d:%d]", chibios_sdlog_status, sdLogGetStorageStatus());
118 #else
119  preflight_warning(result, "SDLogger is not running [%d:%d]", chibios_sdlog_status, sdLogGetStorageStatus());
120 #endif
121  } else {
122  preflight_success(result, "SDLogger running");
123  }
124 }
125 #endif // PREFLIGHT_CHECKS
126 
127 #if PERIODIC_TELEMETRY
129 static void send_sdlog_status(struct transport_tx *trans, struct link_device *dev)
130 {
132  uint8_t errno = (uint8_t) sdLogGetStorageStatus();
133  uint32_t used = (uint32_t) sdLogGetNbBytesWrittenToStorage();
134  uint8_t size = strlen(chibios_sdlog_filenames);
135  char *filenames = chibios_sdlog_filenames;
136  if (size == 0) {
137  // when no file opened
138  filenames = NO_FILE_NAME;
139  size = strlen(filenames);
140  }
141  pprz_msg_send_LOGGER_STATUS(trans, dev, AC_ID, &status, &errno, &used, size, filenames);
142 }
143 #endif
144 
145 
146 // Functions for the generic device API
147 static int sdlog_check_free_space(struct chibios_sdlog *p __attribute__((unused)), long *fd, uint16_t len)
148 {
149  SdLogBuffer *sdb;
150  SdioError status = sdLogAllocSDB(&sdb, len);
151  if (status != SDLOG_OK) {
152  return 0;
153  } else {
154  *fd = (long) sdb;
155  return 1;
156  }
157 }
158 
159 static void sdlog_transmit(struct chibios_sdlog *p __attribute__((unused)), long fd, uint8_t byte)
160 {
161  SdLogBuffer *sdb = (SdLogBuffer *) fd;
162  uint8_t *data = (uint8_t *) sdLogGetBufferFromSDB(sdb);
163  *data = byte;
164  sdLogSeekBufferFromSDB(sdb, 1);
165 }
166 
167 static void sdlog_transmit_buffer(struct chibios_sdlog *p __attribute__((unused)), long fd, uint8_t *data, uint16_t len)
168 {
169  SdLogBuffer *sdb = (SdLogBuffer *) fd;
170  memcpy(sdLogGetBufferFromSDB(sdb), data, len);
171  sdLogSeekBufferFromSDB(sdb, len);
172 }
173 
174 static void sdlog_send(struct chibios_sdlog *p, long fd)
175 {
176  SdLogBuffer *sdb = (SdLogBuffer *) fd;
177  sdLogWriteSDB(*(p->file), sdb);
178 }
179 
180 static int null_function(struct chibios_sdlog *p __attribute__((unused))) { return 0; }
181 static uint8_t null_byte_function(struct chibios_sdlog *p __attribute__((unused))) { return 0; }
182 
183 void chibios_sdlog_init(struct chibios_sdlog *sdlog, FileDes *file)
184 {
185  // Store file descriptor
186  sdlog->file = file;
187  // Configure generic device
188  sdlog->device.periph = (void *)(sdlog);
189  sdlog->device.check_free_space = (check_free_space_t) sdlog_check_free_space;
190  sdlog->device.put_byte = (put_byte_t) sdlog_transmit;
191  sdlog->device.put_buffer = (put_buffer_t) sdlog_transmit_buffer;
192  sdlog->device.send_message = (send_message_t) sdlog_send;
193  sdlog->device.char_available = (char_available_t) null_function; // write only
194  sdlog->device.get_byte = (get_byte_t) null_byte_function; // write only
195 
196 }
197 
199 {
201 #if PERIODIC_TELEMETRY
203 #endif
204 
205 #if PREFLIGHT_CHECKS
206  preflight_check_register(&sdlog_pfc, sdlog_preflight);
207 #endif
208 
209  // Start polling on USB
211 
212  // Start log thread
213  chThdCreateStatic(wa_thd_startlog, sizeof(wa_thd_startlog),
214  NORMALPRIO + 2, thd_startlog, NULL);
215 }
216 
217 
218 void sdlog_chibios_finish(const bool flush)
219 {
220  if (pprzLogFile != -1) {
221  // if a FF_FS_REENTRANT is true, we can umount fs without closing
222  // file, fatfs lock will assure that umount is done after a write,
223  // and umount will close all open files cleanly. Thats the fatest
224  // way to umount cleanly filesystem.
225  //
226  // if FF_FS_REENTRANT is false,
227  // we have to flush and close files before unmounting filesystem
228 #if FF_FS_REENTRANT == 0
229  sdLogCloseAllLogs(flush);
230 #else
231  (void) flush;
232 #endif
233 
234  sdLogFinish();
235  pprzLogFile = -1;
236 #if FLIGHTRECORDER_SDLOG
237  flightRecorderLogFile = -1;
238 #endif
239  }
241 }
242 
243 static void thd_startlog(void *arg)
244 {
245  (void) arg;
246  chRegSetThreadName("start log");
247  char tmpFilename[32];
248 
249  // Wait before starting the log if needed
250  chThdSleepSeconds(SDLOG_START_DELAY);
251  // Check if we are already in USB Storage mode
252  if (usbStorageIsItRunning()) {
253  chThdSleepSeconds(20000); // stuck here for hours FIXME stop the thread ?
254  }
255 
256  // Init sdlog struct
258 
259  // Check for init errors
260  sdOk = true;
261 
262  if (sdLogInit(NULL) != SDLOG_OK) {
263  sdOk = false;
264  } else {
266  if (sdLogOpenLog(&pprzLogFile, PPRZ_LOG_DIR,
268  SDLOG_CONTIGUOUS_STORAGE_MEM, LOG_PREALLOCATION_DISABLED, tmpFilename, sizeof(tmpFilename)) != SDLOG_OK) {
269  sdOk = false;
270  }
271  chsnprintf(chibios_sdlog_filenames, sizeof(chibios_sdlog_filenames), "%s", tmpFilename);
272 #if FLIGHTRECORDER_SDLOG
273  removeEmptyLogs(FR_LOG_DIR, FLIGHTRECORDER_LOG_NAME, 50);
274  if (sdLogOpenLog(&flightRecorderLogFile, FR_LOG_DIR, FLIGHTRECORDER_LOG_NAME,
276  SDLOG_CONTIGUOUS_STORAGE_MEM, LOG_PREALLOCATION_DISABLED, tmpFilename, sizeof(tmpFilename)) != SDLOG_OK) {
277  sdOk = false;
278  }
280 #endif
281  }
282 
283  if (sdOk) {
284  // Create Battery Survey Thread with event
285  chEvtObjectInit(&powerOutageSource);
286  chThdCreateStatic(wa_thd_bat_survey, sizeof(wa_thd_bat_survey),
287  NORMALPRIO + 2, thd_bat_survey, NULL);
288 
290  } else {
292  }
293 
294  while (true) {
295 #ifdef SDLOG_LED
296  LED_TOGGLE(SDLOG_LED);
297 #endif
298  // Blink faster if init has errors
299  chThdSleepMilliseconds(sdOk == true ? 1000 : 200);
300  if (sdLogGetStorageStatus() != SDLOG_OK) {
302  sdOk = false;
303  } else {
305  sdOk = true;
306  }
307 
308 #if HAL_USE_RTC && USE_GPS
309  static uint32_t timestamp = 0;
310  // FIXME this could be done somewhere else, like in sys_time
311  // we sync gps time to rtc every 5 seconds
312  if (chVTGetSystemTime() - timestamp > TIME_S2I(5)) {
313  timestamp = chVTGetSystemTime();
314  if (gps.tow != 0) {
315  // Unix timestamp of the GPS epoch 1980-01-06 00:00:00 UTC
316  const uint32_t unixToGpsEpoch = 315964800;
317  struct tm time_tm;
318  time_t univTime = ((gps.week * 7 * 24 * 3600) + (gps.tow / 1000)) + unixToGpsEpoch;
319  gmtime_r(&univTime, &time_tm);
320  // Chibios date struct
321  RTCDateTime date;
322  rtcConvertStructTmToDateTime(&time_tm, 0, &date);
323  rtcSetTime(&RTCD1, &date);
324  }
325  }
326 #endif
327 
328  }
329 }
330 
331 
332 static void thd_bat_survey(void *arg)
333 {
334  (void)arg;
335  chRegSetThreadName("battery survey");
336  chEvtRegister(&powerOutageSource, &powerOutageListener, 1);
337  chThdSleepMilliseconds(2000);
338 
339  register_adc_watchdog(&SDLOG_BAT_ADC, SDLOG_BAT_CHAN, V_ALERT, &powerOutageIsr);
340 
341  chEvtWaitOne(EVENT_MASK(1));
342  // Only try to energy save is it is really a problem and not powered through USB
343  if (palReadPad(SDLOG_USB_VBUS_PORT, SDLOG_USB_VBUS_PIN) == PAL_LOW) {
344  // disable all required periph to save energy and maximize chance to flush files
345  // to mass storage and avoid infamous dirty bit on filesystem
346  mcu_energy_save();
347  }
348 
349  // in case of powerloss, we should go fast and avoid to flush ram buffer
350  sdlog_chibios_finish(false);
351 
352  // Only put to deep sleep in case there is no power on the USB
353  if (palReadPad(SDLOG_USB_VBUS_PORT, SDLOG_USB_VBUS_PIN) == PAL_LOW) {
355  }
356  chThdExit(0);
357  while (true); // never goes here, only to avoid compiler warning: 'noreturn' function does return
358 }
359 
360 
361 /*
362  powerOutageIsr is called within a lock zone from an isr, so no lock/unlock is needed
363 */
364 static void powerOutageIsr(void)
365 {
366  chEvtBroadcastI(&powerOutageSource);
367 }
368 
370  uint8_t ac_id = pprzlink_get_DL_INFO_MSG_UP_ac_id(buf);
371  if(ac_id != AC_ID && ac_id != 0xFF) {
372  return;
373  }
374  uint8_t fd = pprzlink_get_DL_INFO_MSG_UP_fd(buf);
375  if(pprzLogFile != -1 && (fd == DEST_INFO_MSG_ALL || fd == DEST_INFO_MSG_PPRZLOG)) {
376  uint8_t len = pprzlink_get_INFO_MSG_UP_msg_length(buf);
377  uint8_t* msg = (uint8_t*) pprzlink_get_DL_INFO_MSG_UP_msg(buf);
378  sdLogWriteRaw(pprzLogFile, msg, len);
379  sdLogWriteByte(pprzLogFile, '\n');
380  }
381 }
382 
arch independent ADC (Analog to Digital Converter) API
#define SDLOG_BAT_ADC
Definition: board.h:533
#define SDLOG_USB_VBUS_PIN
Definition: board.h:538
#define SDLOG_USB_VBUS_PORT
Definition: board.h:537
#define SDLOG_BAT_CHAN
Definition: board.h:534
#define LED_TOGGLE(i)
Definition: led_hw.h:53
struct GpsState gps
global GPS state
Definition: gps.c:69
Device independent GPS code (interface)
uint32_t tow
GPS time of week in ms.
Definition: gps.h:107
uint16_t week
GPS week.
Definition: gps.h:106
void chsnprintf(char *buffer, size_t size, const char *fmt,...)
Definition: printf.c:377
void mcu_reboot(enum reboot_state_t reboot_state)
Reboot the MCU.
Definition: mcu_arch.c:206
void mcu_energy_save(void)
Save energy for performing operations on shutdown Used for example to shutdown SD-card logging.
Definition: mcu_arch.c:230
@ MCU_REBOOT_POWEROFF
Poweroff the device.
Definition: mcu.h:44
uint8_t msg[10]
Buffer used for general comunication over SPI (out buffer)
static float p[2][2]
arch independent LED (Light Emitting Diodes) API
Arch independent mcu ( Micro Controller Unit ) utilities.
#define byte
uint8_t status
void preflight_error(struct preflight_result_t *result, const char *fmt,...)
Register a preflight error used inside the preflight checking functions.
void preflight_success(struct preflight_result_t *result, const char *fmt,...)
Register a preflight success used inside the preflight checking functions.
void preflight_warning(struct preflight_result_t *result, const char *fmt,...)
Register a preflight error used inside the preflight checking functions.
void preflight_check_register(struct preflight_check_t *check, preflight_check_f func)
Register a preflight check and add it to the linked list.
Mini printf-like functionality.
SdioError sdLogFinish(void)
unmount filesystem
Definition: sdLog.c:285
SdioError removeEmptyLogs(const char *directoryName, const char *prefix, const size_t sizeConsideredEmpty)
remove spurious log file left on sd
Definition: sdLog.c:815
SdioError sdLogInit(uint32_t *freeSpaceInKo)
initialise sdLog
Definition: sdLog.c:225
struct _SdLogBuffer SdLogBuffer
Definition: sdLog.h:127
int8_t FileDes
Definition: sdLog.h:128
#define LOG_APPEND_TAG_AT_CLOSE_DISABLED
Definition: sdLog.h:105
SdioError
Definition: sdLog.h:111
@ SDLOG_OK
Definition: sdLog.h:112
#define LOG_PREALLOCATION_DISABLED
Definition: sdLog.h:103
#define DefaultAdcOfVoltage(voltage)
Definition: sdlog_chibios.c:64
static void sdlog_send(struct chibios_sdlog *p, long fd)
static int null_function(struct chibios_sdlog *p)
@ SDLOG_STOPPED
Definition: sdlog_chibios.c:99
@ SDLOG_ERROR
@ SDLOG_RUNNING
static void send_sdlog_status(struct transport_tx *trans, struct link_device *dev)
static enum @290 chibios_sdlog_status
sdlog status
static int sdlog_check_free_space(struct chibios_sdlog *p, long *fd, uint16_t len)
void logger_log_msg_up(uint8_t *buf)
static IN_DMA_SECTION(THD_WORKING_AREA(wa_thd_startlog, 4096))
static void thd_startlog(void *arg)
event_source_t powerOutageSource
Definition: sdlog_chibios.c:81
static void powerOutageIsr(void)
#define SDLOG_AUTO_FLUSH_PERIOD
Definition: sdlog_chibios.c:52
static const uint16_t V_ALERT
Definition: sdlog_chibios.c:65
static const char PPRZ_LOG_DIR[]
Definition: sdlog_chibios.c:67
void sdlog_chibios_finish(const bool flush)
event_listener_t powerOutageListener
Definition: sdlog_chibios.c:82
static void sdlog_transmit(struct chibios_sdlog *p, long fd, uint8_t byte)
FileDes pprzLogFile
Definition: sdlog_chibios.c:86
static THD_WORKING_AREA(wa_thd_bat_survey, 1024)
#define SDLOG_START_DELAY
Definition: sdlog_chibios.c:47
static char NO_FILE_NAME[]
static const char PPRZ_LOG_NAME[]
Definition: sdlog_chibios.c:66
#define SDLOG_CONTIGUOUS_STORAGE_MEM
Definition: sdlog_chibios.c:57
void chibios_sdlog_init(struct chibios_sdlog *sdlog, FileDes *file)
init chibios_sdlog structure
bool sdOk
Definition: sdlog_chibios.c:84
static char chibios_sdlog_filenames[68]
sdlog filenames
static uint8_t null_byte_function(struct chibios_sdlog *p)
static void sdlog_transmit_buffer(struct chibios_sdlog *p, long fd, uint8_t *data, uint16_t len)
static void thd_bat_survey(void *arg)
void sdlog_chibios_init(void)
#define DEST_INFO_MSG_PPRZLOG
Definition: sdlog_chibios.h:44
FileDes * file
Definition: sdlog_chibios.h:59
#define DEST_INFO_MSG_ALL
Definition: sdlog_chibios.h:42
struct link_device device
Generic device interface.
Definition: sdlog_chibios.h:61
chibios_sdlog structure
Definition: sdlog_chibios.h:58
int fd
Definition: serial.c:26
static const struct usb_device_descriptor dev
Definition: usb_ser_hw.c:74
int8_t register_periodic_telemetry(struct periodic_telemetry *_pt, uint8_t _id, telemetry_cb _cb)
Register a telemetry callback function.
Definition: telemetry.c:51
Periodic telemetry system header (includes downlink utility and generated code).
#define DefaultPeriodic
Set default periodic telemetry.
Definition: telemetry.h:66
Dynamic memory allocation based on TLSF library.
void usbStorageStartPolling(void)
Definition: usbStorage.c:76
bool usbStorageIsItRunning(void)
Definition: usbStorage.c:163
unsigned short uint16_t
Typedef defining 16 bit unsigned short type.
Definition: vl53l1_types.h:88
unsigned int uint32_t
Typedef defining 32 bit unsigned int type.
Definition: vl53l1_types.h:78
unsigned char uint8_t
Typedef defining 8 bit unsigned char type.
Definition: vl53l1_types.h:98