Jerry Bradshaw
/
HSP_Release
Important changes to repositories hosted on mbed.com
Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.
To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.
It is also possible to export all your personal repositories from the account settings page.
Fork of
mbed-os-test
by 
Jerry Bradshaw
Revision 0:e4a10ed6eb92, committed 2016-10-25
- Comitter:
- jbradshaw
- Date:
- Tue Oct 25 15:22:11 2016 +0000
- Commit message:
- tewt
Changed in this revision
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/.gitignore Tue Oct 25 15:22:11 2016 +0000 @@ -0,0 +1,4 @@ +.build +.mbed +projectfiles +*.py*
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/Devices/BMP280/BMP280/BMP280.cpp Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,294 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+
+
+#include "mbed.h"
+#include "BMP280.h"
+
+//******************************************************************************
+BMP280::BMP280(PinName sda, PinName scl, int slaveAddress) :
+ slaveAddress(slaveAddress) {
+ i2c = new I2C(sda, scl);
+ isOwner = true;
+}
+//******************************************************************************
+BMP280::BMP280(I2C *i2c, int slaveAddress) :
+ slaveAddress(slaveAddress) {
+ this->i2c = i2c;
+ isOwner = false;
+
+ i2c->frequency(100000);
+ loggingEnabled = 0;
+ loggingSampleRate = 5;
+}
+//******************************************************************************
+BMP280::~BMP280(void) {
+ if (isOwner == true) {
+ delete i2c;
+ }
+}
+
+//******************************************************************************
+int BMP280::init(BMP280::bmp280_osrs_P_t Osrs_p, BMP280::bmp280_osrs_T_t Osrs_t,
+ BMP280::bmp280_FILT_t Filter, BMP280::bmp280_MODE_t Mode,
+ BMP280::bmp280_TSB_t T_sb)
+
+{
+ char reg;
+ char raw_Tn[6];
+ char raw_Pn[20];
+
+ // Read all the temp coeffecients from the BMP280 memory. It will be used in
+ // calculation
+ reg = 0x88;
+ if (reg_read(reg, raw_Tn, 6) != 0) {
+ return -1;
+ }
+
+ dig_T1 = (((uint16_t)raw_Tn[1]) << 8) | raw_Tn[0];
+ dig_T2 = (((int16_t)raw_Tn[3]) << 8) | raw_Tn[2];
+ dig_T3 = (((int16_t)raw_Tn[5]) << 8) | raw_Tn[4];
+
+ // Read all the press coeffecients from the BMP280 memory. It will be used in
+ // calculation
+ reg = 0x8E;
+ if (reg_read(reg, raw_Pn, 20) != 0) {
+ return -1;
+ }
+
+ dig_P1 = (((uint16_t)raw_Pn[1]) << 8) | raw_Pn[0];
+ dig_P2 = (((int16_t)raw_Pn[3]) << 8) | raw_Pn[2];
+ dig_P3 = (((int16_t)raw_Pn[5]) << 8) | raw_Pn[4];
+ dig_P4 = (((int16_t)raw_Pn[7]) << 8) | raw_Pn[6];
+ dig_P5 = (((int16_t)raw_Pn[9]) << 8) | raw_Pn[8];
+ dig_P6 = (((int16_t)raw_Pn[11]) << 8) | raw_Pn[10];
+ dig_P7 = (((int16_t)raw_Pn[13]) << 8) | raw_Pn[12];
+ dig_P8 = (((int16_t)raw_Pn[15]) << 8) | raw_Pn[14];
+ dig_P9 = (((int16_t)raw_Pn[17]) << 8) | raw_Pn[16];
+
+
+ wait(1.0 / 10.0);
+
+ /****/
+ if (reg_read(BMP280_CTRL_MEAS, &bmp280_ctrl_meas.all, 1) != 0) {
+ return -1;
+ }
+
+ bmp280_ctrl_meas.bit.osrs_p = Osrs_p;
+ bmp280_ctrl_meas.bit.osrs_t = Osrs_t;
+
+ bmp280_ctrl_meas.bit.mode = Mode;
+
+ if (reg_write(BMP280_CTRL_MEAS, bmp280_ctrl_meas.all) != 0) {
+ return -1;
+ }
+
+ /****/
+
+ if (reg_read(BMP280_CONFIG, &bmp280_config.all, 1) != 0) {
+ return -1;
+ }
+
+ bmp280_config.bit.filter = Filter;
+
+ if (Mode == 0b11) {
+ bmp280_config.bit.t_sb = T_sb;
+ }
+
+ if (reg_write(BMP280_CONFIG, bmp280_config.all) != 0) {
+ return -1;
+ }
+
+ return 0;
+}
+
+//******************************************************************************
+float BMP280::ToFahrenheit(float temperature) {
+ return temperature * 9 / 5 + 32;
+}
+
+//******************************************************************************
+int BMP280::ReadCompDataRaw2(char *bmp280_rawData) {
+ int i;
+ char data[6];
+ float temp;
+ float pressure;
+ int iPressure;
+ char str[32];
+ ReadCompDataRaw(data);
+ ToFloat(data, &temp, &pressure);
+ iPressure = (int)pressure;
+ sprintf(str, "%d ", iPressure);
+ for (i = 0; i < 6; i++) {
+ bmp280_rawData[i] = str[i];
+ }
+ return 0;
+}
+
+//******************************************************************************
+int BMP280::ReadCompDataRaw(char *bmp280_rawData) {
+ char reg;
+ char rxbytes;
+
+ reg = BMP280_PRESS_MSB;
+ rxbytes = 6;
+
+ if (reg_read(reg, bmp280_rawData, rxbytes) != 0) {
+ return -1;
+ }
+ return 0;
+}
+
+//******************************************************************************
+void BMP280::ToFloat(char *bmp280_rawData, float *Temp_degC, float *Press_Pa) {
+ bmp280_rawPress = (uint32_t)(bmp280_rawData[0] << 12) |
+ (bmp280_rawData[1] << 4) | (bmp280_rawData[2] >> 4);
+
+ bmp280_rawTemp = (uint32_t)(bmp280_rawData[3] << 12) |
+ (bmp280_rawData[4] << 4) | (bmp280_rawData[5] >> 4);
+
+ *Temp_degC = compensate_T_float(bmp280_rawTemp);
+ *Press_Pa = compensate_P_float(bmp280_rawPress);
+}
+
+//******************************************************************************
+int BMP280::ReadCompData(float *Temp_degC, float *Press_Pa) {
+ char bmp280_rawData[6];
+
+ if (ReadCompDataRaw(bmp280_rawData) != 0) {
+ return -1;
+ }
+ ToFloat(bmp280_rawData, Temp_degC, Press_Pa);
+ return 0;
+}
+
+//******************************************************************************
+int BMP280::reg_write(char reg, char value) {
+ int result;
+ char cmdData[2] = {(char)reg, value};
+ result = i2c->write(slaveAddress, cmdData, 2);
+ if (result != 0)
+ return -1;
+ return 0;
+}
+
+//******************************************************************************
+int BMP280::reg_read(char reg, char *value, char number) {
+ int result;
+ char cmdData[1] = {(char)reg};
+
+ result = i2c->write(slaveAddress, cmdData, 1);
+ if (result != 0)
+ return -1;
+ result = i2c->read(slaveAddress, value, number);
+ if (result != 0)
+ return -1;
+ return 0;
+}
+
+//******************************************************************************
+int BMP280::Sleep(void) {
+ // Configure the I2C interface
+
+ if (reg_read(BMP280_CTRL_MEAS, &bmp280_ctrl_meas.all, 1) != 0) {
+ return -1;
+ }
+ bmp280_ctrl_meas.bit.mode = 0b00; // put everything to sleep mode...
+
+ if (reg_write(BMP280_CTRL_MEAS, bmp280_ctrl_meas.all) != 0) {
+ return -1;
+ }
+ return 0;
+}
+
+//******************************************************************************
+void BMP280::Reset(void) {
+ reg_write(BMP280_RESET, 0xB6); // Initiate a Soft Reset
+}
+
+//******************************************************************************
+int BMP280::Detect(void) {
+ if (reg_read(BMP280_ID, &bmp280_id, 1) != 0) {
+ return -1;
+ }
+
+ if (bmp280_id == 0x58) {
+ return 1;
+ }
+ return 0;
+}
+
+//******************************************************************************
+int BMP280::ReadId(void) {
+ if (reg_read(BMP280_ID, &bmp280_id, 1) != 0) {
+ return -1;
+ }
+ return bmp280_id;
+}
+
+//******************************************************************************
+float BMP280::compensate_T_float(int32_t adc_T) {
+ float var1, var2, T;
+ var1 =
+ (((float)adc_T) / 16384.0 - ((float)dig_T1) / 1024.0) * ((float)dig_T2);
+
+ var2 = ((((float)adc_T) / 131072.0 - ((float)dig_T1) / 8192.0) *
+ (((float)adc_T) / 131072.0 - ((float)dig_T1) / 8192.0)) *
+ ((float)dig_T3);
+
+ t_fine = (int32_t)(var1 + var2);
+
+ T = (var1 + var2) / 5120.0;
+
+ return T;
+}
+
+//******************************************************************************
+float BMP280::compensate_P_float(int32_t adc_P) {
+ float var1, var2, p;
+ var1 = ((float)t_fine / 2.0) - 64000.0;
+ var2 = var1 * var1 * ((float)dig_P6) / 32768.0;
+ var2 = var2 + var1 * ((float)dig_P5) * 2.0;
+ var2 = (var2 / 4.0) + (((float)dig_P4) * 65536.0);
+ var1 = (((float)dig_P3) * var1 * var1 / 524288.0 + ((float)dig_P2) * var1) / 524288.0;
+ var1 = (1.0 + var1 / 32768.0) * ((float)dig_P1);
+ if (var1 == 0.0) {
+ return 0; // avoid exception caused by division by zero
+ }
+ p = 1048576.0 - (float)adc_P;
+ p = (p - (var2 / 4096.0)) * 6250.0 / var1;
+ var1 = ((float)dig_P9) * p * p / 2147483648.0;
+ var2 = p * ((float)dig_P8) / 32768.0;
+ p = p + (var1 + var2 + ((float)dig_P7)) / 16.0;
+ return p;
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/Devices/BMP280/BMP280/BMP280.h Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,418 @@
+/*******************************************************************************
+* Copyright (C) 2015 Maxim Integrated Products, Inc., All Rights Reserved.
+*
+* Permission is hereby granted, free of charge, to any person obtaining a
+* copy of this software and associated documentation files (the "Software"),
+* to deal in the Software without restriction, including without limitation
+* the rights to use, copy, modify, merge, publish, distribute, sublicense,
+* and/or sell copies of the Software, and to permit persons to whom the
+* Software is furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included
+* in all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+* IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+* OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+* OTHER DEALINGS IN THE SOFTWARE.
+*
+* Except as contained in this notice, the name of Maxim Integrated
+* Products, Inc. shall not be used except as stated in the Maxim Integrated
+* Products, Inc. Branding Policy.
+*
+* The mere transfer of this software does not imply any licenses
+* of trade secrets, proprietary technology, copyrights, patents,
+* trademarks, maskwork rights, or any other form of intellectual
+* property whatsoever. Maxim Integrated Products, Inc. retains all
+* ownership rights.
+*******************************************************************************/
+/**
+ * Bosch BMP280 Digital Pressure Sensor
+ *
+ * @code
+ * #include <stdio.h>
+ * #include "mbed.h"
+ * #include "xxx.h"
+ *
+ * I2C i2c(I2C_SDA, I2C_SCL);
+ * xxx xxx(&i2c);
+ *
+ * int main(void) {
+ * printf("Initialized xxx\n");
+ * while(1) {
+ * if (xxx.init() != 0) {
+ * printf("Error communicating with xxx\n");
+ * } else {
+ * printf("Initialized xxx\n");
+ * break;
+ * }
+ * wait(1);
+ * }
+ *
+ * while(1) {
+ * printf("");
+ * wait(1);
+ * }
+ * }
+ * @endcode
+ */
+
+#ifndef BMP280_H_
+#define BMP280_H_
+
+#include "mbed.h"
+
+#define BMP280_READID (0x58)
+
+#define BMP280_TEMP_XLSB (0xFC)
+#define BMP280_TEMP_LSB (0xFB)
+#define BMP280_TEMP_MSB (0xFA)
+
+#define BMP280_PRESS_XLSB (0xF9)
+#define BMP280_PRESS_LSB (0xF8)
+#define BMP280_PRESS_MSB (0xF7)
+
+#define BMP280_CONFIG (0xF5)
+#define BMP280_CTRL_MEAS (0xF4)
+#define BMP280_STATUS (0xF3)
+#define BMP280_RESET (0xE0)
+#define BMP280_ID (0xD0)
+
+// calib25-calib00: 0xA1-0x88
+#define BMP280_CALIB25 (0xA1) // Beginning address
+#define BMP280_CALIB00 (0x88) // Ending address
+
+#define BMP280_REGISTER_CHIPID (0xD0)
+#define BMP280_REGISTER_VERSION (0xD1)
+#define BMP280_REGISTER_SOFTRESET (0xE0)
+
+#define BMP280_REGISTER_CAL26 (0xE1) // R calibration stored in 0xE1-0xF0
+
+#define BMP280_REGISTER_CONTROL (0xF4)
+#define BMP280_REGISTER_CONFIG (0xF5)
+#define BMP280_REGISTER_PRESSUREDATA (0xF7)
+#define BMP280_REGISTER_TEMPDATA (0xFA)
+
+/**
+ * @brief Bosch BMP280 Digital Pressure Sensor
+ */
+class BMP280 {
+
+public:
+ /**
+ * BMP280 constructor.
+ *
+ * @param sda mbed pin to use for SDA line of I2C interface.
+ * @param scl mbed pin to use for SCL line of I2C interface.
+ * @param slaveAddress Slave Address of the device.
+ */
+ BMP280(PinName sda, PinName scl, int slaveAddress);
+
+ /**
+ * BMP280 constructor.
+ *
+ * @param i2c I2C object to use.
+ * @param slaveAddress Slave Address of the device.
+ */
+ BMP280(I2C *i2c, int slaveAddress);
+
+ char loggingEnabled;
+ char loggingSampleRate;
+
+ /**
+ * Write a device register
+ */
+ int writeReg(char reg, char value);
+ /**
+ * Read a device register
+ */
+ int readReg(char reg, char *value);
+
+ /// @brief TEMP_XLSB (0xFC)
+ char bmp280_temp_xlsb; // Lower 4-bits are all 0's
+
+ /// @brief TEMP_LSB (0xFB)
+ char bmp280_temp_lsb;
+
+ /// @brief TEMP_MSB (0xFA)
+ char bmp280_temp_msb;
+
+ /// @brief PRESS_XLSB (0xF9)
+ char bmp280_press_xlsb; // Lower 4-bits are all 0's
+
+ /// @brief PRESS_LSB (0xF8)
+ char bmp280_press_lsb;
+
+ /// @brief PRESS_MSB (0xF7)
+ char bmp280_press_msb;
+
+ /// @brief CONFIG_REG (0xF5)
+ union bmp280_config_reg {
+ char all;
+ struct {
+ char spi3w_en : 1;
+ char reserved : 1;
+ char filter : 3;
+ char t_sb : 3;
+ } bit;
+ } bmp280_config;
+
+ /// @brief CTRL_MEAS (0xF4)
+ union bmp280_ctrl_meas {
+ char all;
+ struct {
+ char mode : 2;
+ char osrs_p : 3;
+ char osrs_t : 3;
+ } bit;
+ } bmp280_ctrl_meas;
+
+ /// @brief STATUS (0xF3)
+ union bmp280_status {
+ char all;
+ struct {
+ char im_update : 1;
+ char reserved1 : 2;
+ char measuring : 1;
+ char reserved2 : 4;
+ } bit;
+ } bmp280_status;
+
+ /// @brief RESET (0xE0)
+ char bmp280_reset;
+
+ /// @brief ID (0xD0)
+ char bmp280_id;
+
+ typedef enum {
+ SKIPPED_P = 0,
+ OVERSAMPLING_X1_P = 1,
+ OVERSAMPLING_X2_P = 2,
+ OVERSAMPLING_X4_P = 3,
+ OVERSAMPLING_X8_P = 4,
+ OVERSAMPLING_X16_P = 5
+ } bmp280_osrs_P_t;
+
+ typedef enum {
+ SKIPPED_T = 0,
+ OVERSAMPLING_X1_T = 1,
+ OVERSAMPLING_X2_T = 2,
+ OVERSAMPLING_X4_T = 3,
+ OVERSAMPLING_X8_T = 4,
+ OVERSAMPLING_X16_T = 5
+ } bmp280_osrs_T_t;
+
+ typedef enum {
+ FILT_OFF = 1,
+ FILT_2 = 2,
+ FILT_3 = 4,
+ FILT_4 = 8,
+ FILT_5 = 16
+ } bmp280_FILT_t;
+
+ typedef enum {
+ SLEEP_MODE = 0,
+ FORCED_MODE = 1,
+ NORMAL_MODE = 3
+ } bmp280_MODE_t;
+
+ typedef enum {
+ T_0_5 = 0,
+ T_62_5 = 1,
+ T_125 = 2,
+ T_250 = 3,
+ T_500 = 4,
+ T_1000 = 5,
+ T_2000 = 6,
+ T_4000 = 7
+ } bmp280_TSB_t;
+
+ /// @brief calib25... calib00 (0xA1...0x88)
+ char bmp280_Calib[26];
+
+ uint16_t dig_T1;
+ int16_t dig_T2;
+ int16_t dig_T3;
+
+ uint16_t dig_P1;
+ int16_t dig_P2;
+ int16_t dig_P3;
+ int16_t dig_P4;
+ int16_t dig_P5;
+ int16_t dig_P6;
+ int16_t dig_P7;
+ int16_t dig_P8;
+ int16_t dig_P9;
+
+ int32_t t_fine; // This is calculated int the temperature to be used by the
+ // pressure
+
+ int32_t bmp280_rawPress;
+ int32_t bmp280_rawTemp;
+
+ float Temp_degC; // Deg C.
+ float Press_Pa; // Pascal.
+
+ /**
+ * BMP280 constructor.
+ *
+ * @param sda mbed pin to use for SDA line of I2C interface.
+ * @param scl mbed pin to use for SCL line of I2C interface.
+ */
+ BMP280(PinName sda, PinName scl);
+
+ /**
+ * BMP280 constructor.
+ *
+ * @param i2c I2C object to use.
+ */
+ BMP280(I2C *i2c);
+
+ /**
+ * BMP280 destructor.
+ */
+ ~BMP280(void);
+
+ // Function Prototypes
+
+ /**
+ * @brief This initializes the BMP280
+ * @brief The BMP280 has 2 modes. FORCED mode and NORMAL mode. FORCED Mode gives more
+ * @brief control to the processor as the processor sends out the Mode to initiate a conversion
+ * @brief and a data is sent out then. NORMAL mode is initialized once and it just runs and sends
+ * @brief out data at a programmed timed interval. (In this example the main() will set this to Normal
+ * @brief function)
+ * @param Osrs_p- Pressure oversampling
+ * @param Osrs_t- Temperature oversampling
+ * @param Filter- Filter Settings
+ * @param Mode- Power Modes
+ * @param T_sb- Standby time (used with Normal mode)
+ * @param dig_T1, dig_T2, dig_T3- Coeffs used for temp conversion - GLOBAL variables (output)
+ * @param dig_P1, .... , dig_P9- Coeffs used for press conversion - GLOBAL variables (output)
+ * @returns 0-if no error. A non-zero value indicates an error.
+ */
+ int init(bmp280_osrs_P_t Osrs_p, bmp280_osrs_T_t Osrs_t, bmp280_FILT_t Filter,
+ bmp280_MODE_t Mode, bmp280_TSB_t T_sb);
+
+ /**
+ * @brief The BMP280 has 2 modes. FORCED mode and NORMAL mode. FORCED Mode
+ * gives more
+ * @brief control to the processor as the processor sends out the Mode to
+ * initiate a conversion
+ * @brief and a data is sent out then. NORMAL mode is initialized once and it
+ * just runs and sends
+ * @brief out data at a programmed timed interval. (In this example the
+ * main() will set this to Normal
+ * @brief function)
+ * @param *Temp_degC - Pointer to temperature (result in deg C)
+ * @param *Press_Pa - Pointer to pressure (resul in Pascal)
+ * @returns 0-if no error. A non-zero value indicates an error.
+ */
+ int ReadCompData(float *Temp_degC, float *Press_Pa);
+
+ /**
+ * @brief This function allows writing to a register.
+ * @param reg- Address of the register to write to
+ * @param value- Data written to the register
+ * @returns 0-if no error. A non-zero value indicates an error.
+ */
+ int reg_write(char reg, char value);
+
+ /**
+ * @brief This function allows writing to a register.
+ * @params reg- Address of the register to read from (input)
+ * @params *value- Pointer to the value read from the register (output)
+ * @returns 0-if no error. A non-zero value indicates an error.
+ */
+ int reg_read(char reg, char *value, char number);
+
+ /**
+ * @brief Performs a soft reset on the BMP280
+ * @param none
+ * @returns none
+ */
+ void Reset(void);
+
+ /**
+ * @brief Detects if the BMP280 is present
+ * @param none
+ * @returns 1 for found, 0 for not found, -1 for comm error
+ */
+ int Detect(void);
+
+ /**
+ * @brief Performs calculations on the raw temperature data to convert to
+ * @brief temperature in deg C, based on Bosch's algorithm
+ * @param Raw Temp ADC value, Global dig_T1, dig_T2, dig_T3
+ * @returns The Temperature in deg C
+ */
+ float compensate_T_float(int32_t adc_T); // returned value Deg C.
+
+ /**
+ * @brief Performs calculations on the raw pressure data to convert to
+ * @brief pressure in Pascal, based on Bosch's algorithm
+ * @param adc_P Raw Press ADC value, Global dig_P1, dig_P2,..., dig_P9
+ * @returns The Pressure in Pascals
+ */
+ float compensate_P_float(int32_t adc_P); // returned value Pascal.
+
+ /**
+ * @brief Puts the BMP280 in low power Sleep mode
+ * @param none
+ * @returns 0 if no errors, -1 if error.
+ */
+ int Sleep(void);
+
+ /**
+ * @brief This reads the raw BMP280 data
+ * @param *bmp280_rawData- array of raw output data
+ * @returns 0-if no error. A non-zero value indicates an error.
+ *
+ */
+ int ReadCompDataRaw(char *bmp280_rawData);
+ /**
+ * @brief This reads the raw BMP280 data uses the Bosch algorithm to get the
+ * data
+ * @brief in float, then the float gets converted to an String
+ * @param *bmp280_rawData- array of raw output data
+ * @returns 0-if no error. A non-zero value indicates an error.
+ *
+ */
+ int ReadCompDataRaw2(char *bmp280_rawData);
+ /**
+ * @brief This converts the raw BMP280 data to couble based on Bosch's
+ * algorithm
+ * @param *bmp280_rawData- array of raw input data
+ * @param *Temp_degC- pointer to output, Temp value in deg C
+ * @param *Press_Pa- pointer to output, Press value in Pascals
+ * @returns 0-if no error. A non-zero value indicates an error.
+ *
+ */
+ void ToFloat(char *bmp280_rawData, float *Temp_degC, float *Press_Pa);
+ /**
+ * @brief converts to Farenhite from Centigrade
+ * @param temperature in Centigrade
+ * @returns temperature value in Farenhite
+ */
+ float ToFahrenheit(float temperature);
+
+ /**
+ * @brief Reads a unique ID from the register
+ * @param none
+ * @returns The correct id value which is 0x58
+ */
+ int ReadId(void);
+
+private:
+ /// I2C pointer
+ I2C *i2c;
+ /// Is this object the owner of the I2C object
+ bool isOwner;
+ /// Device slave address
+ int slaveAddress;
+};
+
+#endif // BMP280_H_
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/Devices/BMP280/BMP280_RPC.cpp Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,52 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+
+#include "BMP280_RPC.h"
+#include "BMP280.h"
+#include "StringHelper.h"
+#include "Peripherals.h"
+#include "Device_Logging.h"
+
+extern Device_Logging *bmp280_Logging;
+
+
+int BMP280_InitStart(char argStrs[32][32], char replyStrs[32][32]) {
+ uint8_t args[1];
+ uint8_t reply[1];
+
+ ProcessArgs(argStrs, args, sizeof(args));
+ bmp280_Logging->initStart(args[0]);
+ reply[0] = 0x80;
+ FormatReply(reply, sizeof(reply), replyStrs);
+ return 0;
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/HSP/Devices/BMP280/BMP280_RPC.h Tue Oct 25 15:22:11 2016 +0000 @@ -0,0 +1,47 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ +#ifndef _BMP280_RPC_H_ +#define _BMP280_RPC_H_ + +#include "mbed.h" + +/** +* @brief Read the identification of the s25fs512 using quad spi +* @param argStrs incoming rpc argument strings +* OUTPUT: +* replyStrs: strings that get returned to the rpc caller +* @return 0 if successful, -1 if error +*/ +int BMP280_InitStart(char argStrs[32][32], char replyStrs[32][32]); + +#endif /* _BMP280_RPC_H_ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/Devices/HspLed/HspLed/HspLed.cpp Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,143 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+
+#include "HspLed.h"
+#include "Peripherals.h"
+
+void hspled_int_handler(void);
+
+//*******************************************************************************
+HspLed::HspLed(PinName ledPin) :
+ redLed(LED_RED, 0), isStarted(false), timerIntervalLast(-1), timerInterval(500) {
+}
+
+
+//*******************************************************************************
+void HspLed::state(int state) {
+ redLed.write(state);
+}
+
+
+//*******************************************************************************
+void HspLed::toggle(void) {
+ state(!redLed.read());
+}
+
+
+//*******************************************************************************
+void HspLed::setMode(eMode mode) {
+ this->mode = mode;
+}
+
+//*******************************************************************************
+void HspLed::blink(uint32_t mSeconds) {
+ mode = eLedPeriod;
+ this->timerInterval = (float)mSeconds / 1000.0f;
+ start();
+}
+
+//*******************************************************************************
+void HspLed::pattern(uint32_t bitPattern, uint32_t mSeconds) {
+ mode = eLedPattern;
+ this->bitPattern = bitPattern;
+ this->timerInterval = (float)mSeconds / 1000.0f;
+ start();
+}
+
+//*******************************************************************************
+void HspLed::on(void) {
+ mode = eLedOn;
+ state(HSP_LED_ON);
+ start();
+}
+
+
+//*******************************************************************************
+void HspLed::off(void) {
+ mode = eLedOff;
+ state(HSP_LED_OFF);
+ start();
+}
+
+
+//*******************************************************************************
+void HspLed::patternToLed(void) {
+ uint32_t bit;
+ bit = bitPattern & 1;
+ state(bit);
+ // rotate the pattern
+ bitPattern = bitPattern >> 1;
+ bitPattern = bitPattern | (bit << 31);
+}
+
+
+//*******************************************************************************
+void HspLed::service(void) {
+ switch (mode) {
+ case eLedOn:
+ state(HSP_LED_ON);
+ break;
+ case eLedOff:
+ state(HSP_LED_OFF);
+ break;
+ case eLedPeriod:
+ toggle();
+ break;
+ case eLedPattern:
+ patternToLed();
+ break;
+ }
+}
+
+//*******************************************************************************
+void HspLed::start(void) {
+ if (timerInterval != timerIntervalLast && isStarted == true) {
+ stop();
+ }
+ ticker.attach(&hspled_int_handler, timerInterval);
+ timerIntervalLast = timerInterval;
+
+ isStarted = true;
+}
+
+//*******************************************************************************
+void HspLed::stop(void) {
+ ticker.detach();
+ isStarted = false;
+}
+
+//*******************************************************************************
+void hspled_int_handler(void) {
+ HspLed *hspLed = Peripherals::hspLed();
+ hspLed->service();
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/Devices/HspLed/HspLed/HspLed.h Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,169 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+#ifndef _LED_H_
+#define _LED_H_
+
+#include "mbed.h"
+
+/**
+ * Driver for the HSP Led, supports different blink rates and patterns
+ *
+ * @code
+ * #include <stdio.h>
+ * #include "mbed.h"
+ * #include "xxx.h"
+ *
+ * I2C i2c(I2C_SDA, I2C_SCL);
+ * xxx xxx(&i2c);
+ *
+ * int main(void) {
+ * printf("Initialized xxx\n");
+ * while(1) {
+ * if (xxx.init() != 0) {
+ * printf("Error communicating with xxx\n");
+ * } else {
+ * printf("Initialized xxx\n");
+ * break;
+ * }
+ * wait(1);
+ * }
+ *
+ * while(1) {
+ * printf("");
+ * wait(1);
+ * }
+ * }
+ * @endcode
+ */
+
+class HspLed {
+public:
+ static const int LED_ON = 0;
+ static const int LED_OFF = 1;
+
+ /// define all of the modes the LED can support
+ typedef enum eMode {
+ eLedOn,
+ eLedOff,
+ eLedPeriod,
+ eLedPattern
+ } eMode;
+ /// define the values that turn the LED on or off at the pin
+ #define HSP_LED_ON 0
+ #define HSP_LED_OFF 1
+
+ /*
+ * @brief Constructor where you specify the LED pin name
+ */
+ HspLed(PinName ledPin);
+
+ /**
+ * Blink the HSP LED at a set time interval
+ * @param mSeconds Number of seconds to set the timer interval
+ */
+ void blink(uint32_t mSeconds);
+
+ /**
+ * @brief Start rotating the LED through a 32-bit pattern at a mS rate specified
+ * @param pattern 32-bit pattern to rotate through
+ * @param mSeconds the amount of time to take per bit in the pattern
+ */
+ void pattern(uint32_t pattern, uint32_t mSeconds);
+
+ /**
+ * @brief Turn the LED on
+ */
+ void on(void);
+
+ /**
+ * @brief Turn the LED off
+ */
+ void off(void);
+
+ /**
+ * @brief Update the LED
+ */
+ void service(void);
+
+private:
+
+ /**
+ * Set the mode of the LED, the mode include blinking at a set rate or blinking
+ * according to a pattern
+ * @param mode Mode to set the LED to
+ */
+ void setMode(eMode state);
+
+ /**
+ * Toggle the state of the LED
+ */
+ void toggle(void);
+
+ /**
+ * Start the LED blinking or rotating through a pattern
+ */
+ void start(void);
+
+ /**
+ * Stop blinking or rotating through a pattern
+ */
+ void stop(void);
+
+ /**
+ * Write the LED pin to a state
+ * @param state A one or zero value to write to the LED pin
+ */
+ void state(int state);
+
+ /*
+ * @brief Single step through the pattern and output to the LED
+ */
+ void patternToLed(void);
+
+ /// timer interval in mS
+ float timerInterval;
+ /// last timer interval set to... used to prevent resetting the timer to the same value
+ float timerIntervalLast;
+ /// local state of the pattern to rotate through
+ uint32_t bitPattern;
+ /// current mode of the LED
+ eMode mode;
+ /// the LED digital output
+ DigitalOut redLed;
+ /// Timer service used to update the LED
+ Ticker ticker;
+ /// Flag to indicate if the timer has been started
+ bool isStarted;
+};
+
+#endif /* _LED_H_ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/Devices/HspLed/HspLed_RPC.cpp Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,73 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+
+#include "HspLed_RPC.h"
+#include "HspLed.h"
+#include "StringHelper.h"
+#include "Peripherals.h"
+
+int Led_On(char argStrs[32][32], char replyStrs[32][32]) {
+ uint32_t reply[1];
+ Peripherals::hspLed()->on();
+ reply[0] = 0x80;
+ FormatReply32(reply, sizeof(reply) / sizeof(uint32_t), replyStrs);
+ return 0;
+}
+
+int Led_Off(char argStrs[32][32], char replyStrs[32][32]) {
+ uint32_t reply[1];
+ Peripherals::hspLed()->off();
+ reply[0] = 0x80;
+ FormatReply32(reply, sizeof(reply) / sizeof(uint32_t), replyStrs);
+ return 0;
+}
+
+int Led_BlinkHz(char argStrs[32][32], char replyStrs[32][32]) {
+ uint32_t args[1];
+ uint32_t reply[1];
+ ProcessArgs32(argStrs, args, sizeof(args) / sizeof(uint32_t));
+ Peripherals::hspLed()->blink(args[0]);
+ reply[0] = 0x80;
+ FormatReply32(reply, sizeof(reply) / sizeof(uint32_t), replyStrs);
+ return 0;
+}
+
+int Led_BlinkPattern(char argStrs[32][32], char replyStrs[32][32]) {
+ uint32_t args[2];
+ uint32_t reply[1];
+ ProcessArgs32(argStrs, args, sizeof(args) / sizeof(uint32_t));
+ Peripherals::hspLed()->pattern(args[0], args[1]);
+ reply[0] = 0x80;
+ FormatReply32(reply, sizeof(reply) / sizeof(uint32_t), replyStrs);
+ return 0;
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/HSP/Devices/HspLed/HspLed_RPC.h Tue Oct 25 15:22:11 2016 +0000 @@ -0,0 +1,43 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ +#ifndef _LED_RPC_H_ +#define _LED_RPC_H_ + +#include "mbed.h" + +int Led_On(char argStrs[32][32], char replyStrs[32][32]); +int Led_Off(char argStrs[32][32], char replyStrs[32][32]); +int Led_BlinkHz(char argStrs[32][32], char replyStrs[32][32]); +int Led_BlinkPattern(char argStrs[32][32], char replyStrs[32][32]); + +#endif /* _LED_RPC_H_ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/Devices/LIS2DH/LIS2DH/LIS2DH.cpp Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,278 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+
+#include "LIS2DH.h"
+#include "Streaming.h"
+#include "Peripherals.h"
+
+void lis2dh_int_handler(void);
+/** buffer array to hold fifo contents for packetizing
+*/
+uint32_t lis2dh_buffer[LIS2DH_MAX_DATA_SIZE];
+
+static int debug_int_count = 0;
+int16_t motion_cached[3];
+LIS2DH *LIS2DH::instance = NULL;
+
+//******************************************************************************
+LIS2DH::LIS2DH(PinName sda, PinName scl, int slaveAddress) :
+ slaveAddress(slaveAddress) {
+ i2c = new I2C(sda, scl);
+ i2c->frequency(400000);
+ isOwner = true;
+ instance = this;
+}
+
+//******************************************************************************
+LIS2DH::LIS2DH(I2C *i2c, int slaveAddress) :
+ slaveAddress(slaveAddress) {
+ this->i2c = i2c;
+ i2c->frequency(400000);
+ isOwner = false;
+ instance = this;
+}
+
+//******************************************************************************
+LIS2DH::~LIS2DH(void) {
+ if (isOwner == true) {
+ delete i2c;
+ }
+}
+
+//******************************************************************************
+int LIS2DH::writeReg(char reg, char value) {
+ int result;
+ char cmdData[2] = {(char)reg, value};
+ result = i2c->write(slaveAddress, cmdData, 2);
+ if (result != 0)
+ return -1;
+ return 0;
+}
+
+//******************************************************************************
+int LIS2DH::readReg(char reg, char *value) {
+ int result;
+ char cmdData[1] = {(char)reg};
+
+ result = i2c->write(slaveAddress, cmdData, 1);
+ if (result != 0)
+ return -1;
+ result = i2c->read(slaveAddress, value, 1);
+ if (result != 0)
+ return -1;
+ return 0;
+}
+
+//******************************************************************************
+static void I2c_Reset(uint8_t index, int speed) {
+ mxc_i2cm_regs_t *regs = MXC_I2CM_GET_I2CM(index);
+ /* reset module */
+ regs->ctrl = MXC_F_I2CM_CTRL_MSTR_RESET_EN;
+ regs->ctrl = 0;
+ /* enable tx_fifo and rx_fifo */
+ regs->ctrl |= (MXC_F_I2CM_CTRL_TX_FIFO_EN | MXC_F_I2CM_CTRL_RX_FIFO_EN);
+}
+
+//******************************************************************************
+// Interrupt handler, this empties the hardware fifo and packetizes it for
+// streaming
+void LIS2DH::int_handler(void) {
+ char fifo_src;
+ int16_t valueX;
+ int16_t valueY;
+ int16_t valueZ;
+ int num;
+ int index;
+
+ I2c_Reset(2, 1);
+ num = 0;
+ index = 0;
+ fifo_src = 0;
+ while ((fifo_src & 0x20) != 0x20) {
+ get_motion_fifo(&valueX, &valueY, &valueZ);
+ lis2dh_buffer[index++] = valueX;
+ lis2dh_buffer[index++] = valueY;
+ lis2dh_buffer[index++] = valueZ;
+ readReg(LIS2DH_FIFO_SRC_REG, &fifo_src);
+ num++;
+ if (num >= 32)
+ break;
+ }
+ motion_cached[0] = valueX;
+ motion_cached[1] = valueY;
+ motion_cached[2] = valueZ;
+
+ StreamPacketUint32(PACKET_LIS2DH, lis2dh_buffer, index);
+}
+
+//******************************************************************************
+void LIS2DH::init(void) {
+ stop();
+ configure_interrupt();
+}
+
+//******************************************************************************
+void LIS2DH::configure_interrupt(void) {
+ // interrupt enabled on INT1, interrupt active low
+ lis2dh_ctrl_reg6.all = 0;
+ lis2dh_ctrl_reg6.bit.I2_INT1 = 1; // interrupt 1 function enabled on int1 pin
+ lis2dh_ctrl_reg6.bit.H_LACTIVE = 1; // interrupt active low
+ writeReg(LIS2DH_CTRL_REG6, lis2dh_ctrl_reg6.all);
+}
+
+//******************************************************************************
+int LIS2DH::initStart(int dataRate, int fifoThreshold) {
+ __disable_irq();
+
+ configure_interrupt();
+
+ // enable FIFO
+ lis2dh_ctrl_reg5.all = 0x0;
+ lis2dh_ctrl_reg5.bit.FIFO_EN = 0x1;
+ if (writeReg(LIS2DH_CTRL_REG5, lis2dh_ctrl_reg5.all) == -1) {
+ __enable_irq();
+ return -1;
+ }
+
+ // set FIFO to stream mode, trigger select INT1
+ lis2dh_fifo_ctrl_reg.all = 0x0;
+ lis2dh_fifo_ctrl_reg.bit.FTH = fifoThreshold;
+ lis2dh_fifo_ctrl_reg.bit.FM = LIS2DH_FIFOMODE_STREAM;
+ lis2dh_fifo_ctrl_reg.bit.TR = 0x0;
+ if (writeReg(LIS2DH_FIFO_CTRL_REG, lis2dh_fifo_ctrl_reg.all) == -1) {
+ __enable_irq();
+ return -1;
+ }
+
+ // set HR (high resolution)
+ if (writeReg(LIS2DH_CTRL_REG4, 0x8) == -1) {
+ __enable_irq();
+ return -1;
+ }
+
+ // set the data rate, enable all axis
+ dataRate = dataRate & 0xF;
+ if (dataRate > 0x9) dataRate = 0x9;
+ lis2dh_ctrl_reg1.bit.ODR = dataRate; // set the data rate
+ lis2dh_ctrl_reg1.bit.LPen = 0x0; // disable low power mode
+ lis2dh_ctrl_reg1.bit.Zen = 0x1; // enable z
+ lis2dh_ctrl_reg1.bit.Yen = 0x1; // enable y
+ lis2dh_ctrl_reg1.bit.Xen = 0x1; // enable x
+ if (writeReg(LIS2DH_CTRL_REG1, lis2dh_ctrl_reg1.all) == -1) {
+ __enable_irq();
+ return -1;
+ }
+
+ // enable watermark interrupt
+ lis2dh_ctrl_reg3.all = 0x00;
+ lis2dh_ctrl_reg3.bit.I1_WTM = 0x1;
+ if (writeReg(LIS2DH_CTRL_REG3, lis2dh_ctrl_reg3.all) == -1) {
+ __enable_irq();
+ return -1;
+ }
+ __enable_irq();
+
+ return 0;
+}
+
+//******************************************************************************
+int LIS2DH::detect(char *detected) {
+ char val;
+ *detected = 0;
+ if (readReg(LIS2DH_WHO_AM_I, &val) == -1)
+ return -1;
+ if (val == LIS2DH_ID) *detected = 1;
+ return 0;
+}
+
+//******************************************************************************
+int LIS2DH::get_motion_cached(int16_t *valueX, int16_t *valueY,
+ int16_t *valueZ) {
+ *valueX = motion_cached[0];
+ *valueY = motion_cached[1];
+ *valueZ = motion_cached[2];
+ return 0;
+}
+
+//******************************************************************************
+int LIS2DH::get_motion_fifo(int16_t *valueX, int16_t *valueY, int16_t *valueZ) {
+ char reg = LIS2DH_OUT_X_L | 0x80;
+ char values[6];
+ int i;
+
+ reg = LIS2DH_OUT_X_L;
+ for (i = 0; i < 6; i++) {
+ if (readReg(reg, &values[i]) != 0) {
+ return -1;
+ }
+ reg++;
+ }
+
+ *valueX = ((short)values[1] << 8) + values[0];
+ *valueY = ((short)values[3] << 8) + values[2];
+ *valueZ = ((short)values[5] << 8) + values[4];
+ motion_cached[0] = *valueX;
+ motion_cached[1] = *valueY;
+ motion_cached[2] = *valueZ;
+ return 0;
+}
+
+//******************************************************************************
+// 0x33 = read ID
+char LIS2DH::readId(void) {
+ char val;
+ readReg(LIS2DH_WHO_AM_I, &val);
+ return val;
+}
+
+//******************************************************************************
+void LIS2DH::stop(void) {
+ __disable_irq();
+ writeReg(LIS2DH_CTRL_REG3, 0x00); // Disable watermark interrupt
+ writeReg(LIS2DH_CTRL_REG1, 0x00); // Data rate = 0Hz
+ writeReg(LIS2DH_FIFO_CTRL_REG,
+ 0x00); // set to bypass mode... clears FIFO_SRC_REG
+ __enable_irq();
+}
+
+//******************************************************************************
+void LIS2DHIntHandler(void) {
+ char value;
+ // read the data rate axis enable register, if this is zero then just return,
+ // we are not ready for interrupts
+ LIS2DH::instance->readReg(LIS2DH_CTRL_REG1, &value);
+ if (value == 0x0) {
+ return;
+ }
+ LIS2DH::instance->int_handler();
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/Devices/LIS2DH/LIS2DH/LIS2DH.h Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,462 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+
+#ifndef LIS2DH_H_
+#define LIS2DH_H_
+
+#include "mbed.h"
+
+/**
+ * Driver for the LIS2DH on the HSP Platform
+ *
+ * @code
+ * #include <stdio.h>
+ * #include "mbed.h"
+ * #include "xxx.h"
+ *
+ * I2C i2c(I2C_SDA, I2C_SCL);
+ * xxx xxx(&i2c);
+ *
+ * int main(void) {
+ * printf("Initialized xxx\n");
+ * while(1) {
+ * if (xxx.init() != 0) {
+ * printf("Error communicating with xxx\n");
+ * } else {
+ * printf("Initialized xxx\n");
+ * break;
+ * }
+ * wait(1);
+ * }
+ *
+ * while(1) {
+ * printf("");
+ * wait(1);
+ * }
+ * }
+ * @endcode
+ */
+
+void LIS2DHIntHandler(void);
+
+#define LIS2DH_READID 0x33
+
+/// @brief LIS2DH Register addresses
+#define LIS2DH_STATUS_REG_AUX 0x07
+#define LIS2DH_OUT_TEMP_L 0x0C
+#define LIS2DH_OUT_TEMP_H 0x0D
+#define LIS2DH_INT_COUNTER_REG 0x0E
+#define LIS2DH_WHO_AM_I 0x0F
+#define LIS2DH_TEMP_CFG_REG 0x1F
+#define LIS2DH_CTRL_REG1 0x20
+#define LIS2DH_CTRL_REG2 0x21
+#define LIS2DH_CTRL_REG3 0x22
+#define LIS2DH_CTRL_REG4 0x23
+#define LIS2DH_CTRL_REG5 0x24
+#define LIS2DH_CTRL_REG6 0x25
+#define LIS2DH_REFERENCE 0x26
+#define LIS2DH_STATUS_REG2 0x27
+#define LIS2DH_OUT_X_L 0x28
+#define LIS2DH_OUT_X_H 0x29
+#define LIS2DH_OUT_Y_L 0x2A
+#define LIS2DH_OUT_Y_H 0x2B
+#define LIS2DH_OUT_Z_L 0x2C
+#define LIS2DH_OUT_Z_H 0x2D
+#define LIS2DH_FIFO_CTRL_REG 0x2E
+#define LIS2DH_FIFO_SRC_REG 0x2F
+#define LIS2DH_INT1_CFG 0x30
+#define LIS2DH_INT1_SRC 0x31
+#define LIS2DH_INT1_THS 0x32
+#define LIS2DH_INT1_DURATION 0x33
+#define LIS2DH_INT2_CFG 0x34
+#define LIS2DH_INT2_SRC 0x35
+#define LIS2DH_INT2_THS 0x36
+#define LIS2DH_INT2_DURATION 0x37
+#define LIS2DH_CLICK_CFG 0x38
+#define LIS2DH_CLICK_SRC 0x39
+#define LIS2DH_CLICK_THS 0x3A
+#define LIS2DH_TIME_LIMIT 0x3B
+#define LIS2DH_TIME_LATENCY 0x3C
+#define LIS2DH_TIME_WINDOW 0x3D
+#define LIS2DH_Act_THS 0x3E
+#define LIS2DH_Act_DUR 0x3F
+
+#define LIS2DH_DATARATE_1HZ 0x1
+#define LIS2DH_DATARATE_10HZ 0x2
+#define LIS2DH_DATARATE_25HZ 0x3
+#define LIS2DH_DATARATE_50HZ 0x4
+#define LIS2DH_DATARATE_100HZ 0x5
+#define LIS2DH_DATARATE_200HZ 0x6
+#define LIS2DH_DATARATE_400HZ 0x7
+
+#define LIS2DH_FIFOMODE_BYPASS 0x00
+#define LIS2DH_FIFOMODE_FIFO 0x01
+#define LIS2DH_FIFOMODE_STREAM 0x02
+#define LIS2DH_FIFOMODE_TRIGGER 0x03
+
+#define LIS2DH_ID 0x33
+#define LIS2DH_FIFO_SIZE 32
+
+#define LISD2DH_FIFO_MODE_BYPASS 0
+#define LISD2DH_FIFO_MODE_FIFO 1
+#define LISD2DH_FIFO_MODE_STREAM 2
+#define LISD2DH_FIFO_MODE_TRIGGER 3
+
+#define LIS2DH_NUMBER_OF_AXIS 3
+#define LIS2DH_MAX_DATA_SIZE (LIS2DH_NUMBER_OF_AXIS * LIS2DH_FIFO_SIZE)
+
+class LIS2DH {
+public:
+ /// @brief STATUS_AUX (07h)
+ union lis2dh_status_aux_reg {
+ char all;
+ struct {
+ char reserved3 : 2;
+ char TDA : 1;
+ char reserved2 : 3;
+ char TOR : 1;
+ char reserved1 : 1;
+ } bit;
+ } lis2dh_status_aux;
+
+ /// @brief OUT_TEMP_L (0Ch)
+ union lis2dh_out_temp_l_reg {
+ char all;
+ } lis2dh_out_temp_l;
+
+ /// @brief OUT_TEMP_H (0Dh)
+ union lis2dh_out_temp_h_reg {
+ char all;
+ } lis2dh_out_temp_h;
+
+ /// @brief INT_COUNTER (0Eh)
+ union lis2dh_int_counter_reg {
+ char all;
+ } lis2dh_int_counter;
+
+ /// @brief WHO_AM_I (0Fh)
+ union lis2dh_who_am_i_reg {
+ char all;
+ } lis2dh_who_am_i;
+
+ /// @brief TEMP_CFG_REG (1Fh)
+ union lis2dh_temp_cfg_reg {
+ char all;
+ struct {
+ char reserved1 : 6;
+ char TEMP_EN0 : 1;
+ char TEMP_EN1 : 1;
+ } bit;
+ } lis2dh_temp_cfg;
+
+ /// @brief CTRL_REG1 (20h)
+ union lis2dh_ctrl_reg1_reg {
+ char all;
+ struct {
+ char Xen : 1;
+ char Yen : 1;
+ char Zen : 1;
+ char LPen : 1;
+ char ODR : 4;
+ } bit;
+ } lis2dh_ctrl_reg1;
+
+ /// @brief CTRL_REG1 (21h)
+ union lis2dh_ctrl_reg2_reg {
+ char all;
+ struct {
+ char HPIS : 3;
+ char HPCLICK : 1;
+ char FDS : 1;
+ char HPCF : 2;
+ char HPM : 2;
+ } bit;
+ } lis2dh_ctrl_reg2;
+
+ /// @brief CTRL_REG3 (22h)
+ union lis2dh_ctrl_reg3_reg {
+ char all;
+ struct {
+ char reserved : 1;
+ char I1_OVERRUN : 1;
+ char I1_WTM : 1;
+ char I1_DRDY : 2;
+ char I1_AOI : 1;
+ char I1_CLICK : 1;
+ } bit;
+ } lis2dh_ctrl_reg3;
+
+ /// @brief CTRL_REG4 (23h)
+ union lis2dh_ctrl_reg4_reg {
+ char all;
+ struct {
+ char SIM : 1;
+ char ST : 2;
+ char HR : 1;
+ char FS : 2;
+ char BLE : 1;
+ char BDU : 1;
+ } bit;
+ } lis2dh_ctrl_reg4;
+
+ /// @brief CTRL_REG5 (24h)
+ union lis2dh_ctrl_reg5_reg {
+ char all;
+ struct {
+ char D4D_INT2 : 1;
+ char LIR_INT2 : 1;
+ char D4D_INT1 : 1;
+ char LIR_INT1 : 1;
+ char reserved : 2;
+ char FIFO_EN : 1;
+ char BOOT : 1;
+ } bit;
+ } lis2dh_ctrl_reg5;
+
+ /// @brief CTRL_REG6 (25h)
+ union lis2dh_ctrl_reg6_reg {
+ char all;
+ struct {
+ char reserved1 : 1;
+ char H_LACTIVE : 1;
+ char reserved2 : 1;
+ char P2_ACT : 1;
+ char BOOT_I2 : 1;
+ char I2_INT2 : 2;
+ char I2_INT1 : 1;
+ char I2_CLICKen: 1;
+ } bit;
+ } lis2dh_ctrl_reg6;
+
+ /// @brief REFERENCE (26h)
+ union lis2dh_reference_reg {
+ char all;
+ } lis2dh_reference;
+
+ /// @brief STATUS_REG (27h)
+ union lis2dh_status_reg_ {
+ char all;
+ struct {
+ char XDA : 1;
+ char YDA : 1;
+ char ZDA : 1;
+ char ZYXDA : 1;
+ char XOR : 1;
+ char YOR : 1;
+ char ZOR : 1;
+ char ZYXOR : 1;
+ } bit;
+ } lis2dh_status_reg;
+
+ /// @brief OUT_X_L (28h)
+ union lis2dh_out_x_l_ {
+ char all;
+ } lis2dh_out_x_l;
+
+ /// @brief OUT_X_H (29h)
+ union lis2dh_out_x_h_ {
+ char all;
+ } lis2dh_out_x_h;
+
+ /// @brief OUT_Y_L (2Ah)
+ union lis2dh_out_y_l_ {
+ char all;
+ } lis2dh_out_y_l;
+
+ /// @brief OUT_Y_H (2Bh)
+ union lis2dh_out_y_h_ {
+ char all;
+ } lis2dh_out_y_h;
+
+ /// @brief OUT_Z_L (2Ch)
+ union lis2dh_out_z_l_ {
+ char all;
+ } lis2dh_out_z_l;
+
+ /// @brief OUT_Z_H (2Dh)
+ union lis2dh_out_z_h_ {
+ char all;
+ } lis2dh_out_z_h;
+
+ /// @brief FIFO_CTRL_REG (2Eh)
+ union lis2dh_fifo_ctrl_reg_ {
+ char all;
+ struct {
+ char FTH : 5;
+ char TR : 1;
+ char FM : 2;
+ } bit;
+ } lis2dh_fifo_ctrl_reg;
+
+ /// @brief FIFO_CTRL_REG (2Fh)
+ union lis2dh_fifo_src_reg_ {
+ char all;
+ struct {
+ char FSS : 5;
+ char EMPTY : 1;
+ char OVRN_FIFO : 1;
+ char WTM : 1;
+ } bit;
+ } lis2dh_fifo_src_reg;
+
+ /// @brief INT1_CFG (30h)
+ union lis2dh_int1_cfg_reg_ {
+ char all;
+ struct {
+ char XLIE_XDOWNE : 1;
+ char XHIE_XUPE : 1;
+ char YLIE_YDOWNE : 1;
+ char YHIE_YUPE : 1;
+ char ZLIE_ZDOWNE : 1;
+ char ZHIE_ZUPE : 1;
+ char SIXD : 1;
+ char AOI : 1;
+ } bit;
+ } lis2dh_int1_cfg;
+
+ /// @brief INT1_SRC (31h)
+ union lis2dh_int1_src_reg_ {
+ char all;
+ struct {
+ char XL : 1;
+ char XH : 1;
+ char YL : 1;
+ char YH : 1;
+ char ZL : 1;
+ char ZH : 1;
+ char IA : 1;
+ char reserved : 1;
+ } bit;
+ } lis2dh_int1_src;
+
+ /// @brief INT1_THS (32h)
+ union lis2dh_int1_ths_reg_ {
+ char all;
+ } lis2dh_int1_ths;
+
+ /// @brief INT1_DURATION (33h)
+ union lis2dh_int1_duration_reg_ {
+ char all;
+ } lis2dh_int1_duration;
+
+ /// @brief INT2_CFG (34h)
+ union lis2dh_int2_cfg_reg_ {
+ char all;
+ struct {
+ char XLIE : 1;
+ char XHIE : 1;
+ char YLIE : 1;
+ char YHIE : 1;
+ char ZLIE : 1;
+ char ZHIE : 1;
+ char SIX6 : 1;
+ char AOI : 1;
+ } bit;
+ } lis2dh_int2_cfg;
+
+ /// @brief INT2_SRC (35h)
+ union lis2dh_int2_src_reg_ {
+ char all;
+ struct {
+ char XL : 1;
+ char XH : 1;
+ char YL : 1;
+ char YH : 1;
+ char ZL : 1;
+ char ZH : 1;
+ char IA : 1;
+ char reserved : 1;
+ } bit;
+ } lis2dh_int2_src;
+
+ /// @brief INT2_THS (36h)
+ union lis2dh_int2_ths_reg_ {
+ char all;
+ } lis2dh_int2_ths;
+
+ /// @brief INT2_DURATION (37h)
+ union lis2dh_int2_duration_reg_ {
+ char all;
+ } lis2dh_int2_duration;
+
+ LIS2DH(PinName sda, PinName scl, int slaveAddress);
+ LIS2DH(I2C *i2c, int slaveAddress);
+ ~LIS2DH(void);
+
+ /** @brief Initialize the device
+ */
+ void init(void);
+ /** @brief Interrupt handler
+ */
+ void int_handler(void);
+ /** @brief Get motion data from the device fifo
+ */
+ int get_motion_fifo(short *valueX, short *valueY, short *valueZ);
+ /** @brief Get the last cached motion values (cached from a previous interrupt
+ * event)
+ */
+ int get_motion_cached(int16_t *valueX, int16_t *valueY, int16_t *valueZ);
+ /** @brief Star Interrupts
+ */
+ int initStart(int dataRate, int fifoThreshold);
+ /** @brief Stop interrupts
+ */
+ void stop(void);
+ /** @brief Read device register
+ */
+ int readReg(char reg, char *value);
+ /** @brief Write device regsiter
+ */
+ int writeReg(char reg, char value);
+ /** @brief Detect if device exists
+ */
+ int detect(char *detected);
+ /** @brief Read the device ID
+ */
+ char readId(void);
+
+ static LIS2DH *instance;
+
+private:
+ /** @brief
+ */
+ void configure_interrupt(void);
+ /// I2C pointer
+ I2C *i2c;
+ /// Is this object the owner of the I2C object
+ bool isOwner;
+ /// Device slave address
+ int slaveAddress;
+};
+
+#endif /* LIS2DH_H_ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/Devices/LIS2DH/LIS2DH_RPC.cpp Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,89 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+
+#include "mbed.h"
+#include "LIS2DH.h"
+#include "StringInOut.h"
+#include "StringHelper.h"
+#include "Peripherals.h"
+
+#define LIS2DH_SLAVE_ADDRESS 0x32
+#define LIS2DH_REG_PART_ID 0x0F
+
+//******************************************************************************
+int LIS2DH_ReadReg(char argStrs[32][32], char replyStrs[32][32]) {
+ uint8_t args[1];
+ uint8_t reply[1];
+ ProcessArgs(argStrs, args, sizeof(args));
+ LIS2DH *lis2dh = Peripherals::lis2dh();
+ lis2dh->readReg(args[0], (char *)reply);
+ FormatReply(reply, sizeof(reply), replyStrs);
+ return 0;
+}
+
+//******************************************************************************
+int LIS2DH_WriteReg(char argStrs[32][32], char replyStrs[32][32]) {
+ uint8_t args[2];
+ uint8_t reply[1];
+ ProcessArgs(argStrs, args, sizeof(args));
+ LIS2DH *lis2dh = Peripherals::lis2dh();
+ lis2dh->writeReg(args[0], args[1]); // pass in the register address
+ reply[0] = 0x80;
+ FormatReply(reply, sizeof(reply), replyStrs);
+ return 0;
+}
+
+extern int highDataRate;
+//******************************************************************************
+int LIS2DH_InitStart(char argStrs[32][32], char replyStrs[32][32]) {
+ uint8_t args[2];
+ uint8_t reply[1];
+ ProcessArgs(argStrs, args, sizeof(args));
+ LIS2DH *lis2dh = Peripherals::lis2dh();
+ if (args[0] >= LIS2DH_DATARATE_200HZ)
+ highDataRate = 1;
+ lis2dh->initStart(args[0], args[1]);
+ reply[0] = 0x80;
+ FormatReply(reply, sizeof(reply), replyStrs);
+ return 0;
+}
+
+//******************************************************************************
+int LIS2DH_Stop(char argStrs[32][32], char replyStrs[32][32]) {
+ uint8_t reply[1];
+ LIS2DH *lis2dh = Peripherals::lis2dh();
+ lis2dh->stop();
+ reply[0] = 0x80;
+ FormatReply(reply, sizeof(reply), replyStrs);
+ return 0;
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/HSP/Devices/LIS2DH/LIS2DH_RPC.h Tue Oct 25 15:22:11 2016 +0000 @@ -0,0 +1,43 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ +#ifndef _LIS2HD_H_ +#define _LIS2HD_H_ + +#include "mbed.h" + +int LIS2DH_ReadReg(char argStrs[32][32], char replyStrs[32][32]); +int LIS2DH_WriteReg(char argStrs[32][32], char replyStrs[32][32]); +int LIS2DH_InitStart(char argStrs[32][32], char replyStrs[32][32]); +int LIS2DH_Stop(char argStrs[32][32], char replyStrs[32][32]); + +#endif /* _LIS2HD_H_ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/Devices/MAX14720/MAX14720/MAX14720.cpp Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,198 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+
+#include "MAX14720.h"
+
+//******************************************************************************
+MAX14720::MAX14720(PinName sda, PinName scl, int slaveAddress) :
+ slaveAddress(slaveAddress) {
+ i2c = new I2C(sda, scl);
+ isOwner = true;
+ clkDivEn = false;
+ clkDivSet = 0;
+ boostISet = BOOST_ISET_100mA;
+ boostMillivolts = 3300;
+ boostEn = BOOST_DISABLED;
+ boostEMI = false;
+ boostInd = false;
+ boostHysOff = false;
+ boostPasDsc = false;
+ boostActDsc = false;
+ buckMd = BUCK_BURST;
+ buckFst = false;
+ buckISet = BUCK_ISET_300mA;
+ buckCfg = false;
+ buckInd = false;
+ buckHysOff = true;
+ buckMinOT = true;
+ buckInteg = true;
+ buckPasDsc = false;
+ buckActDsc = false;
+ buckFScl = false;
+}
+//******************************************************************************
+MAX14720::MAX14720(I2C *i2c, int slaveAddress) : slaveAddress(slaveAddress) {
+ this->i2c = i2c;
+ isOwner = false;
+ clkDivEn = false;
+ clkDivSet = 0;
+ boostISet = BOOST_ISET_100mA;
+ boostMillivolts = 3300;
+ boostEn = BOOST_DISABLED;
+ boostEMI = false;
+ boostInd = false;
+ boostHysOff = false;
+ boostPasDsc = false;
+ boostActDsc = false;
+ buckMd = BUCK_BURST;
+ buckFst = false;
+ buckISet = BUCK_ISET_300mA;
+ buckCfg = false;
+ buckInd = false;
+ buckHysOff = true;
+ buckMinOT = true;
+ buckInteg = true;
+ buckPasDsc = false;
+ buckActDsc = false;
+ buckFScl = false;
+}
+//******************************************************************************
+MAX14720::~MAX14720() {
+ if (isOwner == true) {
+ delete i2c;
+ }
+}
+
+//******************************************************************************
+int MAX14720::boostSetMode(boostEn_t mode) {
+ int result;
+ char data;
+ boostEn = mode;
+ data = (boostEn << 3) | (boostEMI << 1) | (boostInd);
+ result = writeReg(REG_BOOST_CFG, data);
+ if (result == MAX14720_ERROR) return result;
+ return 0;
+}
+
+//******************************************************************************
+int MAX14720::boostSetVoltage(int mV) {
+ int result;
+ char data;
+ if ((MAX14720_BOOST_MIN_MV <= mV) && (mV <= MAX14720_BOOST_MAX_MV)) {
+ boostMillivolts = mV;
+ data = (mV - MAX14720_BOOST_MIN_MV) / MAX14720_BOOST_STEP_MV;
+ } else {
+ return MAX14720_ERROR;
+ }
+ if (boostEn == BOOST_ENABLED) {
+ result = writeReg(REG_BOOST_CFG, 0x00);
+ }
+ if (result == MAX14720_ERROR) return result;
+ result = writeReg(REG_BOOST_VSET, data);
+ if (result == MAX14720_ERROR) return result;
+ if (boostEn == BOOST_ENABLED) {
+ data = (boostEn << 3) | (boostEMI << 1) | (boostInd);
+ result = writeReg(REG_BOOST_CFG, data);
+ }
+ if (result == MAX14720_ERROR) return result;
+ return 0;
+}
+
+//******************************************************************************
+int MAX14720::init() {
+ int result;
+ char data;
+ data = (clkDivEn << 7) | (clkDivSet);
+ result = writeReg(REG_BOOST_CDIV, data);
+ if (result == MAX14720_ERROR) return result;
+ data = (boostISet);
+ result = writeReg(REG_BOOST_ISET, data);
+ if (result == MAX14720_ERROR)return result;
+ if ((MAX14720_BOOST_MIN_MV <= boostMillivolts) &&
+ (boostMillivolts <= MAX14720_BOOST_MAX_MV)) {
+ data = (boostMillivolts - MAX14720_BOOST_MIN_MV) / MAX14720_BOOST_STEP_MV;
+ } else {
+ return MAX14720_ERROR;
+ }
+ result = writeReg(REG_BOOST_VSET, data);
+ if (result == MAX14720_ERROR) return result;
+ data = (buckMd << 1) | (buckFst);
+ result = writeReg(REG_BUCK_CFG, data);
+ if (result == MAX14720_ERROR) return result;
+ data = (boostHysOff << 7) | (boostPasDsc << 6) | (boostActDsc << 5) |
+ (buckPasDsc << 2) | (buckActDsc << 1) | (buckFScl);
+ result = writeReg(REG_BBB_EXTRA, data);
+ if (result == MAX14720_ERROR) return result;
+ // Write Boost Enable Register Last
+ data = (boostEn << 3) | (boostEMI << 1) | (boostInd);
+ result = writeReg(REG_BOOST_CFG, data);
+ if (result == MAX14720_ERROR) return result;
+ return 0;
+}
+
+//******************************************************************************
+int MAX14720::monSet(monCfg_t monCfg) {
+ int result;
+ result = writeReg(REG_MON_CFG, monCfg);
+ if (result == MAX14720_ERROR) return result;
+ return 0;
+}
+
+//******************************************************************************
+int MAX14720::shutdown() {
+ int result;
+ result = writeReg(REG_PWR_OFF, 0xB2);
+ if (result == MAX14720_ERROR) return result;
+ return 0;
+}
+
+//******************************************************************************
+int MAX14720::writeReg(registers_t reg, char value) {
+ int result;
+ char cmdData[2] = {(char)reg, value};
+ result = i2c->write(slaveAddress, cmdData, 2);
+ if (result != 0) return MAX14720_ERROR;
+ return MAX14720_NO_ERROR;
+}
+
+//******************************************************************************
+int MAX14720::readReg(registers_t reg, char *value) {
+ int result;
+ char cmdData[1] = {(char)reg};
+
+ result = i2c->write(slaveAddress, cmdData, 1);
+ if (result != 0) return MAX14720_ERROR;
+ result = i2c->read(slaveAddress, value, 1);
+ if (result != 0) return MAX14720_ERROR;
+ return MAX14720_NO_ERROR;
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/Devices/MAX14720/MAX14720/MAX14720.h Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,317 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+
+#ifndef _MAX14720_H_
+#define _MAX14720_H_
+
+#include "mbed.h"
+
+#define MAX14720_NO_ERROR 0
+#define MAX14720_ERROR -1
+
+#define MAX14720_BOOST_MIN_MV 2500
+#define MAX14720_BOOST_MAX_MV 5000
+#define MAX14720_BOOST_STEP_MV 100
+
+/**
+ * MAX14720 PMIC Driver
+ *
+ * @code
+ * #include "mbed.h"
+ * #include "MAX14720.h"
+ *
+ * // I2C Master 2
+ * I2C i2c2(I2C2_SDA, I2C2_SCL);
+ *
+ * #define I2C_ADDR_PMIC (0x54)
+ * MAX14720 max14720(&i2c2,I2C_ADDR_PMIC);
+ *
+ * DigitalOut led(LED1);
+ * InterruptIn button(SW1);
+ *
+ * void turnOff()
+ * {
+ * max14720.shutdown();
+ * }
+ *
+ * int main()
+ * {
+ * int result;
+ * button.fall(&turnOff);
+ * led = 0;
+ * max14720.boostEn = MAX14720::BOOST_ENABLED;
+ * result = max14720.init();
+ * if (result == MAX14720_ERROR) printf("Error initializing MAX14720");
+ * wait(1);
+ * while(1) {
+ * max14720.boostSetMode(MAX14720::BOOST_DISABLED);
+ * max14720.boostEn = MAX14720::BOOST_ENABLED;
+ * wait(0.5);
+ * max14720.boostSetVoltage(2500);
+ * wait(0.5);
+ * max14720.boostSetVoltage(5000);
+ * wait(0.5);
+ * }
+ * }
+ * @endcode
+ */
+class MAX14720 {
+
+public:
+ /**
+ *@brief Register Addresses
+ *@details Enumerated MAX14720 register addresses
+ */
+ typedef enum {
+ REG_CHIP_ID = 0x00, ///< Chip ID
+ REG_CHIP_REV = 0x01, ///< Chip Revision
+ REG_BOOST_CDIV = 0x03, ///< Boost Clock Divider
+ REG_BOOST_ISET = 0x04, ///< Boost Peak Current
+ REG_BOOST_VSET = 0x05, ///< Boost Voltage Setting
+ REG_BOOST_CFG = 0x06, ///< Boost Configuration
+ REG_BUCK_VSET = 0x07, ///< Buck Voltage Setting
+ REG_BUCK_CFG = 0x08, ///< Buck Configuration
+ REG_BUCK_ISET = 0x09, ///< Buck Peak Current and Settings
+ REG_LDO_VSET = 0x0A, ///< LDO Voltage Setting
+ REG_LDO_CFG = 0x0B, ///< LDO Configuration
+ REG_SWITCH_CFG = 0x0C, ///< Switch Configuration
+ REG_BAT_TIME = 0x0D, ///< Battery Impedance Timing
+ REG_BAT_CFG = 0x0E, ///< Battery Impedance Configuration
+ REG_BAT_BCV = 0x0F, ///< Battery Cell Voltage
+ REG_BAT_OCV = 0x10, ///< Open Cell Voltage
+ REG_BAT_LCV = 0x11, ///< Loaded Cell Voltage
+ REG_MON_CFG = 0x19, ///< Monitor Multiplexer Configuration
+ REG_BOOT_CFG = 0x1A, ///< Boot Configuration
+ REG_PIN_STAT = 0x1B, ///< Pin Status
+ REG_BBB_EXTRA = 0x1C, ///< Buck/Buck-Boost Extra
+ REG_HANDSHK = 0x1D, ///< Power-On Handshake
+ REG_UVLO_CFG = 0x1E, ///< Under-Voltage Lock Out
+ REG_PWR_OFF = 0x1F, ///< Power Off Command
+ } registers_t;
+
+ /**
+ *@brief Boost Peak Current Settings
+ *@details Enumerated peak current settings for boost regulator
+ */
+ typedef enum {
+ BOOST_ISET_MIN, ///< Minimum On-Time
+ BOOST_ISET_50mA, ///< 50mA Peak Current
+ BOOST_ISET_100mA, ///< 100mA Peak Current
+ BOOST_ISET_150mA, ///< 150mA Peak Current
+ BOOST_ISET_200mA, ///< 200mA Peak Current
+ BOOST_ISET_250mA, ///< 250mA Peak Current
+ BOOST_ISET_300mA, ///< 300mA Peak Current
+ BOOST_ISET_350mA, ///< 350mA Peak Current
+ } boostISet_t;
+
+ /**
+ *@brief Boost Enable Mode
+ *@details Enumerated enable modes for boost regulator
+ */
+ typedef enum {
+ BOOST_DISABLED, ///< Boost Disabled
+ BOOST_ENABLED, ///< Boost Enabled
+ BOOST_EN_MPC, ///< Boost Enabled by MPC pin
+ } boostEn_t;
+
+ /**
+ *@brief Buck Operating Modes
+ *@details Enumerated operating modes for buck regulator
+ */
+ typedef enum {
+ BUCK_BURST, ///< Burst Mode Operation
+ BUCK_FPWM, ///< Forced PWM Operation
+ BUCK_MPC_FPWM, ///< MPC activated Forced PWM
+ } buckMd_t;
+
+ /**
+ *@brief Buck Peak Current Settings
+ *@details Enumerated peak current settings for buck regulator
+ */
+ typedef enum {
+ BUCK_ISET_50mA, ///< 50mA Peak Current
+ BUCK_ISET_100mA, ///< 100mA Peak Current
+ BUCK_ISET_150mA, ///< 150mA Peak Current
+ BUCK_ISET_200mA, ///< 200mA Peak Current
+ BUCK_ISET_250mA, ///< 250mA Peak Current
+ BUCK_ISET_300mA, ///< 300mA Peak Current
+ BUCK_ISET_350mA, ///< 350mA Peak Current
+ BUCK_ISET_400mA, ///< 400mA Peak Current
+ } buckISet_t;
+
+ /**
+ *@brief Monitor Configurations
+ *@details Enumerated configuration modes for monitor multiplexer
+ */
+ typedef enum {
+ MON_PULLDOWN = 0x00, ///< Pulled down by 100k Ohm
+ MON_HI_Z = 0x08, ///< High Impedance
+ MON_SWIN = 0x80, ///< SWIN Selected
+ MON_SWOUT = 0x81, ///< SWOUT Selected
+ MON_BIN = 0x82, ///< BIN Selected
+ MON_BOUT = 0x83, ///< BOUT Selected
+ MON_HVIN = 0x84, ///< HVIN Selected
+ MON_HVOUT = 0x85, ///< HVOUT Selected
+ MON_LIN = 0x86, ///< LIN Selected
+ MON_LOUT = 0x87, ///< LOUT Selected
+ } monCfg_t;
+
+ /**
+ *@brief Under-Voltage Lock Out Input
+ *@details Enumerated input selection options for UVLO
+ */
+ typedef enum {
+ LIN_UVLO, ///< LIN used to determine UVLO condition
+ BIN_UVLO, ///< BIN used to determine UVLO condition
+ } uvloIn_t;
+
+ /**
+ * @brief MAX14720 constructor.
+ *
+ * @param sda mbed pin to use for SDA line of I2C interface.
+ * @param scl mbed pin to use for SCL line of I2C interface.
+ * @param slaveAddress Slave Address of the device.
+ */
+ MAX14720(PinName sda, PinName scl, int slaveAddress);
+
+ /**
+ * @brief MAX14720 constructor.
+ *
+ * @param i2c I2C object to use.
+ * @param slaveAddress Slave Address of the device.
+ */
+ MAX14720(I2C *i2c, int slaveAddress);
+
+ /**
+ * @brief MAX14720 destructor.
+ */
+ ~MAX14720();
+
+ /**
+ * @brief Initialize MAX14720
+ * @details Applies settings to MAX14720.
+ * Settings are stored in public variables.
+ * The variables are pre-loaded with the most common configuation.
+ * Assign new values to the public variables before calling init.
+ * @returns 0 if no errors, -1 if error.
+ */
+ int init();
+
+ /**
+ * @brief Set the Boost Voltage
+ * @details Sets the voltage for the boost regulator.
+ * The voltage is specified in millivoltst.
+ * The MAX14720 cannot update the voltage when enabled.
+ * This function checks the local boostEn variable and if the
+ * regualtor is enabled it will send the disable command before
+ * sending the new voltage and re-enable the boost regulator after
+ * the new voltage is written.
+ * @param mV voltage for boost regualtor in millivolts
+ * @returns 0 if no errors, -1 if error.
+ */
+ int boostSetVoltage(int mV);
+
+ /**
+ * @brief Set Boost Enable Mode
+ * @details Sets the enable mode for the boost regulator
+ * @param mode The enable mode for the boost regulator
+ * @returns 0 if no errors, -1 if error.
+ */
+ int boostSetMode(boostEn_t mode);
+
+ /**
+ * @brief Configure Mon Pin
+ * @details Configures the operating mode of the monitor multiplexer
+ * @param monCfg The configuration mode for the monitor pin
+ * @returns 0 if no errors, -1 if error.
+ */
+ int monSet(monCfg_t monCfg);
+
+ /**
+ * @brief Shutdown
+ * @details Sends the command to turn off all supplies and put the part
+ * in battery saving shelf mode.
+ * @returns 0 if no errors, -1 if error.
+ */
+ int shutdown();
+
+ /**
+ * @brief Write Register
+ * @details Writes the given value to the specified register
+ * @param reg The register to be written
+ * @param value The data to be written
+ * @returns 0 if no errors, -1 if error.
+ */
+ int writeReg(registers_t reg, char value);
+
+ /**
+ * @brief Read Register
+ * @details Reads from the specified register
+ * @param reg The register to be read
+ * @param value Pointer for where to store the data
+ * @returns 0 if no errors, -1 if error.
+ */
+ int readReg(registers_t reg, char *value);
+
+ bool clkDivEn; /// Boost Clock Divider Enable
+ int clkDivSet; /// Boost Clock Divider Setting
+ boostISet_t boostISet; /// Boost Peak Current Setting
+ int boostMillivolts; /// Boost Voltage in millivolts
+ boostEn_t boostEn; /// Boost Enable Mode
+ bool boostEMI, /// Boost EMI Setting
+ boostInd, /// Boost Inductor Setting
+ boostHysOff, /// Boost Hysteresis Off
+ boostPasDsc, /// Boost Passive Discharge
+ boostActDsc; /// Boost Active Discharge
+ buckMd_t buckMd; /// Buck Operating Mode
+ bool buckFst; /// Buck Fast Start
+ buckISet_t buckISet; /// Buck Peak Current Setting
+ bool buckCfg, /// Buck Configuration (Set to 1 when using FPWM mode)
+ buckInd, /// Buck Inductor Setting
+ buckHysOff, /// Buck Hysteresis Off
+ buckMinOT, /// Buck Minimum On Time
+ buckInteg, /// Buck Integrate
+ buckPasDsc, /// Buck Passive Discharge
+ buckActDsc, /// Buck Active Discharge
+ buckFScl; /// Buck Fet Scaling
+
+private:
+ /// I2C pointer
+ I2C *i2c;
+ /// Is this object the owner of the I2C object
+ bool isOwner;
+ /// Device slave address
+ int slaveAddress;
+};
+
+#endif /* _MAX14720_H_ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/Devices/MAX14720/MAX14720_RPC.cpp Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,115 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+
+#include "MAX14720_RPC.h"
+#include "MAX14720.h"
+#include "StringHelper.h"
+#include "Peripherals.h"
+#include "Device_Logging.h"
+
+/**
+* @brief Read the identification of the s25fs512 using quad spi
+* @param argStrs incoming rpc argument strings
+* OUTPUT:
+* replyStrs: strings that get returned to the rpc caller
+* @return 0 if successful, -1 if error
+*/
+int MAX14720_ReadBoostVSet(char argStrs[32][32], char replyStrs[32][32]) {
+ uint8_t args[1];
+ uint8_t reply[1];
+ //MAX14720::BoostVSet_Values value;
+
+ ProcessArgs(argStrs, args, sizeof(args));
+ //Peripherals::max14720()->readBoostVSet(&value);
+ //reply[0] = (char)value;
+ FormatReply(reply, sizeof(reply), replyStrs);
+ return 0;
+}
+
+/**
+* @brief Read the identification of the s25fs512 using quad spi
+* @param argStrs incoming rpc argument strings
+* OUTPUT:
+* replyStrs: strings that get returned to the rpc caller
+* @return 0 if successful, -1 if error
+*/
+int MAX14720_WriteBoostVSet(char argStrs[32][32], char replyStrs[32][32]) {
+ uint8_t args[1];
+ uint8_t reply[1];
+
+ ProcessArgs(argStrs, args, sizeof(args));
+ // Peripherals::max14720()->boostEn(MAX14720::BoostEn_Disable);
+ // Peripherals::max14720()->boostVSet((MAX14720::BoostVSet_Values)args[0]);
+ // Peripherals::max14720()->boostEn(MAX14720::BoostEn_Enable);
+ reply[0] = 0x80;
+ FormatReply(reply, sizeof(reply), replyStrs);
+ return 0;
+}
+
+/**
+* @brief Read the identification of the s25fs512 using quad spi
+* @param argStrs incoming rpc argument strings
+* OUTPUT:
+* replyStrs: strings that get returned to the rpc caller
+* @return 0 if successful, -1 if error
+*/
+int MAX14720_ReadReg(char argStrs[32][32], char replyStrs[32][32]) {
+ uint8_t args[1];
+ uint8_t reply[1];
+ char address;
+ char value;
+
+ ProcessArgs(argStrs, args, sizeof(args));
+ // Peripherals::max14720()->readReg((MAX14720::MAX14720_REG_map_t)address,&value);
+ reply[0] = (char)value;
+ FormatReply(reply, sizeof(reply), replyStrs);
+ return 0;
+}
+
+/**
+* @brief Read the identification of the s25fs512 using quad spi
+* @param argStrs incoming rpc argument strings
+* OUTPUT:
+* replyStrs: strings that get returned to the rpc caller
+* @return 0 if successful, -1 if error
+*/
+int MAX14720_WriteReg(char argStrs[32][32], char replyStrs[32][32]) {
+ uint8_t args[2];
+ uint8_t reply[1];
+
+ ProcessArgs(argStrs, args, sizeof(args));
+ // Peripherals::max14720()->writeReg((MAX14720::MAX14720_REG_map_t)args[0],args[1]);
+ reply[0] = 0x80;
+ FormatReply(reply, sizeof(reply), replyStrs);
+ return 0;
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/HSP/Devices/MAX14720/MAX14720_RPC.h Tue Oct 25 15:22:11 2016 +0000 @@ -0,0 +1,43 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ +#ifndef _MAX14720_RPC_H_ +#define _MAX14720_RPC_H_ + +#include "mbed.h" + +int MAX14720_ReadBoostVSet(char argStrs[32][32], char replyStrs[32][32]); +int MAX14720_WriteBoostVSet(char argStrs[32][32], char replyStrs[32][32]); +int MAX14720_ReadReg(char argStrs[32][32], char replyStrs[32][32]); +int MAX14720_WriteReg(char argStrs[32][32], char replyStrs[32][32]); + +#endif /* _MAX14720_RPC_H_ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/Devices/MAX30001/MAX30001/MAX30001.cpp Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,1317 @@
+
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+
+#include "mbed.h"
+#include "MAX30001.h"
+
+MAX30001 *MAX30001::instance = NULL;
+
+//******************************************************************************
+MAX30001::MAX30001(PinName mosi, PinName miso, PinName sclk, PinName cs) {
+ spi = new SPI(mosi, miso, sclk, cs);
+ spi->frequency(3000000);
+ spi_owner = true;
+ functionpointer.attach(&spiHandler);
+ onDataAvailableCallback = NULL;
+ instance = this;
+}
+
+//******************************************************************************
+MAX30001::MAX30001(SPI *_spi) {
+ spi = _spi;
+ spi->frequency(3000000);
+ spi_owner = false;
+ functionpointer.attach(&spiHandler);
+ onDataAvailableCallback = NULL;
+ instance = this;
+}
+
+//******************************************************************************
+MAX30001::~MAX30001(void) {
+ if (spi_owner) {
+ delete spi;
+ }
+}
+
+//******************************************************************************
+int MAX30001::max30001_Rbias_FMSTR_Init(uint8_t En_rbias, uint8_t Rbiasv,
+ uint8_t Rbiasp, uint8_t Rbiasn,
+ uint8_t Fmstr) {
+ if (max30001_reg_read(CNFG_GEN, &max30001_cnfg_gen.all) == -1) {
+ return -1;
+ }
+
+ max30001_cnfg_gen.bit.en_rbias = En_rbias;
+ max30001_cnfg_gen.bit.rbiasv = Rbiasv;
+ max30001_cnfg_gen.bit.rbiasp = Rbiasp;
+ max30001_cnfg_gen.bit.rbiasn = Rbiasn;
+ max30001_cnfg_gen.bit.fmstr = Fmstr;
+
+ if (max30001_reg_write(CNFG_GEN, max30001_cnfg_gen.all) == -1) {
+ return -1;
+ }
+ return 0;
+}
+
+//******************************************************************************
+int MAX30001::max30001_CAL_InitStart(uint8_t En_Vcal, uint8_t Vmode,
+ uint8_t Vmag, uint8_t Fcal, uint16_t Thigh,
+ uint8_t Fifty) {
+ // CNFG_CAL
+ if (max30001_reg_read(CNFG_CAL, &max30001_cnfg_cal.all) == -1) {
+ return -1;
+ }
+
+ max30001_cnfg_cal.bit.vmode = Vmode;
+ max30001_cnfg_cal.bit.vmag = Vmag;
+ max30001_cnfg_cal.bit.fcal = Fcal;
+ max30001_cnfg_cal.bit.thigh = Thigh;
+ max30001_cnfg_cal.bit.fifty = Fifty;
+
+ if (max30001_reg_write(CNFG_CAL, max30001_cnfg_cal.all) == -1) {
+ return -1;
+ }
+
+ // RTOS uses a 32768HZ clock. 32768ticks represents 1secs. 1sec/10 =
+ // 100msecs.
+ wait(1.0 / 10.0);
+
+ if (max30001_reg_read(CNFG_CAL, &max30001_cnfg_cal.all) == -1) {
+ return -1;
+ }
+
+ max30001_cnfg_cal.bit.en_vcal = En_Vcal;
+
+ if (max30001_reg_write(CNFG_CAL, max30001_cnfg_cal.all) == -1) {
+ return -1;
+ }
+
+ // RTOS uses a 32768HZ clock. 32768ticks represents 1secs. 1sec/10 =
+ // 100msecs.
+ wait(1.0 / 10.0);
+
+ return 0;
+}
+
+//******************************************************************************
+int MAX30001::max30001_CAL_Stop(void) {
+
+ if (max30001_reg_read(CNFG_CAL, &max30001_cnfg_cal.all) == -1) {
+ return -1;
+ }
+
+ max30001_cnfg_cal.bit.en_vcal = 0; // Disable VCAL, all other settings are left unaffected
+
+ if (max30001_reg_write(CNFG_CAL, max30001_cnfg_cal.all) == -1) {
+ return -1;
+ }
+
+ return 0;
+}
+//******************************************************************************
+//******************************************************************************
+int MAX30001::max30001_INT_assignment(max30001_intrpt_Location_t en_enint_loc, max30001_intrpt_Location_t en_eovf_loc, max30001_intrpt_Location_t en_fstint_loc,
+ max30001_intrpt_Location_t en_dcloffint_loc, max30001_intrpt_Location_t en_bint_loc, max30001_intrpt_Location_t en_bovf_loc,
+ max30001_intrpt_Location_t en_bover_loc, max30001_intrpt_Location_t en_bundr_loc, max30001_intrpt_Location_t en_bcgmon_loc,
+ max30001_intrpt_Location_t en_pint_loc, max30001_intrpt_Location_t en_povf_loc, max30001_intrpt_Location_t en_pedge_loc,
+ max30001_intrpt_Location_t en_lonint_loc, max30001_intrpt_Location_t en_rrint_loc, max30001_intrpt_Location_t en_samp_loc,
+ max30001_intrpt_type_t intb_Type, max30001_intrpt_type_t int2b_Type)
+
+
+{
+ // INT1
+
+ if (max30001_reg_read(EN_INT, &max30001_en_int.all) == -1) {
+ return -1;
+ }
+
+ // max30001_en_int2.bit.en_pint = 0b1; // Keep this off...
+
+ max30001_en_int.bit.en_eint = 0b1 & en_enint_loc;
+ max30001_en_int.bit.en_eovf = 0b1 & en_eovf_loc;
+ max30001_en_int.bit.en_fstint = 0b1 & en_fstint_loc;
+
+ max30001_en_int.bit.en_dcloffint = 0b1 & en_dcloffint_loc;
+ max30001_en_int.bit.en_bint = 0b1 & en_bint_loc;
+ max30001_en_int.bit.en_bovf = 0b1 & en_bovf_loc;
+
+ max30001_en_int.bit.en_bover = 0b1 & en_bover_loc;
+ max30001_en_int.bit.en_bundr = 0b1 & en_bundr_loc;
+ max30001_en_int.bit.en_bcgmon = 0b1 & en_bcgmon_loc;
+
+ max30001_en_int.bit.en_pint = 0b1 & en_pint_loc;
+ max30001_en_int.bit.en_povf = 0b1 & en_povf_loc;
+ max30001_en_int.bit.en_pedge = 0b1 & en_pedge_loc;
+
+ max30001_en_int.bit.en_lonint = 0b1 & en_lonint_loc;
+ max30001_en_int.bit.en_rrint = 0b1 & en_rrint_loc;
+ max30001_en_int.bit.en_samp = 0b1 & en_samp_loc;
+
+ max30001_en_int.bit.intb_type = int2b_Type;
+
+ if (max30001_reg_write(EN_INT, max30001_en_int.all) == -1) {
+ return -1;
+ }
+
+ // INT2
+
+ if (max30001_reg_read(EN_INT2, &max30001_en_int2.all) == -1) {
+ return -1;
+ }
+
+ max30001_en_int2.bit.en_eint = 0b1 & (en_enint_loc >> 1);
+ max30001_en_int2.bit.en_eovf = 0b1 & (en_eovf_loc >> 1);
+ max30001_en_int2.bit.en_fstint = 0b1 & (en_fstint_loc >> 1);
+
+ max30001_en_int2.bit.en_dcloffint = 0b1 & (en_dcloffint_loc >> 1);
+ max30001_en_int2.bit.en_bint = 0b1 & (en_bint_loc >> 1);
+ max30001_en_int2.bit.en_bovf = 0b1 & (en_bovf_loc >> 1);
+
+ max30001_en_int2.bit.en_bover = 0b1 & (en_bover_loc >> 1);
+ max30001_en_int2.bit.en_bundr = 0b1 & (en_bundr_loc >> 1);
+ max30001_en_int2.bit.en_bcgmon = 0b1 & (en_bcgmon_loc >> 1);
+
+ max30001_en_int2.bit.en_pint = 0b1 & (en_pint_loc >> 1);
+ max30001_en_int2.bit.en_povf = 0b1 & (en_povf_loc >> 1);
+ max30001_en_int2.bit.en_pedge = 0b1 & (en_pedge_loc >> 1);
+
+ max30001_en_int2.bit.en_lonint = 0b1 & (en_lonint_loc >> 1);
+ max30001_en_int2.bit.en_rrint = 0b1 & (en_rrint_loc >> 1);
+ max30001_en_int2.bit.en_samp = 0b1 & (en_samp_loc >> 1);
+
+ max30001_en_int2.bit.intb_type = intb_Type;
+
+ if (max30001_reg_write(EN_INT2, max30001_en_int2.all) == -1) {
+ return -1;
+ }
+
+ return 0;
+}
+
+//******************************************************************************
+int MAX30001::max30001_ECG_InitStart(uint8_t En_ecg, uint8_t Openp,
+ uint8_t Openn, uint8_t Pol,
+ uint8_t Calp_sel, uint8_t Caln_sel,
+ uint8_t E_fit, uint8_t Rate, uint8_t Gain,
+ uint8_t Dhpf, uint8_t Dlpf) {
+
+ // CNFG_EMUX
+
+ if (max30001_reg_read(CNFG_EMUX, &max30001_cnfg_emux.all) == -1) {
+ return -1;
+ }
+
+ max30001_cnfg_emux.bit.openp = Openp;
+ max30001_cnfg_emux.bit.openn = Openn;
+ max30001_cnfg_emux.bit.pol = Pol;
+ max30001_cnfg_emux.bit.calp_sel = Calp_sel;
+ max30001_cnfg_emux.bit.caln_sel = Caln_sel;
+
+ if (max30001_reg_write(CNFG_EMUX, max30001_cnfg_emux.all) == -1) {
+ return -1;
+ }
+
+ /**** ENABLE CHANNELS ****/
+ // CNFG_GEN
+
+ if (max30001_reg_read(CNFG_GEN, &max30001_cnfg_gen.all) == -1) {
+ return -1;
+ }
+
+ max30001_cnfg_gen.bit.en_ecg = En_ecg; // 0b1
+
+ // fmstr is default
+
+ if (max30001_reg_write(CNFG_GEN, max30001_cnfg_gen.all) == -1) {
+ return -1;
+ }
+
+ /**** Wait for PLL Lock & References to settle down ****/
+
+ max30001_timeout = 0;
+
+ do {
+ if (max30001_reg_read(STATUS, &max30001_status.all) == -1) // Wait and spin for PLL to lock...
+ {
+ return -1;
+ }
+ } while (max30001_status.bit.pllint == 1 && max30001_timeout++ <= 1000);
+
+ // MNGR_INT
+
+ if (max30001_reg_read(MNGR_INT, &max30001_mngr_int.all) == -1) {
+ return -1;
+ }
+
+ max30001_mngr_int.bit.e_fit = E_fit; // 31
+
+ if (max30001_reg_write(MNGR_INT, max30001_mngr_int.all) == -1) {
+ return -1;
+ }
+
+ // CNFG_ECG
+
+ if (max30001_reg_read(CNFG_ECG, &max30001_cnfg_ecg.all) == -1) {
+ return -1;
+ }
+
+ max30001_cnfg_ecg.bit.rate = Rate;
+ max30001_cnfg_ecg.bit.gain = Gain;
+ max30001_cnfg_ecg.bit.dhpf = Dhpf;
+ max30001_cnfg_ecg.bit.dlpf = Dlpf;
+
+ if (max30001_reg_write(CNFG_ECG, max30001_cnfg_ecg.all) == -1) {
+ return -1;
+ }
+
+ return 0;
+}
+
+//******************************************************************************
+int MAX30001::max30001_ECGFast_Init(uint8_t Clr_Fast, uint8_t Fast, uint8_t Fast_Th) {
+ if (max30001_reg_read(MNGR_INT, &max30001_mngr_int.all) == -1) {
+ return -1;
+ }
+
+ max30001_mngr_int.bit.clr_fast = Clr_Fast;
+
+ if (max30001_reg_write(MNGR_INT, max30001_mngr_int.all) == -1) {
+ return -1;
+ }
+
+ if (max30001_reg_read(MNGR_DYN, &max30001_mngr_dyn.all) == -1) {
+ return -1;
+ }
+
+ max30001_mngr_dyn.bit.fast = Fast;
+ max30001_mngr_dyn.bit.fast_th = Fast_Th;
+
+ if (max30001_reg_write(MNGR_INT, max30001_mngr_int.all) == -1) {
+ return -1;
+ }
+
+ return 0;
+}
+
+//******************************************************************************
+int MAX30001::max30001_Stop_ECG(void) {
+
+ if (max30001_reg_read(CNFG_GEN, &max30001_cnfg_gen.all) == -1) {
+ return -1;
+ }
+
+ max30001_cnfg_gen.bit.en_ecg = 0; // Stop ECG
+
+ // fmstr is default
+
+ if (max30001_reg_write(CNFG_GEN, max30001_cnfg_gen.all) == -1) {
+ return -1;
+ }
+
+ return 0;
+}
+
+//******************************************************************************
+int MAX30001::max30001_PACE_InitStart(uint8_t En_pace, uint8_t Clr_pedge,
+ uint8_t Pol, uint8_t Gn_diff_off,
+ uint8_t Gain, uint8_t Aout_lbw,
+ uint8_t Aout, uint8_t Dacp,
+ uint8_t Dacn) {
+
+ /**** SET MASTER FREQUENCY, ENABLE CHANNELS ****/
+
+ // CNFG_GEN
+
+ if (max30001_reg_read(CNFG_GEN, &max30001_cnfg_gen.all) == -1) {
+ return -1;
+ }
+
+ max30001_cnfg_gen.bit.en_pace = En_pace; // 0b1;
+
+ if (max30001_reg_write(CNFG_GEN, max30001_cnfg_gen.all) == -1) {
+ return -1;
+ }
+
+ /**** Wait for PLL Lock & References to settle down ****/
+ max30001_timeout = 0;
+
+ do {
+ if (max30001_reg_read(STATUS, &max30001_status.all) ==
+ -1) // Wait and spin for PLL to lock...
+ {
+ return -1;
+ }
+
+ } while (max30001_status.bit.pllint == 1 && max30001_timeout++ <= 1000);
+
+ // MNGR_INT
+
+ if (max30001_reg_read(MNGR_INT, &max30001_mngr_int.all) == -1) {
+ return -1;
+ }
+
+ max30001_mngr_int.bit.clr_pedge = Clr_pedge; // 0b0;
+
+ if (max30001_reg_write(MNGR_INT, max30001_mngr_int.all) == -1) {
+ return -1;
+ }
+
+ /* Put: CNFG_PACE */
+
+ max30001_reg_read(CNFG_PACE, &max30001_cnfg_pace.all);
+
+ max30001_cnfg_pace.bit.pol = Pol;
+ max30001_cnfg_pace.bit.gn_diff_off = Gn_diff_off;
+ max30001_cnfg_pace.bit.gain = Gain;
+ max30001_cnfg_pace.bit.aout_lbw = Aout_lbw;
+ max30001_cnfg_pace.bit.aout = Aout;
+ max30001_cnfg_pace.bit.dacp = Dacp;
+ max30001_cnfg_pace.bit.dacn = Dacn;
+
+ max30001_reg_write(CNFG_PACE, max30001_cnfg_pace.all);
+
+ return 0;
+}
+//******************************************************************************
+int MAX30001::max30001_Stop_PACE(void) {
+
+ if (max30001_reg_read(CNFG_GEN, &max30001_cnfg_gen.all) == -1) {
+ return -1;
+ }
+
+ max30001_cnfg_gen.bit.en_pace = 0; // Stop PACE
+
+ if (max30001_reg_write(CNFG_GEN, max30001_cnfg_gen.all) == -1) {
+ return -1;
+ }
+
+ return 0;
+}
+
+//******************************************************************************
+int MAX30001::max30001_BIOZ_InitStart(
+ uint8_t En_bioz, uint8_t Openp, uint8_t Openn, uint8_t Calp_sel,
+ uint8_t Caln_sel, uint8_t CG_mode, uint8_t B_fit, uint8_t Rate,
+ uint8_t Ahpf, uint8_t Ext_rbias, uint8_t Gain, uint8_t Dhpf, uint8_t Dlpf,
+ uint8_t Fcgen, uint8_t Cgmon, uint8_t Cgmag, uint8_t Phoff) {
+
+ // CNFG_BMUX
+
+ if (max30001_reg_read(CNFG_BMUX, &max30001_cnfg_bmux.all) == -1) {
+ return -1;
+ }
+
+ max30001_cnfg_bmux.bit.openp = Openp; // 0b1;
+ max30001_cnfg_bmux.bit.openn = Openn; // 0b1;
+ max30001_cnfg_bmux.bit.calp_sel = Calp_sel; // 0b10;
+ max30001_cnfg_bmux.bit.caln_sel = Caln_sel; // 0b11;
+ max30001_cnfg_bmux.bit.cg_mode = CG_mode; // 0b00;
+
+ if (max30001_reg_write(CNFG_BMUX, max30001_cnfg_bmux.all) == -1) {
+ return -1;
+ }
+
+ /**** SET MASTER FREQUENCY, ENABLE CHANNELS ****/
+
+ // CNFG_GEN
+
+ if (max30001_reg_read(CNFG_GEN, &max30001_cnfg_gen.all) == -1) {
+ return -1;
+ }
+
+ max30001_cnfg_gen.bit.en_bioz = En_bioz;
+
+ // fmstr is default
+
+ if (max30001_reg_write(CNFG_GEN, max30001_cnfg_gen.all) == -1) {
+ return -1;
+ }
+
+ /**** Wait for PLL Lock & References to settle down ****/
+
+ max30001_timeout = 0;
+
+ do {
+ if (max30001_reg_read(STATUS, &max30001_status.all) ==
+ -1) // Wait and spin for PLL to lock...
+ {
+ return -1;
+ }
+
+ } while (max30001_status.bit.pllint == 1 && max30001_timeout++ <= 1000);
+
+ /**** Start of CNFG_BIOZ ****/
+
+ // MNGR_INT
+
+ if (max30001_reg_read(MNGR_INT, &max30001_mngr_int.all) == -1) {
+ return -1;
+ }
+
+ max30001_mngr_int.bit.b_fit = B_fit; //;
+
+ if (max30001_reg_write(MNGR_INT, max30001_mngr_int.all) == -1) {
+ return -1;
+ }
+
+ // CNFG_BIOZ
+
+ if (max30001_reg_read(CNFG_BIOZ, &max30001_cnfg_bioz.all) == -1) {
+ return -1;
+ }
+
+ max30001_cnfg_bioz.bit.rate = Rate;
+ max30001_cnfg_bioz.bit.ahpf = Ahpf;
+ max30001_cnfg_bioz.bit.ext_rbias = Ext_rbias;
+ max30001_cnfg_bioz.bit.gain = Gain;
+ max30001_cnfg_bioz.bit.dhpf = Dhpf;
+ max30001_cnfg_bioz.bit.dlpf = Dlpf;
+ max30001_cnfg_bioz.bit.fcgen = Fcgen;
+ max30001_cnfg_bioz.bit.cgmon = Cgmon;
+ max30001_cnfg_bioz.bit.cgmag = Cgmag;
+ max30001_cnfg_bioz.bit.phoff = Phoff;
+
+ if (max30001_reg_write(CNFG_BIOZ, max30001_cnfg_bioz.all) == -1) {
+ return -1;
+ }
+
+ return 0;
+}
+
+//******************************************************************************
+int MAX30001::max30001_Stop_BIOZ(void) {
+
+ if (max30001_reg_read(CNFG_GEN, &max30001_cnfg_gen.all) == -1) {
+ return -1;
+ }
+
+ max30001_cnfg_gen.bit.en_bioz = 0; // Stop BIOZ
+
+ if (max30001_reg_write(CNFG_GEN, max30001_cnfg_gen.all) == -1) {
+ return -1;
+ }
+
+ return 0;
+}
+
+//******************************************************************************
+int MAX30001::max30001_BIOZ_InitBist(uint8_t En_bist, uint8_t Rnom,
+ uint8_t Rmod, uint8_t Fbist) {
+
+ // CNFG_BMUX
+
+ if (max30001_reg_read(CNFG_BMUX, &max30001_cnfg_bmux.all) == -1) {
+ return -1;
+ }
+
+ max30001_cnfg_bmux.bit.en_bist = En_bist;
+ max30001_cnfg_bmux.bit.rnom = Rnom;
+ max30001_cnfg_bmux.bit.rmod = Rmod;
+ max30001_cnfg_bmux.bit.fbist = Fbist;
+
+ if (max30001_reg_write(CNFG_BMUX, max30001_cnfg_bmux.all) == -1) {
+ return -1;
+ }
+
+ return 0;
+}
+//******************************************************************************
+int MAX30001::max30001_RtoR_InitStart(uint8_t En_rtor, uint8_t Wndw,
+ uint8_t Gain, uint8_t Pavg, uint8_t Ptsf,
+ uint8_t Hoff, uint8_t Ravg, uint8_t Rhsf,
+ uint8_t Clr_rrint) {
+
+ // MNGR_INT
+
+ if (max30001_reg_read(MNGR_INT, &max30001_mngr_int.all) == -1) {
+ return -1;
+ }
+
+ max30001_mngr_int.bit.clr_rrint =
+ Clr_rrint; // 0b01 & 0b00 are for interrupt mode...
+ // 0b10 is for monitoring mode... it just overwrites the data...
+
+ if (max30001_reg_write(MNGR_INT, max30001_mngr_int.all) == -1) {
+ return -1;
+ }
+
+ // RTOR1
+ if (max30001_reg_read(CNFG_RTOR1, &max30001_cnfg_rtor1.all) == -1) {
+ return -1;
+ }
+
+ max30001_cnfg_rtor1.bit.wndw = Wndw;
+ max30001_cnfg_rtor1.bit.gain = Gain;
+ max30001_cnfg_rtor1.bit.en_rtor = En_rtor;
+ max30001_cnfg_rtor1.bit.pavg = Pavg;
+ max30001_cnfg_rtor1.bit.ptsf = Ptsf;
+
+ if (max30001_reg_write(CNFG_RTOR1, max30001_cnfg_rtor1.all) == -1) {
+ return -1;
+ }
+ // RTOR2
+
+ if (max30001_reg_read(CNFG_RTOR2, &max30001_cnfg_rtor2.all) == -1) {
+ return -1;
+ }
+ max30001_cnfg_rtor2.bit.hoff = Hoff;
+ max30001_cnfg_rtor2.bit.ravg = Ravg;
+ max30001_cnfg_rtor2.bit.rhsf = Rhsf;
+
+ if (max30001_reg_write(CNFG_RTOR2, max30001_cnfg_rtor2.all) == -1) {
+ return -1;
+ }
+
+ return 0;
+}
+
+//******************************************************************************
+int MAX30001::max30001_Stop_RtoR(void) {
+
+ if (max30001_reg_read(CNFG_RTOR1, &max30001_cnfg_rtor1.all) == -1) {
+ return -1;
+ }
+
+ max30001_cnfg_rtor1.bit.en_rtor = 0; // Stop RtoR
+
+ if (max30001_reg_write(CNFG_RTOR1, max30001_cnfg_rtor1.all) == -1) {
+ return -1;
+ }
+
+ return 0;
+}
+
+//******************************************************************************
+int MAX30001::max30001_PLL_lock(void) {
+ // Spin to see PLLint become zero to indicate a lock.
+
+ max30001_timeout = 0;
+
+ do {
+ if (max30001_reg_read(STATUS, &max30001_status.all) ==
+ -1) // Wait and spin for PLL to lock...
+ {
+ return -1;
+ }
+
+ } while (max30001_status.bit.pllint == 1 && max30001_timeout++ <= 1000);
+
+ return 0;
+}
+
+//******************************************************************************
+int MAX30001::max30001_sw_rst(void) {
+ // SW reset for the MAX30001 chip
+
+ if (max30001_reg_write(SW_RST, 0x000000) == -1) {
+ return -1;
+ }
+
+ return 0;
+}
+
+//******************************************************************************
+int MAX30001::max30001_synch(void) { // For synchronization
+ if (max30001_reg_write(SYNCH, 0x000000) == -1) {
+ return -1;
+ }
+ return 0;
+}
+
+//******************************************************************************
+int MAX30001::max300001_fifo_rst(void) { // Resets the FIFO
+ if (max30001_reg_write(FIFO_RST, 0x000000) == -1) {
+ return -1;
+ }
+ return 0;
+}
+
+//******************************************************************************
+// int MAX30001::max30001_reg_write(uint8_t addr, uint32_t data)
+int MAX30001::max30001_reg_write(MAX30001_REG_map_t addr, uint32_t data) {
+
+ uint8_t result[4];
+ uint8_t data_array[4];
+ int32_t success = 0;
+
+ data_array[0] = (addr << 1) & 0xff;
+
+ data_array[3] = data & 0xff;
+ data_array[2] = (data >> 8) & 0xff;
+ data_array[1] = (data >> 16) & 0xff;
+
+ success = SPI_Transmit(&data_array[0], 4, &result[0], 4);
+
+ if (success != 0) {
+ return -1;
+ } else {
+ return 0;
+ }
+}
+
+//******************************************************************************
+// int MAX30001::max30001_reg_read(uint8_t addr, uint32_t *return_data)
+int MAX30001::max30001_reg_read(MAX30001_REG_map_t addr,
+ uint32_t *return_data) {
+ uint8_t result[4];
+ uint8_t data_array[1];
+ int32_t success = 0;
+
+ data_array[0] = ((addr << 1) & 0xff) | 1; // For Read, Or with 1
+ success = SPI_Transmit(&data_array[0], 1, &result[0], 4);
+ *return_data = /*result[0] + */ (uint32_t)(result[1] << 16) +
+ (result[2] << 8) + result[3];
+ if (success != 0) {
+ return -1;
+ } else {
+ return 0;
+ }
+}
+
+//******************************************************************************
+int MAX30001::max30001_Enable_DcLeadOFF_Init(int8_t En_dcloff, int8_t Ipol,
+ int8_t Imag, int8_t Vth) {
+ // the leads are not touching the body
+
+ // CNFG_EMUX, Set ECGP and ECGN for external hook up...
+
+ if (max30001_reg_read(CNFG_GEN, &max30001_cnfg_gen.all) == -1) {
+ return -1;
+ }
+
+ max30001_cnfg_gen.bit.en_dcloff = En_dcloff;
+ max30001_cnfg_gen.bit.ipol = Ipol;
+ max30001_cnfg_gen.bit.imag = Imag;
+ max30001_cnfg_gen.bit.vth = Vth;
+
+ if (max30001_reg_write(CNFG_GEN, max30001_cnfg_gen.all) == -1) {
+ return -1;
+ }
+
+ return 0;
+}
+
+//******************************************************************************
+int MAX30001::max30001_Disable_DcLeadOFF(void) {
+ if (max30001_reg_read(CNFG_GEN, &max30001_cnfg_gen.all) == -1) {
+ return -1;
+ }
+
+ max30001_cnfg_gen.bit.en_dcloff = 0; // Turned off the dc lead off.
+
+ if (max30001_reg_write(CNFG_GEN, max30001_cnfg_gen.all) == -1) {
+ return -1;
+ }
+
+ return 0;
+}
+
+//******************************************************************************
+int MAX30001::max30001_BIOZ_Enable_ACLeadOFF_Init(uint8_t En_bloff,
+ uint8_t Bloff_hi_it,
+ uint8_t Bloff_lo_it) {
+
+ // CNFG_GEN
+ if (max30001_reg_read(CNFG_GEN, &max30001_cnfg_gen.all) == -1) {
+ return -1;
+ }
+
+ max30001_cnfg_gen.bit.en_bloff = En_bloff;
+
+ if (max30001_reg_write(CNFG_GEN, max30001_cnfg_gen.all) == -1) {
+ return -1;
+ }
+
+ // MNGR_DYN
+ if (max30001_reg_read(MNGR_DYN, &max30001_mngr_dyn.all) == -1) {
+ return -1;
+ }
+
+ max30001_mngr_dyn.bit.bloff_hi_it = Bloff_hi_it;
+ max30001_mngr_dyn.bit.bloff_lo_it = Bloff_lo_it;
+
+ if (max30001_reg_write(MNGR_DYN, max30001_mngr_dyn.all) == -1) {
+ return -1;
+ }
+
+ return 0;
+}
+
+//******************************************************************************
+int MAX30001::max30001_BIOZ_Disable_ACleadOFF(void) {
+ // CNFG_GEN
+ if (max30001_reg_read(CNFG_GEN, &max30001_cnfg_gen.all) == -1) {
+ return -1;
+ }
+
+ max30001_cnfg_gen.bit.en_bloff = 0b0; // Turns of the BIOZ AC Lead OFF feature
+
+ if (max30001_reg_write(CNFG_GEN, max30001_cnfg_gen.all) == -1) {
+ return -1;
+ }
+
+ return 0;
+}
+
+//******************************************************************************
+int MAX30001::max30001_BIOZ_Enable_BCGMON(void) {
+ // CNFG_BIOZ
+ if (max30001_reg_read(CNFG_BIOZ, &max30001_cnfg_bioz.all) == -1) {
+ return -1;
+ }
+
+ max30001_cnfg_bioz.bit.cgmon = 1;
+
+ if (max30001_reg_write(CNFG_BIOZ, max30001_cnfg_bioz.all) == -1) {
+ return -1;
+ }
+
+ max30001_reg_read(CNFG_BIOZ, &max30001_cnfg_bioz.all);
+
+ return 0;
+}
+
+#if 1
+//******************************************************************************
+int MAX30001::max30001_Enable_LeadON(int8_t Channel) // Channel: ECG = 0b01, BIOZ = 0b10, Disable = 0b00
+{
+
+ if (max30001_reg_read(CNFG_GEN, &max30001_cnfg_gen.all) == -1) {
+ return -1;
+ }
+
+ max30001_cnfg_gen.bit.en_ecg = 0b0;
+ max30001_cnfg_gen.bit.en_bioz = 0b0;
+ max30001_cnfg_gen.bit.en_pace = 0b0;
+
+ max30001_cnfg_gen.bit.en_ulp_lon = Channel; // BIOZ ULP lead on detection...
+
+ if (max30001_reg_write(CNFG_GEN, max30001_cnfg_gen.all) == -1) {
+ return -1;
+ }
+
+ max30001_reg_read(CNFG_GEN, &max30001_cnfg_gen.all);
+
+ max30001_reg_read(STATUS, &max30001_status.all);
+
+ return 0;
+}
+//******************************************************************************
+int MAX30001::max30001_Disable_LeadON(void) {
+
+ if (max30001_reg_read(CNFG_GEN, &max30001_cnfg_gen.all) == -1) {
+ return -1;
+ }
+
+ max30001_cnfg_gen.bit.en_ulp_lon = 0b0;
+
+ if (max30001_reg_write(CNFG_GEN, max30001_cnfg_gen.all) == -1) {
+ return -1;
+ }
+
+ return 0;
+}
+#endif
+//******************************************************************************
+#define LEADOFF_SERVICE_TIME 0x2000 // 0x1000 = 1 second
+#define LEADOFF_NUMSTATES 2
+uint32_t leadoffState = 0;
+uint32_t max30001_LeadOffoldTime = 0;
+void MAX30001::max30001_ServiceLeadoff(uint32_t currentTime) {
+
+ uint32_t delta_Time;
+
+ delta_Time = currentTime - max30001_LeadOffoldTime;
+
+ if (delta_Time > LEADOFF_SERVICE_TIME) {
+ switch (leadoffState) {
+ case 0: /* switch to ECG DC Lead OFF */
+ max30001_Enable_DcLeadOFF_Init(0b01, 0b0, 0b001, 0b00);
+ break;
+
+ case 1: /* switch to BIOZ DC Lead OFF */
+ max30001_Enable_DcLeadOFF_Init(0b10, 0b0, 0b001, 0b00);
+ break;
+ }
+
+ leadoffState++;
+ leadoffState %= LEADOFF_NUMSTATES;
+
+ max30001_LeadOffoldTime = currentTime;
+ }
+}
+//******************************************************************************
+#define LEADON_SERVICE_TIME 0x2000 // 0x1000 = 1 second
+#define LEADON_NUMSTATES 2
+uint32_t leadOnState = 0;
+uint32_t max30001_LeadOnoldTime = 0;
+void MAX30001::max30001_ServiceLeadON(uint32_t currentTime) {
+
+ uint32_t delta_Time;
+
+ delta_Time = currentTime - max30001_LeadOnoldTime;
+
+ if (delta_Time > LEADON_SERVICE_TIME) {
+ switch (leadOnState) {
+ case 0: /* switch to ECG DC Lead ON */
+ max30001_Enable_LeadON(0b01);
+ break;
+
+ case 1: /* switch to BIOZ DC Lead ON */
+ max30001_Enable_LeadON(0b10);
+ break;
+ }
+
+ leadOnState++;
+ leadOnState %= LEADON_NUMSTATES;
+
+ max30001_LeadOnoldTime = currentTime;
+ }
+}
+
+//******************************************************************************
+int MAX30001::max30001_FIFO_LeadONOff_Read(void) {
+
+ uint8_t result[32 * 3]; // 32words - 3bytes each
+
+ uint8_t data_array[4];
+ int32_t success = 0;
+ int i, j;
+
+ uint32_t total_databytes;
+ uint8_t i_index;
+ uint8_t data_chunk;
+ uint8_t loop_logic;
+
+ uint8_t etag, ptag, btag;
+
+ uint8_t adr;
+
+ int8_t ReadAllPaceOnce;
+
+ static uint8_t dcloffint_OneShot = 0;
+ static uint8_t acloffint_OneShot = 0;
+ static uint8_t bcgmon_OneShot = 0;
+ static uint8_t acleadon_OneShot = 0;
+
+ int8_t ret_val;
+
+ if (max30001_status.bit.eint == 1 || max30001_status.bit.pint == 1) {
+ adr = ECG_FIFO_BURST;
+ data_array[0] = ((adr << 1) & 0xff) | 1;
+
+ // The SPI routine only sends out data of 32 bytes in size. Therefore the
+ // data is being read in
+ // smaller chunks in this routine...
+
+ total_databytes = (max30001_mngr_int.bit.e_fit + 1) * 3;
+
+ i_index = 0;
+ loop_logic = 1;
+
+ while (loop_logic) {
+ if (total_databytes > 30) {
+ data_chunk = 30;
+ total_databytes = total_databytes - 30;
+ } else {
+ data_chunk = total_databytes;
+ loop_logic = 0;
+ }
+
+ /* The extra 1 byte is for the extra byte that comes out of the SPI */
+ success = SPI_Transmit(&data_array[0], 1, &result[i_index], (data_chunk + 1)); // Make a copy of the FIFO over here...
+
+ if (success != 0) {
+ return -1;
+ }
+
+ /* This is important, because every transaction above creates an empty
+ * redundant data at result[0] */
+ for (j = i_index; j < (data_chunk + i_index); j++) /* get rid of the 1 extra byte by moving the whole array up one */
+ {
+ result[j] = result[j + 1];
+ }
+
+ i_index = i_index + 30; /* point to the next array location to put the data in */
+ }
+
+ ReadAllPaceOnce = 0;
+
+ /* Put the content of the FIFO based on the EFIT value, We ignore the
+ * result[0] and start concatenating indexes: 1,2,3 - 4,5,6 - 7,8,9 - */
+ for (i = 0, j = 0; i < max30001_mngr_int.bit.e_fit + 1; i++, j = j + 3) // index1=23-16 bit, index2=15-8 bit, index3=7-0 bit
+ {
+ max30001_ECG_FIFO_buffer[i] = ((uint32_t)result[j] << 16) + (result[j + 1] << 8) + result[j + 2];
+
+ etag = (0b00111000 & result[j + 2]) >> 3;
+ ptag = 0b00000111 & result[j + 2];
+
+ if (ptag != 0b111 && ReadAllPaceOnce == 0) {
+
+ ReadAllPaceOnce = 1; // This will prevent extra read of PACE, once group
+ // 0-5 is read ONCE.
+
+ adr = PACE0_FIFO_BURST;
+
+ data_array[0] = ((adr << 1) & 0xff) | 1; // For Read Or with 1
+
+ success = SPI_Transmit(&data_array[0], 1, &result[0], 10);
+
+ max30001_PACE[0] = (uint32_t)(result[1] << 16) + (result[2] << 8) + result[3];
+ max30001_PACE[1] = (uint32_t)(result[4] << 16) + (result[5] << 8) + result[6];
+ max30001_PACE[2] = (uint32_t)(result[7] << 16) + (result[8] << 8) + result[9];
+
+ adr = PACE1_FIFO_BURST;
+
+ data_array[0] = ((adr << 1) & 0xff) | 1; // For Read Or with 1
+
+ success = SPI_Transmit(&data_array[0], 1, &result[0], 10);
+
+ max30001_PACE[3] = (uint32_t)(result[1] << 16) + (result[2] << 8) + result[3];
+ max30001_PACE[4] = (uint32_t)(result[4] << 16) + (result[5] << 8) + result[6];
+ max30001_PACE[5] = (uint32_t)(result[7] << 16) + (result[8] << 8) + result[9];
+
+ adr = PACE2_FIFO_BURST;
+
+ data_array[0] = ((adr << 1) & 0xff) | 1; // For Read Or with 1
+
+ success = SPI_Transmit(&data_array[0], 1, &result[0], 10);
+
+ max30001_PACE[6] = (uint32_t)(result[1] << 16) + (result[2] << 8) + result[3];
+ max30001_PACE[7] = (uint32_t)(result[4] << 16) + (result[5] << 8) + result[6];
+ max30001_PACE[8] = (uint32_t)(result[7] << 16) + (result[8] << 8) + result[9];
+
+ adr = PACE3_FIFO_BURST;
+
+ data_array[0] = ((adr << 1) & 0xff) | 1; // For Read Or with 1
+
+ success = SPI_Transmit(&data_array[0], 1, &result[0], 10);
+
+ max30001_PACE[9] = (uint32_t)(result[1] << 16) + (result[2] << 8) + result[3];
+ max30001_PACE[10] = (uint32_t)(result[4] << 16) + (result[5] << 8) + result[6];
+ max30001_PACE[11] = (uint32_t)(result[7] << 16) + (result[8] << 8) + result[9];
+
+ adr = PACE4_FIFO_BURST;
+
+ data_array[0] = ((adr << 1) & 0xff) | 1; // For Read Or with 1
+
+ success = SPI_Transmit(&data_array[0], 1, &result[0], 10);
+
+ max30001_PACE[12] = (uint32_t)(result[1] << 16) + (result[2] << 8) + result[3];
+ max30001_PACE[13] = (uint32_t)(result[4] << 16) + (result[5] << 8) + result[6];
+ max30001_PACE[14] = (uint32_t)(result[7] << 16) + (result[8] << 8) + result[9];
+
+ adr = PACE5_FIFO_BURST;
+
+ data_array[0] = ((adr << 1) & 0xff) | 1; // For Read Or with 1
+
+ success = SPI_Transmit(&data_array[0], 1, &result[0], 10);
+
+ max30001_PACE[15] = (uint32_t)(result[1] << 16) + (result[2] << 8) + result[3];
+ max30001_PACE[16] = (uint32_t)(result[4] << 16) + (result[5] << 8) + result[6];
+ max30001_PACE[17] = (uint32_t)(result[7] << 16) + (result[8] << 8) + result[9];
+
+ dataAvailable(MAX30001_DATA_PACE, max30001_PACE, 18); // Send out the Pace data once only
+ }
+ }
+
+ if (etag != 0b110) {
+
+ dataAvailable(MAX30001_DATA_ECG, max30001_ECG_FIFO_buffer, (max30001_mngr_int.bit.e_fit + 1));
+ }
+
+ } /* End of ECG init */
+
+ /* RtoR */
+
+ if (max30001_status.bit.rrint == 1) {
+ if (max30001_reg_read(RTOR, &max30001_RtoR_data) == -1) {
+ return -1;
+ }
+
+ max30001_RtoR_data = (0x00FFFFFF & max30001_RtoR_data) >> 10;
+
+ hspValMax30001.R2R = (uint16_t)max30001_RtoR_data;
+ hspValMax30001.fmstr = (uint16_t)max30001_cnfg_gen.bit.fmstr;
+
+ dataAvailable(MAX30001_DATA_RTOR, &max30001_RtoR_data, 1);
+ }
+
+ // Handling BIOZ data...
+
+ if (max30001_status.bit.bint == 1) {
+ adr = 0x22;
+ data_array[0] = ((adr << 1) & 0xff) | 1;
+
+ /* [(BFIT+1)*3byte]+1extra byte due to the addr */
+
+ if (SPI_Transmit(&data_array[0], 1, &result[0],((max30001_mngr_int.bit.b_fit + 1) * 3) + 1) == -1) // Make a copy of the FIFO over here...
+
+ {
+ return -1;
+ }
+
+ btag = 0b00000111 & result[3];
+
+ /* Put the content of the FIFO based on the BFIT value, We ignore the
+ * result[0] and start concatenating indexes: 1,2,3 - 4,5,6 - 7,8,9 - */
+ for (i = 0, j = 0; i < max30001_mngr_int.bit.b_fit + 1; i++, j = j + 3) // index1=23-16 bit, index2=15-8 bit, index3=7-0 bit
+ {
+ max30001_BIOZ_FIFO_buffer[i] = ((uint32_t)result[j + 1] << 16) + (result[j + 2] << 8) + result[j + 3];
+ }
+
+ if (btag != 0b110) {
+ dataAvailable(MAX30001_DATA_BIOZ, max30001_BIOZ_FIFO_buffer, 8);
+ }
+ }
+
+ ret_val = 0;
+
+ if (max30001_status.bit.dcloffint == 1) // ECG/BIOZ Lead Off
+ {
+ dcloffint_OneShot = 1;
+ max30001_DCLeadOff = 0;
+ max30001_DCLeadOff = max30001_DCLeadOff | (max30001_cnfg_gen.bit.en_dcloff << 8) | (max30001_status.all & 0x00000F);
+ dataAvailable(MAX30001_DATA_LEADOFF_DC, &max30001_DCLeadOff, 1);
+ // Do a FIFO Reset
+ max30001_reg_write(FIFO_RST, 0x000000);
+
+ ret_val = 0b100;
+
+ } else if (dcloffint_OneShot == 1 && max30001_status.bit.dcloffint == 0) // Just send once when it comes out of dc lead off
+ {
+ max30001_DCLeadOff = 0;
+ max30001_DCLeadOff = max30001_DCLeadOff | (max30001_cnfg_gen.bit.en_dcloff << 8) | (max30001_status.all & 0x00000F);
+ dataAvailable(MAX30001_DATA_LEADOFF_DC, &max30001_DCLeadOff, 1);
+ dcloffint_OneShot = 0;
+ }
+
+ if (max30001_status.bit.bover == 1 || max30001_status.bit.bundr == 1) // BIOZ AC Lead Off
+ {
+ acloffint_OneShot = 1;
+ max30001_ACLeadOff = 0;
+ max30001_ACLeadOff =
+ max30001_ACLeadOff | ((max30001_status.all & 0x030000) >> 16);
+ dataAvailable(MAX30001_DATA_LEADOFF_AC, &max30001_ACLeadOff, 1);
+ // Do a FIFO Reset
+ max30001_reg_write(FIFO_RST, 0x000000);
+
+ ret_val = 0b1000;
+ } else if (acloffint_OneShot == 1 && max30001_status.bit.bover == 0 && max30001_status.bit.bundr == 0) // Just send once when it comes out of ac lead off
+ {
+ max30001_ACLeadOff = 0;
+ max30001_ACLeadOff = max30001_ACLeadOff | ((max30001_status.all & 0x030000) >> 16);
+ dataAvailable(MAX30001_DATA_LEADOFF_AC, &max30001_ACLeadOff, 1);
+ acloffint_OneShot = 0;
+ }
+
+ if (max30001_status.bit.bcgmon == 1) // BIOZ BCGMON check
+ {
+ bcgmon_OneShot = 1;
+ max30001_bcgmon = 0;
+ max30001_bcgmon = max30001_bcgmon | ((max30001_status.all & 0x000030) >> 4);
+ dataAvailable(MAX30001_DATA_BCGMON, &max30001_bcgmon, 1);
+ // Do a FIFO Reset
+ max30001_reg_write(FIFO_RST, 0x000000);
+
+ ret_val = 0b10000;
+ } else if (bcgmon_OneShot == 1 && max30001_status.bit.bcgmon == 0) {
+ max30001_bcgmon = 0;
+ max30001_bcgmon = max30001_bcgmon | ((max30001_status.all & 0x000030) >> 4);
+ bcgmon_OneShot = 0;
+ dataAvailable(MAX30001_DATA_BCGMON, &max30001_bcgmon, 1);
+ }
+
+#if 0
+if(max30001_status.bit.lonint == 1) // AC LeadON Check
+{
+ max30001_LeadOn = 0;
+ max30001_reg_read(STATUS,&max30001_status.all); // Reading is important
+ max30001_LeadOn = max30001_LeadOn | (max30001_cnfg_gen.bit.en_ulp_lon << 8) | ((max30001_status.all & 0x000800) >> 11); // 0b01 will mean ECG Lead On, 0b10 will mean BIOZ Lead On
+ // LEAD ON has been detected... Now take actions
+}
+#endif
+
+ if (max30001_status.bit.lonint == 1 &&
+ acleadon_OneShot == 0) // AC LeadON Check, when lead is on
+ {
+ max30001_LeadOn = 0;
+ max30001_reg_read(STATUS, &max30001_status.all); // Reading is important
+ max30001_LeadOn =
+ max30001_LeadOn | (max30001_cnfg_gen.bit.en_ulp_lon << 8) |
+ ((max30001_status.all & 0x000800) >>
+ 11); // 0b01 will mean ECG Lead On, 0b10 will mean BIOZ Lead On
+
+ // LEAD ON has been detected... Now take actions
+ acleadon_OneShot = 1;
+ dataAvailable(MAX30001_DATA_ACLEADON, &max30001_LeadOn, 1); // One shot data will be sent...
+ } else if (max30001_status.bit.lonint == 0 && acleadon_OneShot == 1) {
+ max30001_LeadOn = 0;
+ max30001_reg_read(STATUS, &max30001_status.all);
+ max30001_LeadOn =
+ max30001_LeadOn | (max30001_cnfg_gen.bit.en_ulp_lon << 8) | ((max30001_status.all & 0x000800) >> 11); // 0b01 will mean ECG Lead On, 0b10 will mean BIOZ Lead On
+ dataAvailable(MAX30001_DATA_ACLEADON, &max30001_LeadOn, 1); // One shot data will be sent...
+ acleadon_OneShot = 0;
+ }
+
+ return ret_val;
+}
+
+//******************************************************************************
+
+int MAX30001::max30001_int_handler(void) {
+
+ static uint32_t InitReset = 0;
+
+ int8_t return_value;
+
+ max30001_reg_read(STATUS, &max30001_status.all);
+
+ // Inital Reset and any FIFO over flow invokes a FIFO reset
+ if (InitReset == 0 || max30001_status.bit.eovf == 1 || max30001_status.bit.bovf == 1 || max30001_status.bit.povf == 1) {
+ // Do a FIFO Reset
+ max30001_reg_write(FIFO_RST, 0x000000);
+
+ InitReset++;
+ return 2;
+ }
+
+ return_value = 0;
+
+ // The four data handling goes on over here
+ if (max30001_status.bit.eint == 1 || max30001_status.bit.pint == 1 || max30001_status.bit.bint == 1 || max30001_status.bit.rrint == 1) {
+ return_value = return_value | max30001_FIFO_LeadONOff_Read();
+ }
+
+ // ECG/BIOZ DC Lead Off test
+ if (max30001_status.bit.dcloffint == 1) {
+ return_value = return_value | max30001_FIFO_LeadONOff_Read();
+ }
+
+ // BIOZ AC Lead Off test
+ if (max30001_status.bit.bover == 1 || max30001_status.bit.bundr == 1) {
+ return_value = return_value | max30001_FIFO_LeadONOff_Read();
+ }
+
+ // BIOZ DRVP/N test using BCGMON.
+ if (max30001_status.bit.bcgmon == 1) {
+ return_value = return_value | max30001_FIFO_LeadONOff_Read();
+ }
+
+ if (max30001_status.bit.lonint == 1) // ECG Lead ON test: i.e. the leads are touching the body...
+ {
+
+ max30001_FIFO_LeadONOff_Read();
+ }
+
+ return return_value;
+}
+
+/// function pointer to the async callback
+static event_callback_t functionpointer;
+/// flag used to indicate an async xfer has taken place
+static volatile int xferFlag = 0;
+
+/**
+* @brief Callback handler for SPI async events
+* @param events description of event that occurred
+*/
+static void spiHandler(int events) { xferFlag = 1; }
+
+/**
+* @brief Transmit and recieve QUAD SPI data
+* @param tx_buf pointer to transmit byte buffer
+* @param tx_size number of bytes to transmit
+* @param rx_buf pointer to the recieve buffer
+* @param rx_size number of bytes to recieve
+*/
+int MAX30001::SPI_Transmit(const uint8_t *tx_buf, uint32_t tx_size, uint8_t *rx_buf, uint32_t rx_size) {
+ xferFlag = 0;
+ int i;
+ for (i = 0; i < sizeof(buffer); i++) {
+ if (i < tx_size)
+ buffer[i] = tx_buf[i];
+ else
+ buffer[i] = 0xFF;
+ }
+ spi->transfer<uint8_t>(buffer, (int)rx_size, rx_buf, (int)rx_size, spiHandler /* functionpointer */);
+ while (xferFlag == 0);
+ return 0;
+}
+
+//******************************************************************************
+void MAX30001::max30001_ReadHeartrateData(max30001_t *_hspValMax30001) {
+ _hspValMax30001->R2R = hspValMax30001.R2R;
+ _hspValMax30001->fmstr = hspValMax30001.fmstr;
+}
+
+//******************************************************************************
+void MAX30001::onDataAvailable(PtrFunction _onDataAvailable) {
+ onDataAvailableCallback = _onDataAvailable;
+}
+
+/**
+* @brief Used to notify an external function that interrupt data is available
+* @param id type of data available
+* @param buffer 32-bit buffer that points to the data
+* @param length length of 32-bit elements available
+*/
+void MAX30001::dataAvailable(uint32_t id, uint32_t *buffer, uint32_t length) {
+ if (onDataAvailableCallback != NULL) {
+ (*onDataAvailableCallback)(id, buffer, length);
+ }
+}
+
+/**
+* @brief Callback handler for SPI async events
+* @param events description of event that occurred
+*/
+void MAX30001::spiHandler(int events) { xferFlag = 1; }
+
+//******************************************************************************
+static int allowInterrupts = 0;
+
+void MAX30001Mid_IntB_Handler(void) {
+ if (allowInterrupts == 0) return;
+ MAX30001::instance->max30001_int_handler();
+}
+
+void MAX30001Mid_Int2B_Handler(void) {
+ if (allowInterrupts == 0) return;
+ MAX30001::instance->max30001_int_handler();
+}
+
+void MAX30001_AllowInterrupts(int state) {
+allowInterrupts = state;
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/Devices/MAX30001/MAX30001/MAX30001.h Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,1076 @@
+/*******************************************************************************
+* Copyright (C) 2015 Maxim Integrated Products, Inc., All Rights Reserved.
+*
+* Permission is hereby granted, free of charge, to any person obtaining a
+* copy of this software and associated documentation files (the "Software"),
+* to deal in the Software without restriction, including without limitation
+* the rights to use, copy, modify, merge, publish, distribute, sublicense,
+* and/or sell copies of the Software, and to permit persons to whom the
+* Software is furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included
+* in all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+* IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+* OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+* OTHER DEALINGS IN THE SOFTWARE.
+*
+* Except as contained in this notice, the name of Maxim Integrated
+* Products, Inc. shall not be used except as stated in the Maxim Integrated
+* Products, Inc. Branding Policy.
+*
+* The mere transfer of this software does not imply any licenses
+* of trade secrets, proprietary technology, copyrights, patents,
+* trademarks, maskwork rights, or any other form of intellectual
+* property whatsoever. Maxim Integrated Products, Inc. retains all
+* ownership rights.
+*******************************************************************************/
+/*
+ * max30001.h
+ *
+ * Created on: Oct 9, 2015
+ * Author: faisal.tariq
+ */
+
+#ifndef MAX30001_H_
+#define MAX30001_H_
+
+#include "mbed.h"
+
+#define mbed_COMPLIANT // Uncomment to Use timer for MAX30001 FCLK (for mbed)
+ // Comment to use the RTC clock
+
+#define ASYNC_SPI_BUFFER_SIZE (32 * 3) // Maximimum buffer size for async byte transfers
+
+// Defines for data callbacks
+#define MAX30001_DATA_ECG 0x30
+#define MAX30001_DATA_PACE 0x31
+#define MAX30001_DATA_RTOR 0x32
+#define MAX30001_DATA_BIOZ 0x33
+#define MAX30001_DATA_LEADOFF_DC 0x34
+#define MAX30001_DATA_LEADOFF_AC 0x35
+#define MAX30001_DATA_BCGMON 0x36
+#define MAX30001_DATA_ACLEADON 0x37
+
+#define MAX30001_SPI_MASTER_PORT 0
+#define MAX30001_SPI_SS_INDEX 0
+
+#define MAX30001_INT_PORT_B 3
+#define MAX30001_INT_PIN_B 6
+
+#define MAX30001_INT_PORT_2B 4
+#define MAX30001_INT_PIN_2B 5
+
+#define MAX30001_INT_PORT_FCLK 1
+#define MAX30001_INT_PIN_FCLK 7
+
+#define MAX30001_FUNC_SEL_TMR 2 // 0=FW Control, 1= Pulse Train, 2=Timer
+
+#define MAX30001_INDEX 3
+#define MAX30001_POLARITY 0
+#define MAX30001_PERIOD 30518
+#define MAX30001_CYCLE 50
+
+#define MAX30001_IOMUX_IO_ENABLE 1
+
+#define MAX30001_SPI_PORT 0
+#define MAX30001_CS_PIN 0
+#define MAX30001_CS_POLARITY 0
+#define MAX30001_CS_ACTIVITY_DELAY 0
+#define MAX30001_CS_INACTIVITY_DELAY 0
+#define MAX30001_CLK_HI 1
+#define MAX30001_CLK_LOW 1
+#define MAX30001_ALT_CLK 0
+#define MAX30001_CLK_POLARITY 0
+#define MAX30001_CLK_PHASE 0
+#define MAX30001_WRITE 1
+#define MAX30001_READ 0
+
+#define MAX30001_INT_PORT_B 3
+#define MAX30001INT_PIN_B 6
+
+void MAX30001_AllowInterrupts(int state);
+
+/**
+* Maxim Integrated MAX30001 ECG/BIOZ chip
+*/
+class MAX30001 {
+
+public:
+ typedef enum { // MAX30001 Register addresses
+ STATUS = 0x01,
+ EN_INT = 0x02,
+ EN_INT2 = 0x03,
+ MNGR_INT = 0x04,
+ MNGR_DYN = 0x05,
+ SW_RST = 0x08,
+ SYNCH = 0x09,
+ FIFO_RST = 0x0A,
+ INFO = 0x0F,
+ CNFG_GEN = 0x10,
+ CNFG_CAL = 0x12,
+ CNFG_EMUX = 0x14,
+ CNFG_ECG = 0x15,
+ CNFG_BMUX = 0x17,
+ CNFG_BIOZ = 0x18,
+ CNFG_PACE = 0x1A,
+ CNFG_RTOR1 = 0x1D,
+ CNFG_RTOR2 = 0x1E,
+
+ // Data locations
+ ECG_FIFO_BURST = 0x20,
+ ECG_FIFO = 0x21,
+ FIFO_BURST = 0x22,
+ BIOZ_FIFO = 0x23,
+ RTOR = 0x25,
+
+ PACE0_FIFO_BURST = 0x30,
+ PACE0_A = 0x31,
+ PACE0_B = 0x32,
+ PACE0_C = 0x33,
+
+ PACE1_FIFO_BURST = 0x34,
+ PACE1_A = 0x35,
+ PACE1_B = 0x36,
+ PACE1_C = 0x37,
+
+ PACE2_FIFO_BURST = 0x38,
+ PACE2_A = 0x39,
+ PACE2_B = 0x3A,
+ PACE2_C = 0x3B,
+
+ PACE3_FIFO_BURST = 0x3C,
+ PACE3_A = 0x3D,
+ PACE3_B = 0x3E,
+ PACE3_C = 0x3F,
+
+ PACE4_FIFO_BURST = 0x40,
+ PACE4_A = 0x41,
+ PACE4_B = 0x42,
+ PACE4_C = 0x43,
+
+ PACE5_FIFO_BURST = 0x44,
+ PACE5_A = 0x45,
+ PACE5_B = 0x46,
+ PACE5_C = 0x47,
+
+ } MAX30001_REG_map_t;
+
+ /**
+ * @brief STATUS (0x01)
+ */
+ union max30001_status_reg {
+ uint32_t all;
+
+ struct {
+ uint32_t loff_nl : 1;
+ uint32_t loff_nh : 1;
+ uint32_t loff_pl : 1;
+ uint32_t loff_ph : 1;
+
+ uint32_t bcgmn : 1;
+ uint32_t bcgmp : 1;
+ uint32_t reserved1 : 1;
+ uint32_t reserved2 : 1;
+
+ uint32_t pllint : 1;
+ uint32_t samp : 1;
+ uint32_t rrint : 1;
+ uint32_t lonint : 1;
+
+ uint32_t pedge : 1;
+ uint32_t povf : 1;
+ uint32_t pint : 1;
+ uint32_t bcgmon : 1;
+
+ uint32_t bundr : 1;
+ uint32_t bover : 1;
+ uint32_t bovf : 1;
+ uint32_t bint : 1;
+
+ uint32_t dcloffint : 1;
+ uint32_t fstint : 1;
+ uint32_t eovf : 1;
+ uint32_t eint : 1;
+
+ uint32_t reserved : 8;
+
+ } bit;
+
+ } max30001_status;
+
+
+ /**
+ * @brief EN_INT (0x02)
+ */
+
+ union max30001_en_int_reg {
+ uint32_t all;
+
+ struct {
+ uint32_t intb_type : 2;
+ uint32_t reserved1 : 1;
+ uint32_t reserved2 : 1;
+
+ uint32_t reserved3 : 1;
+ uint32_t reserved4 : 1;
+ uint32_t reserved5 : 1;
+ uint32_t reserved6 : 1;
+
+ uint32_t en_pllint : 1;
+ uint32_t en_samp : 1;
+ uint32_t en_rrint : 1;
+ uint32_t en_lonint : 1;
+
+ uint32_t en_pedge : 1;
+ uint32_t en_povf : 1;
+ uint32_t en_pint : 1;
+ uint32_t en_bcgmon : 1;
+
+ uint32_t en_bundr : 1;
+ uint32_t en_bover : 1;
+ uint32_t en_bovf : 1;
+ uint32_t en_bint : 1;
+
+ uint32_t en_dcloffint : 1;
+ uint32_t en_fstint : 1;
+ uint32_t en_eovf : 1;
+ uint32_t en_eint : 1;
+
+ uint32_t reserved : 8;
+
+ } bit;
+
+ } max30001_en_int;
+
+
+ /**
+ * @brief EN_INT2 (0x03)
+ */
+ union max30001_en_int2_reg {
+ uint32_t all;
+
+ struct {
+ uint32_t intb_type : 2;
+ uint32_t reserved1 : 1;
+ uint32_t reserved2 : 1;
+
+ uint32_t reserved3 : 1;
+ uint32_t reserved4 : 1;
+ uint32_t reserved5 : 1;
+ uint32_t reserved6 : 1;
+
+ uint32_t en_pllint : 1;
+ uint32_t en_samp : 1;
+ uint32_t en_rrint : 1;
+ uint32_t en_lonint : 1;
+
+ uint32_t en_pedge : 1;
+ uint32_t en_povf : 1;
+ uint32_t en_pint : 1;
+ uint32_t en_bcgmon : 1;
+
+ uint32_t en_bundr : 1;
+ uint32_t en_bover : 1;
+ uint32_t en_bovf : 1;
+ uint32_t en_bint : 1;
+
+ uint32_t en_dcloffint : 1;
+ uint32_t en_fstint : 1;
+ uint32_t en_eovf : 1;
+ uint32_t en_eint : 1;
+
+ uint32_t reserved : 8;
+
+ } bit;
+
+ } max30001_en_int2;
+
+ /**
+ * @brief MNGR_INT (0x04)
+ */
+ union max30001_mngr_int_reg {
+ uint32_t all;
+
+ struct {
+ uint32_t samp_it : 2;
+ uint32_t clr_samp : 1;
+ uint32_t clr_pedge : 1;
+ uint32_t clr_rrint : 2;
+ uint32_t clr_fast : 1;
+ uint32_t reserved1 : 1;
+ uint32_t reserved2 : 4;
+ uint32_t reserved3 : 4;
+
+ uint32_t b_fit : 3;
+ uint32_t e_fit : 5;
+
+ uint32_t reserved : 8;
+
+ } bit;
+
+ } max30001_mngr_int;
+
+ /**
+ * @brief MNGR_DYN (0x05)
+ */
+ union max30001_mngr_dyn_reg {
+ uint32_t all;
+
+ struct {
+ uint32_t bloff_lo_it : 8;
+ uint32_t bloff_hi_it : 8;
+ uint32_t fast_th : 6;
+ uint32_t fast : 2;
+ uint32_t reserved : 8;
+ } bit;
+
+ } max30001_mngr_dyn;
+
+ // 0x08
+ // uint32_t max30001_sw_rst;
+
+ // 0x09
+ // uint32_t max30001_synch;
+
+ // 0x0A
+ // uint32_t max30001_fifo_rst;
+
+
+ /**
+ * @brief INFO (0x0F)
+ */
+ union max30001_info_reg {
+ uint32_t all;
+ struct {
+ uint32_t serial : 12;
+ uint32_t part_id : 2;
+ uint32_t sample : 1;
+ uint32_t reserved1 : 1;
+ uint32_t rev_id : 4;
+ uint32_t pattern : 4;
+ uint32_t reserved : 8;
+ } bit;
+
+ } max30001_info;
+
+ /**
+ * @brief CNFG_GEN (0x10)
+ */
+ union max30001_cnfg_gen_reg {
+ uint32_t all;
+ struct {
+ uint32_t rbiasn : 1;
+ uint32_t rbiasp : 1;
+ uint32_t rbiasv : 2;
+ uint32_t en_rbias : 2;
+ uint32_t vth : 2;
+ uint32_t imag : 3;
+ uint32_t ipol : 1;
+ uint32_t en_dcloff : 2;
+ uint32_t en_bloff : 2;
+ uint32_t reserved1 : 1;
+ uint32_t en_pace : 1;
+ uint32_t en_bioz : 1;
+ uint32_t en_ecg : 1;
+ uint32_t fmstr : 2;
+ uint32_t en_ulp_lon : 2;
+ uint32_t reserved : 8;
+ } bit;
+
+ } max30001_cnfg_gen;
+
+
+ /**
+ * @brief CNFG_CAL (0x12)
+ */
+ union max30001_cnfg_cal_reg {
+ uint32_t all;
+ struct {
+ uint32_t thigh : 11;
+ uint32_t fifty : 1;
+ uint32_t fcal : 3;
+ uint32_t reserved1 : 5;
+ uint32_t vmag : 1;
+ uint32_t vmode : 1;
+ uint32_t en_vcal : 1;
+ uint32_t reserved2 : 1;
+ uint32_t reserved : 8;
+ } bit;
+
+ } max30001_cnfg_cal;
+
+ /**
+ * @brief CNFG_EMUX (0x14)
+ */
+ union max30001_cnfg_emux_reg {
+ uint32_t all;
+ struct {
+ uint32_t reserved1 : 16;
+ uint32_t caln_sel : 2;
+ uint32_t calp_sel : 2;
+ uint32_t openn : 1;
+ uint32_t openp : 1;
+ uint32_t reserved2 : 1;
+ uint32_t pol : 1;
+ uint32_t reserved : 8;
+ } bit;
+
+ } max30001_cnfg_emux;
+
+
+ /**
+ * @brief CNFG_ECG (0x15)
+ */
+ union max30001_cnfg_ecg_reg {
+ uint32_t all;
+ struct {
+ uint32_t reserved1 : 12;
+ uint32_t dlpf : 2;
+ uint32_t dhpf : 1;
+ uint32_t reserved2 : 1;
+ uint32_t gain : 2;
+ uint32_t reserved3 : 4;
+ uint32_t rate : 2;
+
+ uint32_t reserved : 8;
+ } bit;
+
+ } max30001_cnfg_ecg;
+
+ /**
+ * @brief CNFG_BMUX (0x17)
+ */
+ union max30001_cnfg_bmux_reg {
+ uint32_t all;
+ struct {
+ uint32_t fbist : 2;
+ uint32_t reserved1 : 2;
+ uint32_t rmod : 3;
+ uint32_t reserved2 : 1;
+ uint32_t rnom : 3;
+ uint32_t en_bist : 1;
+ uint32_t cg_mode : 2;
+ uint32_t reserved3 : 2;
+ uint32_t caln_sel : 2;
+ uint32_t calp_sel : 2;
+ uint32_t openn : 1;
+ uint32_t openp : 1;
+ uint32_t reserved4 : 2;
+ uint32_t reserved : 8;
+ } bit;
+
+ } max30001_cnfg_bmux;
+
+ /**
+ * @brief CNFG_BIOZ (0x18)
+ */
+ union max30001_bioz_reg {
+ uint32_t all;
+ struct {
+ uint32_t phoff : 4;
+ uint32_t cgmag : 3;
+ uint32_t cgmon : 1;
+ uint32_t fcgen : 4;
+ uint32_t dlpf : 2;
+ uint32_t dhpf : 2;
+ uint32_t gain : 2;
+ uint32_t reserved1 : 1;
+ uint32_t ext_rbias : 1;
+ uint32_t ahpf : 3;
+ uint32_t rate : 1;
+ uint32_t reserved : 8;
+ } bit;
+
+ } max30001_cnfg_bioz;
+
+
+ /**
+ * @brief CNFG_PACE (0x1A)
+ */
+ union max30001_cnfg_pace_reg {
+ uint32_t all;
+
+ struct {
+ uint32_t dacn : 4;
+ uint32_t dacp : 4;
+ uint32_t reserved1 : 4;
+ uint32_t aout : 2;
+ uint32_t aout_lbw : 1;
+ uint32_t reserved2 : 1;
+ uint32_t gain : 3;
+ uint32_t gn_diff_off : 1;
+ uint32_t reserved3 : 3;
+ uint32_t pol : 1;
+ uint32_t reserved : 8;
+ } bit;
+
+ } max30001_cnfg_pace;
+
+ /**
+ * @brief CNFG_RTOR1 (0x1D)
+ */
+ union max30001_cnfg_rtor1_reg {
+ uint32_t all;
+ struct {
+ uint32_t reserved1 : 8;
+ uint32_t ptsf : 4;
+ uint32_t pavg : 2;
+ uint32_t reserved2 : 1;
+ uint32_t en_rtor : 1;
+ uint32_t gain : 4;
+ uint32_t wndw : 4;
+ uint32_t reserved : 8;
+ } bit;
+
+ } max30001_cnfg_rtor1;
+
+ /**
+ * @brief CNFG_RTOR2 (0x1E)
+ */
+ union max30001_cnfg_rtor2_reg {
+ uint32_t all;
+ struct {
+ uint32_t reserved1 : 8;
+ uint32_t rhsf : 3;
+ uint32_t reserved2 : 1;
+ uint32_t ravg : 2;
+ uint32_t reserved3 : 2;
+ uint32_t hoff : 6;
+ uint32_t reserved4 : 2;
+ uint32_t reserved : 8;
+ } bit;
+
+ } max30001_cnfg_rtor2;
+
+ /*********************************************************************************/
+
+ typedef enum {
+ MAX30001_NO_INT = 0, // No interrupt
+ MAX30001_INT_B = 1, // INTB selected for interrupt
+ MAX30001_INT_2B = 2 // INT2B selected for interrupt
+ } max30001_intrpt_Location_t;
+
+ typedef enum {
+ MAX30001_INT_DISABLED = 0b00,
+ MAX30001_INT_CMOS = 0b01,
+ MAX30001_INT_ODN = 0b10,
+ MAX30001_INT_ODNR = 0b11
+ } max30001_intrpt_type_t;
+
+ typedef enum { // Input Polarity selection
+ MAX30001_NON_INV = 0, // Non-Inverted
+ MAX30001_INV = 1 // Inverted
+ } max30001_emux_pol;
+
+ typedef enum { // OPENP and OPENN setting
+ MAX30001_ECG_CON_AFE = 0, // ECGx is connected to AFE channel
+ MAX30001_ECG_ISO_AFE = 1 // ECGx is isolated from AFE channel
+ } max30001_emux_openx;
+
+ typedef enum { // EMUX_CALP_SEL & EMUX_CALN_SEL
+ MAX30001_NO_CAL_SIG = 0b00, // No calibration signal is applied
+ MAX30001_INPT_VMID = 0b01, // Input is connected to VMID
+ MAX30001_INPT_VCALP = 0b10, // Input is connected to VCALP
+ MAX30001_INPT_VCALN = 0b11 // Input is connected to VCALN
+ } max30001_emux_calx_sel;
+
+ typedef enum { // EN_ECG, EN_BIOZ, EN_PACE
+ MAX30001_CHANNEL_DISABLED = 0b0, //
+ MAX30001_CHANNEL_ENABLED = 0b1
+ } max30001_en_feature;
+
+ /*********************************************************************************/
+ // Data
+ uint32_t max30001_ECG_FIFO_buffer[32]; // (303 for internal test)
+ uint32_t max30001_BIOZ_FIFO_buffer[8]; // (303 for internal test)
+
+ uint32_t max30001_PACE[18]; // Pace Data 0-5
+
+ uint32_t max30001_RtoR_data; // This holds the RtoR data
+
+ uint32_t max30001_DCLeadOff; // This holds the LeadOff data, Last 4 bits give
+ // the status, BIT3=LOFF_PH, BIT2=LOFF_PL,
+ // BIT1=LOFF_NH, BIT0=LOFF_NL
+ // 8th and 9th bits tell Lead off is due to ECG or BIOZ.
+ // 0b01 = ECG Lead Off and 0b10 = BIOZ Lead off
+
+ uint32_t max30001_ACLeadOff; // This gives the state of the BIOZ AC Lead Off
+ // state. BIT 1 = BOVER, BIT 0 = BUNDR
+
+ uint32_t max30001_bcgmon; // This holds the BCGMON data, BIT 1 = BCGMP, BIT0 =
+ // BCGMN
+
+ uint32_t max30001_LeadOn; // This holds the LeadOn data, BIT1 = BIOZ Lead ON,
+ // BIT0 = ECG Lead ON, BIT8= Lead On Status Bit
+
+ uint32_t max30001_timeout; // If the PLL does not respond, timeout and get out.
+
+ typedef struct { // Creating a structure for BLE data
+ int16_t R2R;
+ int16_t fmstr;
+ } max30001_t;
+
+ max30001_t hspValMax30001; // R2R, FMSTR
+
+ /**
+ * @brief Constructor that accepts pin names for the SPI interface
+ * @param spi pointer to the mbed SPI object
+ */
+ MAX30001(SPI *spi);
+
+ /**
+ * @brief Constructor that accepts pin names for the SPI interface
+ * @param mosi master out slave in pin name
+ * @param miso master in slave out pin name
+ * @param sclk serial clock pin name
+ * @param cs chip select pin name
+ */
+ MAX30001(PinName mosi, PinName miso, PinName sclk, PinName cs);
+
+ /**
+ * MAX30001 destructor
+ */
+ ~MAX30001(void);
+
+ /**
+ * @brief This function sets up the Resistive Bias mode and also selects the master clock frequency.
+ * @brief Uses Register: CNFG_GEN-0x10
+ * @param En_rbias: Enable and Select Resitive Lead Bias Mode
+ * @param Rbiasv: Resistive Bias Mode Value Selection
+ * @param Rbiasp: Enables Resistive Bias on Positive Input
+ * @param Rbiasn: Enables Resistive Bias on Negative Input
+ * @param Fmstr: Selects Master Clock Frequency
+ * @returns 0-if no error. A non-zero value indicates an error.
+ *
+ */
+ int max30001_Rbias_FMSTR_Init(uint8_t En_rbias, uint8_t Rbiasv,
+ uint8_t Rbiasp, uint8_t Rbiasn, uint8_t Fmstr);
+
+ /**
+ * @brief This function uses sets up the calibration signal internally. If it is desired to use the internal signal, then
+ * @brief this function must be called and the registers set, prior to setting the CALP_SEL and CALN_SEL in the ECG_InitStart
+ * @brief and BIOZ_InitStart functions.
+ * @brief Uses Register: CNFG_CAL-0x12
+ * @param En_Vcal: Calibration Source (VCALP and VCALN) Enable
+ * @param Vmode: Calibration Source Mode Selection
+ * @param Vmag: Calibration Source Magnitude Selection (VMAG)
+ * @param Fcal: Calibration Source Frequency Selection (FCAL)
+ * @param Thigh: Calibration Source Time High Selection
+ * @param Fifty: Calibration Source Duty Cycle Mode Selection
+ * @returns 0-if no error. A non-zero value indicates an error.
+ *
+ */
+ int max30001_CAL_InitStart(uint8_t En_Vcal, uint8_t Vmode, uint8_t Vmag,
+ uint8_t Fcal, uint16_t Thigh, uint8_t Fifty);
+
+ /**
+ * @brief This function disables the VCAL signal
+ * @returns 0-if no error. A non-zero value indicates an error.
+ */
+ int max30001_CAL_Stop(void);
+
+ /**
+ * @brief This function handles the assignment of the two interrupt pins (INTB & INT2B) with various
+ * @brief functions/behaviors of the MAX30001. Also, each pin can be configured for different drive capability.
+ * @brief Uses Registers: EN_INT-0x02 and EN_INT2-0x03.
+ * @param max30001_intrpt_Locatio_t <argument>: All the arguments with the aforementioned enumeration essentially
+ * can be configured to generate an interrupt on either INTB or INT2B or NONE.
+ * @param max30001_intrpt_type_t intb_Type: INTB Port Type (EN_INT Selections).
+ * @param max30001_intrpt_type _t int2b_Type: INT2B Port Type (EN_INT2 Selections)
+ * @returns 0-if no error. A non-zero value indicates an error.
+ *
+ */
+ int max30001_INT_assignment(max30001_intrpt_Location_t en_enint_loc, max30001_intrpt_Location_t en_eovf_loc, max30001_intrpt_Location_t en_fstint_loc,
+ max30001_intrpt_Location_t en_dcloffint_loc, max30001_intrpt_Location_t en_bint_loc, max30001_intrpt_Location_t en_bovf_loc,
+ max30001_intrpt_Location_t en_bover_loc, max30001_intrpt_Location_t en_bundr_loc, max30001_intrpt_Location_t en_bcgmon_loc,
+ max30001_intrpt_Location_t en_pint_loc, max30001_intrpt_Location_t en_povf_loc, max30001_intrpt_Location_t en_pedge_loc,
+ max30001_intrpt_Location_t en_lonint_loc, max30001_intrpt_Location_t en_rrint_loc, max30001_intrpt_Location_t en_samp_loc,
+ max30001_intrpt_type_t intb_Type, max30001_intrpt_type_t int2b_Type);
+
+
+
+ /**
+ * @brief For MAX30001/3 ONLY
+ * @brief This function sets up the MAX30001 for the ECG measurements.
+ * @brief Registers used: CNFG_EMUX, CNFG_GEN, MNGR_INT, CNFG_ECG.
+ * @param En_ecg: ECG Channel Enable <CNFG_GEN register bits>
+ * @param Openp: Open the ECGN Input Switch (most often used for testing and calibration studies) <CNFG_EMUX register bits>
+ * @param Openn: Open the ECGN Input Switch (most often used for testing and calibration studies) <CNFG_EMUX register bits>
+ * @param Calp_sel: ECGP Calibration Selection <CNFG_EMUX register bits>
+ * @param Caln_sel: ECGN Calibration Selection <CNFG_EMUX register bits>
+ * @param E_fit: ECG FIFO Interrupt Threshold (issues EINT based on number of unread FIFO records) <CNFG_GEN register bits>
+ * @param Clr_rrint: RTOR R Detect Interrupt (RRINT) Clear Behavior <CNFG_GEN register bits>
+ * @param Rate: ECG Data Rate
+ * @param Gain: ECG Channel Gain Setting
+ * @param Dhpf: ECG Channel Digital High Pass Filter Cutoff Frequency
+ * @param Dlpf: ECG Channel Digital Low Pass Filter Cutoff Frequency
+ * @returns 0-if no error. A non-zero value indicates an error.
+ *
+ */
+ int max30001_ECG_InitStart(uint8_t En_ecg, uint8_t Openp, uint8_t Openn,
+ uint8_t Pol, uint8_t Calp_sel, uint8_t Caln_sel,
+ uint8_t E_fit, uint8_t Rate, uint8_t Gain,
+ uint8_t Dhpf, uint8_t Dlpf);
+
+ /**
+ * @brief For MAX30001/3 ONLY
+ * @brief This function enables the Fast mode feature of the ECG.
+ * @brief Registers used: MNGR_INT-0x04, MNGR_DYN-0x05
+ * @param Clr_Fast: FAST MODE Interrupt Clear Behavior <MNGR_INT Register>
+ * @param Fast: ECG Channel Fast Recovery Mode Selection (ECG High Pass Filter Bypass) <MNGR_DYN Register>
+ * @param Fast_Th: Automatic Fast Recovery Threshold
+ * @returns 0-if no error. A non-zero value indicates an error.
+ *
+ */
+ int max30001_ECGFast_Init(uint8_t Clr_Fast, uint8_t Fast, uint8_t Fast_Th);
+
+ /**
+ * @brief For MAX30001/3 ONLY
+ * @brief This function disables the ECG.
+ * @brief Uses Register CNFG_GEN-0x10.
+ * @returns 0-if no error. A non-zero value indicates an error.
+ *
+ */
+ int max30001_Stop_ECG(void);
+
+ /**
+ * @brief For MAX30001 ONLY
+ * @brief This function sets up the MAX30001 for pace signal detection.
+ * @brief If both PACE and BIOZ are turned ON, then make sure Fcgen is set for 80K or 40K in the
+ * @brief max30001_BIOZ_InitStart() function. However, if Only PACE is on but BIOZ off, then Fcgen can be set
+ * @brief for 80K only, in the max30001_BIOZ_InitStart() function
+ * @brief Registers used: MNGR_INT-0x04, CNFG_GEN-0x37, CNFG_PACE-0x1A.
+ * @param En_pace : PACE Channel Enable <CNFG_GEN Register>
+ * @param Clr_pedge : PACE Edge Detect Interrupt (PEDGE) Clear Behavior <MNGR_INT Register>
+ * @param Pol: PACE Input Polarity Selection <CNFG_PACE Register>
+ * @param Gn_diff_off: PACE Differentiator Mode <CNFG_PACE Register>
+ * @param Gain: PACE Channel Gain Selection <CNFG_PACE Register>
+ * @param Aout_lbw: PACE Analog Output Buffer Bandwidth Mode <CNFG_PACE Register>
+ * @param Aout: PACE Single Ended Analog Output Buffer Signal Monitoring Selection <CNFG_PACE Register>
+ * @param Dacp (4bits): PACE Detector Positive Comparator Threshold <CNFG_PACE Register>
+ * @param Dacn(4bits): PACE Detector Negative Comparator Threshold <CNFG_PACE Register>
+ * @returns 0-if no error. A non-zero value indicates an error <CNFG_PACE Register>
+ *
+ */
+ int max30001_PACE_InitStart(uint8_t En_pace, uint8_t Clr_pedge, uint8_t Pol,
+ uint8_t Gn_diff_off, uint8_t Gain,
+ uint8_t Aout_lbw, uint8_t Aout, uint8_t Dacp,
+ uint8_t Dacn);
+
+ /**
+ *@brief For MAX30001 ONLY
+ *@param This function disables the PACE. Uses Register CNFG_GEN-0x10.
+ *@returns 0-if no error. A non-zero value indicates an error.
+ *
+ */
+ int max30001_Stop_PACE(void);
+
+ /**
+ * @brief For MAX30001/2 ONLY
+ * @brief This function sets up the MAX30001 for BIOZ measurement.
+ * @brief Registers used: MNGR_INT-0x04, CNFG_GEN-0X10, CNFG_BMUX-0x17,CNFG_BIOZ-0x18.
+ * @param En_bioz: BIOZ Channel Enable <CNFG_GEN Register>
+ * @param Openp: Open the BIP Input Switch <CNFG_BMUX Register>
+ * @param Openn: Open the BIN Input Switch <CNFG_BMUX Register>
+ * @param Calp_sel: BIP Calibration Selection <CNFG_BMUX Register>
+ * @param Caln_sel: BIN Calibration Selection <CNFG_BMUX Register>
+ * @param CG_mode: BIOZ Current Generator Mode Selection <CNFG_BMUX Register>
+ * @param B_fit: BIOZ FIFO Interrupt Threshold (issues BINT based on number of unread FIFO records) <MNGR_INT Register>
+ * @param Rate: BIOZ Data Rate <CNFG_BIOZ Register>
+ * @param Ahpf: BIOZ/PACE Channel Analog High Pass Filter Cutoff Frequency and Bypass <CNFG_BIOZ Register>
+ * @param Ext_rbias: External Resistor Bias Enable <CNFG_BIOZ Register>
+ * @param Gain: BIOZ Channel Gain Setting <CNFG_BIOZ Register>
+ * @param Dhpf: BIOZ Channel Digital High Pass Filter Cutoff Frequency <CNFG_BIOZ Register>
+ * @param Dlpf: BIOZ Channel Digital Low Pass Filter Cutoff Frequency <CNFG_BIOZ Register>
+ * @param Fcgen: BIOZ Current Generator Modulation Frequency <CNFG_BIOZ Register>
+ * @param Cgmon: BIOZ Current Generator Monitor <CNFG_BIOZ Register>
+ * @param Cgmag: BIOZ Current Generator Magnitude <CNFG_BIOZ Register>
+ * @param Phoff: BIOZ Current Generator Modulation Phase Offset <CNFG_BIOZ Register>
+ * @returns 0-if no error. A non-zero value indicates an error.
+ *
+ */
+ int max30001_BIOZ_InitStart(uint8_t En_bioz, uint8_t Openp, uint8_t Openn,
+ uint8_t Calp_sel, uint8_t Caln_sel,
+ uint8_t CG_mode,
+ /* uint8_t En_bioz,*/ uint8_t B_fit, uint8_t Rate,
+ uint8_t Ahpf, uint8_t Ext_rbias, uint8_t Gain,
+ uint8_t Dhpf, uint8_t Dlpf, uint8_t Fcgen,
+ uint8_t Cgmon, uint8_t Cgmag, uint8_t Phoff);
+
+ /**
+ * @brief For MAX30001/2 ONLY
+ * @brief This function disables the BIOZ. Uses Register CNFG_GEN-0x10.
+ * @returns 0-if no error. A non-zero value indicates an error.
+ * @returns 0-if no error. A non-zero value indicates an error.
+ *
+ */
+ int max30001_Stop_BIOZ(void);
+
+ /**
+ * @brief For MAX30001/2 ONLY
+ * @brief BIOZ modulated Resistance Built-in-Self-Test, Registers used: CNFG_BMUX-0x17
+ * @param En_bist: Enable Modulated Resistance Built-in-Self-test <CNFG_BMUX Register>
+ * @param Rnom: BIOZ RMOD BIST Nominal Resistance Selection <CNFG_BMUX Register>
+ * @param Rmod: BIOZ RMOD BIST Modulated Resistance Selection <CNFG_BMUX Register>
+ * @param Fbist: BIOZ RMOD BIST Frequency Selection <CNFG_BMUX Register>
+ * @returns 0-if no error. A non-zero value indicates an error.
+ *
+ */
+ int max30001_BIOZ_InitBist(uint8_t En_bist, uint8_t Rnom, uint8_t Rmod,
+ uint8_t Fbist);
+
+ /**
+ * @brief For MAX30001/3/4 ONLY
+ * @brief Sets up the device for RtoR measurement
+ * @param EN_rtor: ECG RTOR Detection Enable <RTOR1 Register>
+ * @param Wndw: R to R Window Averaging (Window Width = RTOR_WNDW[3:0]*8mS) <RTOR1 Register>
+ * @param Gain: R to R Gain (where Gain = 2^RTOR_GAIN[3:0], plus an auto-scale option) <RTOR1 Register>
+ * @param Pavg: R to R Peak Averaging Weight Factor <RTOR1 Register>
+ * @param Ptsf: R to R Peak Threshold Scaling Factor <RTOR1 Register>
+ * @param Hoff: R to R minimum Hold Off <RTOR2 Register>
+ * @param Ravg: R to R Interval Averaging Weight Factor <RTOR2 Register>
+ * @param Rhsf: R to R Interval Hold Off Scaling Factor <RTOR2 Register>
+ * @param Clr_rrint: RTOR Detect Interrupt Clear behaviour <MNGR_INT Register>
+ * @returns 0-if no error. A non-zero value indicates an error.
+ *
+ */
+ int max30001_RtoR_InitStart(uint8_t En_rtor, uint8_t Wndw, uint8_t Gain,
+ uint8_t Pavg, uint8_t Ptsf, uint8_t Hoff,
+ uint8_t Ravg, uint8_t Rhsf, uint8_t Clr_rrint);
+
+ /**
+ * @brief For MAX30001/3/4 ONLY
+ * @brief This function disables the RtoR. Uses Register CNFG_RTOR1-0x1D
+ * @returns 0-if no error. A non-zero value indicates an error.
+ *
+ */
+ int max30001_Stop_RtoR(void);
+
+ /**
+ * @brief This is a function that waits for the PLL to lock; once a lock is achieved it exits out. (For convenience only)
+ * @returns 0-if no error. A non-zero value indicates an error.
+ *
+ */
+ int max30001_PLL_lock(void);
+
+ /**
+ * @brief This function causes the MAX30001 to reset. Uses Register SW_RST-0x08
+ * @return 0-if no error. A non-zero value indicates an error.
+ *
+ */
+ int max30001_sw_rst(void);
+
+ /**
+ * @brief This function provides a SYNCH operation. Uses Register SYCNH-0x09. Please refer to the data sheet for
+ * @brief the details on how to use this.
+ * @returns 0-if no error. A non-zero value indicates an error.
+ *
+ */
+ int max30001_synch(void);
+
+ /**
+ * @brief This function performs a FIFO Reset. Uses Register FIFO_RST-0x0A. Please refer to the data sheet
+ * @brief for the details on how to use this.
+ * @returns 0-if no error. A non-zero value indicates an error.
+ */
+ int max300001_fifo_rst(void);
+
+ /**
+ *
+ * @brief This is a callback function which collects all the data from the ECG, BIOZ, PACE and RtoR. It also handles
+ * @brief Lead On/Off. This function is passed through the argument of max30001_COMMinit().
+ * @returns 0-if no error. A non-zero value indicates an error.
+ *
+ */
+ int max30001_int_handler(void);
+
+ /**
+ * @brief This is function called from the max30001_int_handler() function and processes all the ECG, BIOZ, PACE
+ * @brief and the RtoR data and sticks them in appropriate arrays and variables each unsigned 32 bits.
+ * @param ECG data will be in the array (input): max30001_ECG_FIFO_buffer[]
+ * @param Pace data will be in the array (input): max30001_PACE[]
+ * @param RtoRdata will be in the variable (input): max30001_RtoR_data
+ * @param BIOZ data will be in the array (input): max30001_BIOZ_FIFO_buffer[]
+ * @param global max30001_ECG_FIFO_buffer[]
+ * @param global max30001_PACE[]
+ * @param global max30001_BIOZ_FIFO_buffer[]
+ * @param global max30001_RtoR_data
+ * @param global max30001_DCLeadOff
+ * @param global max30001_ACLeadOff
+ * @param global max30001_LeadON
+ * @returns 0-if no error. A non-zero value indicates an error.
+ *
+ */
+ int max30001_FIFO_LeadONOff_Read(void);
+
+ /**
+ * @brief This function allows writing to a register.
+ * @param addr: Address of the register to write to
+ * @param data: 24-bit data read from the register.
+ * @returns 0-if no error. A non-zero value indicates an error.
+ *
+ */
+ int max30001_reg_write(MAX30001_REG_map_t addr, uint32_t data);
+
+ /**
+ * @brief This function allows reading from a register
+ * @param addr: Address of the register to read from.
+ * @param *return_data: pointer to the value read from the register.
+ * @returns 0-if no error. A non-zero value indicates an error.
+ *
+ */
+ int max30001_reg_read(MAX30001_REG_map_t addr, uint32_t *return_data);
+
+ /**
+ * @brief This function enables the DC Lead Off detection. Either ECG or BIOZ can be detected, one at a time.
+ * @brief Registers Used: CNFG_GEN-0x10
+ * @param En_dcloff: BIOZ Digital Lead Off Detection Enable
+ * @param Ipol: DC Lead Off Current Polarity (if current sources are enabled/connected)
+ * @param Imag: DC Lead off current Magnitude Selection
+ * @param Vth: DC Lead Off Voltage Threshold Selection
+ * @returns 0-if no error. A non-zero value indicates an error.
+ *
+ */
+ int max30001_Enable_DcLeadOFF_Init(int8_t En_dcloff, int8_t Ipol, int8_t Imag,
+ int8_t Vth);
+
+ /**
+ * @brief This function disables the DC Lead OFF feature, whichever is active.
+ * @returns 0-if no error. A non-zero value indicates an error.
+ *
+ */
+ int max30001_Disable_DcLeadOFF(void);
+
+ /**
+ * @brief This function sets up the BIOZ for AC Lead Off test.
+ * @brief Registers Used: CNFG_GEN-0x10, MNGR_DYN-0x05
+ * @param En_bloff: BIOZ Digital Lead Off Detection Enable <CNFG_GEN register>
+ * @param Bloff_hi_it: DC Lead Off Current Polarity (if current sources are enabled/connected) <MNGR_DYN register>
+ * @param Bloff_lo_it: DC Lead off current Magnitude Selection <MNGR_DYN register>
+ * @returns 0-if no error. A non-zero value indicates an error.
+ *
+ */
+ int max30001_BIOZ_Enable_ACLeadOFF_Init(uint8_t En_bloff, uint8_t Bloff_hi_it,
+ uint8_t Bloff_lo_it);
+
+ /**
+ * @brief This function Turns of the BIOZ AC Lead OFF feature
+ * @brief Registers Used: CNFG_GEN-0x10
+ * @returns 0-if no error. A non-zero value indicates an error.
+ *
+ */
+ int max30001_BIOZ_Disable_ACleadOFF(void);
+
+ /**
+ * @brief This function enables the Current Gnerator Monitor
+ * @brief Registers Used: CNFG_BIOZ-0x18
+ * @returns 0-if no error. A non-zero value indicates an error.
+ *
+ */
+ int max30001_BIOZ_Enable_BCGMON(void);
+
+ /**
+ *
+ * @brief This function enables the Lead ON detection. Either ECG or BIOZ can be detected, one at a time.
+ * @brief Also, the en_bioz, en_ecg, en_pace setting is saved so that when this feature is disabled through the
+ * @brief max30001_Disable_LeadON() function (or otherwise) the enable/disable state of those features can be retrieved.
+ * @param Channel: ECG or BIOZ detection
+ * @returns 0-if everything is good. A non-zero value indicates an error.
+ *
+ */
+ int max30001_Enable_LeadON(int8_t Channel);
+
+ /**
+ * @brief This function turns off the Lead ON feature, whichever one is active. Also, retrieves the en_bioz,
+ * @brief en_ecg, en_pace and sets it back to as it was.
+ * @param 0-if everything is good. A non-zero value indicates an error.
+ *
+ */
+ int max30001_Disable_LeadON(void);
+
+ /**
+ *
+ * @brief This function is toggled every 2 seconds to switch between ECG Lead ON and BIOZ Lead ON detect
+ * @brief Adjust LEADOFF_SERVICE_TIME to determine the duration between the toggles.
+ * @param CurrentTime - This gets fed the time by RTC_GetValue function
+ *
+ */
+ void max30001_ServiceLeadON(uint32_t currentTime);
+
+ /**
+ *
+ * @brief This function is toggled every 2 seconds to switch between ECG DC Lead Off and BIOZ DC Lead Off
+ * @brief Adjust LEADOFF_SERVICE_TIME to determine the duration between the toggles.
+ * @param CurrentTime - This gets fed the time by RTC_GetValue function
+ *
+ */
+ void max30001_ServiceLeadoff(uint32_t currentTime);
+
+ /**
+ *
+ * @brief This function sets current RtoR values and fmstr values in a pointer structure
+ * @param hspValMax30001 - Pointer to a structure where to store the values
+ *
+ */
+ void max30001_ReadHeartrateData(max30001_t *_hspValMax30001);
+
+ /**
+ * @brief type definition for data interrupt
+ */
+ typedef void (*PtrFunction)(uint32_t id, uint32_t *buffer, uint32_t length);
+
+ /**
+ * @brief Used to connect a callback for when interrupt data is available
+ */
+ void onDataAvailable(PtrFunction _onDataAvailable);
+
+ static MAX30001 *instance;
+
+private:
+ void dataAvailable(uint32_t id, uint32_t *buffer, uint32_t length);
+ /// interrupt handler for async spi events
+ static void spiHandler(int events);
+ /// wrapper method to transmit and recieve SPI data
+ int SPI_Transmit(const uint8_t *tx_buf, uint32_t tx_size, uint8_t *rx_buf,
+ uint32_t rx_size);
+
+ /// pointer to mbed SPI object
+ SPI *spi;
+ /// is this object the owner of the spi object
+ bool spi_owner;
+ /// buffer to use for async transfers
+ uint8_t buffer[ASYNC_SPI_BUFFER_SIZE];
+ /// function pointer to the async callback
+ event_callback_t functionpointer;
+ /// callback function when interrupt data is available
+ PtrFunction onDataAvailableCallback;
+
+}; // End of MAX30001 Class
+
+/**
+ * @brief Preventive measure used to dismiss interrupts that fire too early during
+ * @brief initialization on INTB line
+ *
+ */
+void MAX30001Mid_IntB_Handler(void);
+
+/**
+ * @brief Preventive measure used to dismiss interrupts that fire too early during
+ * @brief initialization on INT2B line
+ *
+ */
+void MAX30001Mid_Int2B_Handler(void);
+
+/**
+ * @brief Allows Interrupts to be accepted as valid.
+ * @param state: 1-Allow interrupts, Any-Don't allow interrupts.
+ *
+ */
+void MAX30001_AllowInterrupts(int state);
+
+#endif /* MAX30001_H_ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/Devices/MAX30001/MAX30001_RPC.cpp Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,477 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+
+#include <stdio.h>
+#include "StringHelper.h"
+#include "MAX30001.h"
+#include "Streaming.h"
+#include "StringInOut.h"
+#include "MAX30001_helper.h"
+#include "RpcFifo.h"
+#include "RpcServer.h"
+#include "Peripherals.h"
+#include "DataLoggingService.h"
+
+/*static int startedEcg = 0;
+static int startedBioz = 0;
+static int startedCal = 0;
+static int startedPace = 0;
+static int startedRtor = 0;
+static void StopAll();
+*/
+
+extern int highDataRate;
+
+uint32_t max30001_RegRead(MAX30001::MAX30001_REG_map_t addr) {
+ uint32_t data;
+ Peripherals::max30001()->max30001_reg_read(addr, &data);
+ return data;
+}
+
+void max30001_RegWrite(MAX30001::MAX30001_REG_map_t addr, uint32_t data) {
+ Peripherals::max30001()->max30001_reg_write(addr, data);
+}
+
+int MAX30001_WriteReg(char argStrs[32][32], char replyStrs[32][32]) {
+ uint32_t args[2];
+ uint32_t reply[1];
+ uint32_t value;
+ ProcessArgs32(argStrs, args, sizeof(args) / sizeof(uint32_t));
+
+ max30001_RegWrite((MAX30001::MAX30001_REG_map_t)args[0], args[1]);
+ reply[0] = 0x80;
+ FormatReply32(reply, sizeof(reply) / sizeof(uint32_t), replyStrs);
+ return 0;
+}
+
+int MAX30001_ReadReg(char argStrs[32][32], char replyStrs[32][32]) {
+ uint32_t args[1];
+ uint32_t reply[1];
+ uint32_t value;
+ ProcessArgs32(argStrs, args, sizeof(args) / sizeof(uint32_t));
+ value = max30001_RegRead((MAX30001::MAX30001_REG_map_t)args[0]);
+ reply[0] = value;
+ FormatReply32(reply, sizeof(reply) / sizeof(uint32_t), replyStrs);
+ return 0;
+}
+
+int MAX30001_Rbias_FMSTR_Init(char argStrs[32][32], char replyStrs[32][32]) {
+ uint32_t args[5];
+ uint32_t reply[1];
+ uint32_t value;
+ ProcessArgs32(argStrs, args, sizeof(args) / sizeof(uint32_t));
+
+ value = Peripherals::max30001()->max30001_Rbias_FMSTR_Init(args[0], // En_rbias
+ args[1], // Rbiasv
+ args[2], // Rbiasp
+ args[3], // Rbiasn
+ args[4]); // Fmstr
+
+ reply[0] = value;
+ FormatReply32(reply, sizeof(reply) / sizeof(uint32_t), replyStrs);
+ return 0;
+}
+
+int MAX30001_CAL_InitStart(char argStrs[32][32], char replyStrs[32][32]) {
+ uint32_t args[6];
+ uint32_t reply[1];
+ uint32_t value;
+ ProcessArgs32(argStrs, args, sizeof(args) / sizeof(uint32_t));
+
+ // Peripherals::serial()->printf("MAX30001_CAL_InitStart 0 ");
+ value = Peripherals::max30001()->max30001_CAL_InitStart(args[0], // En_Vcal
+ args[1], // Vmag
+ args[2], // Fcal
+ args[3], // Thigh
+ args[4], // Fifty
+ args[5]); // Vmode
+
+ reply[0] = value;
+ FormatReply32(reply, sizeof(reply) / sizeof(uint32_t), replyStrs);
+ return 0;
+}
+
+int MAX30001_ECG_InitStart(char argStrs[32][32], char replyStrs[32][32]) {
+ uint32_t args[11];
+ uint32_t reply[1];
+ uint32_t value;
+ ProcessArgs32(argStrs, args, sizeof(args) / sizeof(uint32_t));
+
+ // Peripherals::serial()->printf("MAX30001_ECG_InitStart 0 ");
+ value = Peripherals::max30001()->max30001_ECG_InitStart(args[0], // En_ecg
+ args[1], // Openp
+ args[2], // Openn
+ args[3], // Pol
+ args[4], // Calp_sel
+ args[5], // Caln_sel
+ args[6], // E_fit
+ args[7], // Rate
+ args[8], // Gain
+ args[9], // Dhpf
+ args[10]); // Dlpf
+ // Peripherals::serial()->printf("MAX30001_ECG_InitStart 1 ");
+ MAX30001_Helper_SetStreamingFlag(eStreaming_ECG, 1);
+ reply[0] = value;
+ FormatReply32(reply, sizeof(reply) / sizeof(uint32_t), replyStrs);
+ return 0;
+}
+
+int MAX30001_ECGFast_Init(char argStrs[32][32], char replyStrs[32][32]) {
+ uint32_t args[3];
+ uint32_t reply[1];
+ uint32_t value;
+ ProcessArgs32(argStrs, args, sizeof(args) / sizeof(uint32_t));
+
+ value = Peripherals::max30001()->max30001_ECGFast_Init(args[0], // Clr_Fast
+ args[1], // Fast
+ args[2]); // Fast_Th
+
+ reply[0] = value;
+ FormatReply32(reply, sizeof(reply) / sizeof(uint32_t), replyStrs);
+ return 0;
+}
+
+int MAX30001_PACE_InitStart(char argStrs[32][32], char replyStrs[32][32]) {
+ uint32_t args[9];
+ uint32_t reply[1];
+ uint32_t value;
+ ProcessArgs32(argStrs, args, sizeof(args) / sizeof(uint32_t));
+
+ value =
+ Peripherals::max30001()->max30001_PACE_InitStart(args[0], // En_pace
+ args[1], // Clr_pedge
+ args[2], // Pol
+ args[3], // Gn_diff_off
+ args[4], // Gain
+ args[5], // Aout_lbw
+ args[6], // Aout
+ args[7], // Dacp
+ args[8]); // Dacn
+
+ MAX30001_Helper_SetStreamingFlag(eStreaming_PACE, 1);
+ reply[0] = value;
+ FormatReply32(reply, sizeof(reply) / sizeof(uint32_t), replyStrs);
+ return 0;
+}
+
+int MAX30001_BIOZ_InitStart(char argStrs[32][32], char replyStrs[32][32]) {
+ uint32_t args[17];
+ uint32_t reply[1];
+ uint32_t value;
+ ProcessArgs32(argStrs, args, sizeof(args) / sizeof(uint32_t));
+
+ value = Peripherals::max30001()->max30001_BIOZ_InitStart(args[0], // En_bioz
+ args[1], // Openp
+ args[2], // Openn
+ args[3], // Calp_sel
+ args[4], // Caln_sel
+ args[5], // CG_mode
+ args[6], // B_fit
+ args[7], // Rate
+ args[8], // Ahpf
+ args[9], // Ext_rbias
+ args[10], // Gain
+ args[11], // Dhpf
+ args[12], // Dlpf
+ args[13], // Fcgen
+ args[14], // Cgmon
+ args[15], // Cgmag
+ args[16]); // Phoff
+
+ MAX30001_Helper_SetStreamingFlag(eStreaming_BIOZ, 1);
+ reply[0] = value;
+ FormatReply32(reply, sizeof(reply) / sizeof(uint32_t), replyStrs);
+ return 0;
+}
+
+int MAX30001_RtoR_InitStart(char argStrs[32][32], char replyStrs[32][32]) {
+ uint32_t args[9];
+ uint32_t reply[1];
+ uint32_t value;
+ ProcessArgs32(argStrs, args, sizeof(args) / sizeof(uint32_t));
+
+ value = Peripherals::max30001()->max30001_RtoR_InitStart(args[0], // En_rtor
+ args[1], // Wndw
+ args[2], // Gain
+ args[3], // Pavg
+ args[4], // Ptsf
+ args[5], // Hoff
+ args[6], // Ravg
+ args[7], // Rhsf
+ args[8]); // Clr_rrint
+
+ MAX30001_Helper_SetStreamingFlag(eStreaming_RtoR, 1);
+ reply[0] = value;
+ FormatReply32(reply, sizeof(reply) / sizeof(uint32_t), replyStrs);
+ return 0;
+}
+
+int MAX30001_Stop_ECG(char argStrs[32][32], char replyStrs[32][32]) {
+ uint32_t reply[1];
+ Peripherals::max30001()->max30001_Stop_ECG();
+ reply[0] = 0x80;
+ FormatReply32(reply, sizeof(reply) / sizeof(uint32_t), replyStrs);
+ return 0;
+}
+int MAX30001_Stop_PACE(char argStrs[32][32], char replyStrs[32][32]) {
+ uint32_t reply[1];
+ Peripherals::max30001()->max30001_Stop_PACE();
+ reply[0] = 0x80;
+ FormatReply32(reply, sizeof(reply) / sizeof(uint32_t), replyStrs);
+ return 0;
+}
+int MAX30001_Stop_BIOZ(char argStrs[32][32], char replyStrs[32][32]) {
+ uint32_t reply[1];
+ Peripherals::max30001()->max30001_Stop_BIOZ();
+ reply[0] = 0x80;
+ FormatReply32(reply, sizeof(reply) / sizeof(uint32_t), replyStrs);
+ return 0;
+}
+int MAX30001_Stop_RtoR(char argStrs[32][32], char replyStrs[32][32]) {
+ uint32_t reply[1];
+ Peripherals::max30001()->max30001_Stop_RtoR();
+ reply[0] = 0x80;
+ FormatReply32(reply, sizeof(reply) / sizeof(uint32_t), replyStrs);
+ return 0;
+}
+int MAX30001_Stop_Cal(char argStrs[32][32], char replyStrs[32][32]) {
+ uint32_t reply[1];
+ // max30001_Stop_Cal();
+ reply[0] = 0x80;
+ FormatReply32(reply, sizeof(reply) / sizeof(uint32_t), replyStrs);
+ return 0;
+}
+
+void max30001_ServiceStreaming() {
+ char ch;
+ uint32_t val;
+ USBSerial *usbSerial = Peripherals::usbSerial();
+
+ fifo_clear(GetStreamOutFifo());
+
+ SetStreaming(TRUE);
+ clearOutReadFifo();
+ while (IsStreaming() == TRUE) {
+
+ if (fifo_empty(GetStreamOutFifo()) == 0) {
+ fifo_get32(GetStreamOutFifo(), &val);
+
+ usbSerial->printf("%02X ", val);
+
+ }
+ if (usbSerial->available()) {
+ ch = usbSerial->_getc();
+
+ MAX30001_Helper_Stop();
+ SetStreaming(FALSE);
+ fifo_clear(GetUSBIncomingFifo()); // clear USB serial incoming fifo
+ fifo_clear(GetStreamOutFifo());
+ }
+
+ }
+}
+
+int MAX30001_Start(char argStrs[32][32], char replyStrs[32][32]) {
+ uint32_t reply[1];
+ uint32_t all;
+ fifo_clear(GetUSBIncomingFifo());
+ Peripherals::max30001()->max30001_synch();
+ // max30001_ServiceStreaming();
+ highDataRate = 0;
+ Peripherals::max30001()->max30001_reg_read(MAX30001::STATUS, &all);
+ LoggingService_StartLoggingUsb();
+
+ reply[0] = 0x80;
+ FormatReply32(reply, sizeof(reply) / sizeof(uint32_t), replyStrs);
+ return 0;
+}
+
+int MAX30001_Stop(char argStrs[32][32], char replyStrs[32][32]) {
+ /* uint32_t args[1];
+ uint32_t reply[1];
+ uint32_t value;
+ //ProcessArgs32(argStrs, args, sizeof(args) / sizeof(uint32_t));
+ max30001_StopTest();
+ reply[0] = 0x80;
+ FormatReply32(reply, sizeof(reply) / sizeof(uint32_t), replyStrs);*/
+ return 0;
+}
+
+int MAX30001_INT_assignment(char argStrs[32][32], char replyStrs[32][32]) {
+ uint32_t args[17];
+ uint32_t reply[1];
+ ProcessArgs32(argStrs, args, sizeof(args) / sizeof(uint32_t));
+ /*
+ printf("MAX30001_INT_assignment ");
+ printf("%d ",args[0]);
+ printf("%d ",args[1]);
+ printf("%d ",args[2]);
+ printf("%d ",args[3]);
+ printf("%d ",args[4]);
+ printf("%d ",args[5]);
+ printf("%d ",args[6]);
+ printf("%d ",args[7]);
+ printf("%d ",args[8]);
+ printf("%d ",args[9]);
+ printf("%d ",args[10]);
+ printf("%d ",args[11]);
+ printf("%d ",args[12]);
+ printf("%d ",args[13]);
+ printf("%d ",args[14]);
+ printf("%d ",args[15]);
+ printf("%d ",args[16]);
+ printf("\n");
+ fflush(stdout);
+ */
+
+ Peripherals::max30001()->max30001_INT_assignment(
+ (MAX30001::max30001_intrpt_Location_t)args[0],
+ (MAX30001::max30001_intrpt_Location_t)args[1],
+ (MAX30001::max30001_intrpt_Location_t)args[2],
+ (MAX30001::max30001_intrpt_Location_t)args[3],
+ (MAX30001::max30001_intrpt_Location_t)args[4],
+ (MAX30001::max30001_intrpt_Location_t)args[5],
+ (MAX30001::max30001_intrpt_Location_t)args[6],
+ (MAX30001::max30001_intrpt_Location_t)args[7],
+ (MAX30001::max30001_intrpt_Location_t)args[8],
+ (MAX30001::max30001_intrpt_Location_t)args[9],
+ (MAX30001::max30001_intrpt_Location_t)args[10],
+ (MAX30001::max30001_intrpt_Location_t)args[11],
+ (MAX30001::max30001_intrpt_Location_t)args[12],
+ (MAX30001::max30001_intrpt_Location_t)args[13],
+ (MAX30001::max30001_intrpt_Location_t)args[14],
+ (MAX30001::max30001_intrpt_type_t)args[15],
+ (MAX30001::max30001_intrpt_type_t)args[16]);
+ reply[0] = 0x80;
+ FormatReply32(reply, sizeof(reply) / sizeof(uint32_t), replyStrs);
+ return 0;
+}
+
+int MAX30001_StartTest(char argStrs[32][32], char replyStrs[32][32]) {
+ uint32_t reply[1];
+ // ProcessArgs32(argStrs, args, sizeof(args) / sizeof(uint32_t));
+
+ /*** Set FMSTR over here ****/
+
+ /*** Set and Start the VCAL input ***/
+ /* NOTE VCAL must be set first if VCAL is to be used */
+ Peripherals::max30001()->max30001_CAL_InitStart(0b1, 0b1, 0b1, 0b011, 0x7FF, 0b0);
+
+ /**** ECG Initialization ****/
+ Peripherals::max30001()->max30001_ECG_InitStart(0b1, 0b1, 0b1, 0b0, 0b10, 0b11, 31, 0b00, 0b00, 0b0, 0b01);
+
+ /***** PACE Initialization ***/
+ Peripherals::max30001()->max30001_PACE_InitStart(0b1, 0b0, 0b0, 0b1, 0b000, 0b0, 0b00, 0b0, 0b0);
+
+ /**** BIOZ Initialization ****/
+ Peripherals::max30001()->max30001_BIOZ_InitStart(
+ 0b1, 0b1, 0b1, 0b10, 0b11, 0b00, 7, 0b0, 0b111, 0b0, 0b10, 0b00, 0b00, 0b0001, 0b0, 0b111, 0b0000);
+
+ /*** Set RtoR registers ***/
+ Peripherals::max30001()->max30001_RtoR_InitStart(
+ 0b1, 0b0011, 0b1111, 0b00, 0b0011, 0b000001, 0b00, 0b000, 0b01);
+
+ /*** Set Rbias & FMSTR over here ****/
+ Peripherals::max30001()->max30001_Rbias_FMSTR_Init(0b01, 0b10, 0b1, 0b1, 0b00);
+
+ /**** Interrupt Setting ****/
+
+ /*** Set ECG Lead ON/OFF ***/
+ // max30001_ECG_LeadOnOff();
+
+ /*** Set BIOZ Lead ON/OFF ***/
+ // max30001_BIOZ_LeadOnOff(); Does not work yet...
+
+ /**** Do a Synch ****/
+ Peripherals::max30001()->max30001_synch();
+
+ fifo_clear(GetUSBIncomingFifo());
+ max30001_ServiceStreaming();
+
+ reply[0] = 0x80;
+ FormatReply32(reply, sizeof(reply) / sizeof(uint32_t), replyStrs);
+ return 0;
+}
+/*
+static void StopAll() {
+ if (startedEcg == 1) {
+ max30001_Stop_ECG();
+ }
+ if (startedCal == 1) {
+ }
+ if (startedBioz == 1) {
+ max30001_Stop_BIOZ();
+ }
+ if (startedPace == 1) {
+ max30001_Stop_PACE();
+ }
+ if (startedRtor == 1) {
+ max30001_Stop_RtoR();
+ }
+ startedEcg = 0;
+ startedBioz = 0;
+ startedCal = 0;
+ startedPace = 0;
+ startedRtor = 0;
+}
+*/
+/*
+// switch to ECG DC Lead ON
+max30001_Enable_LeadON(0b01);
+// switch to BIOZ DC Lead ON
+max30001_Enable_LeadON(0b10);
+*/
+int MAX30001_Enable_ECG_LeadON(char argStrs[32][32], char replyStrs[32][32]) {
+ uint32_t reply[1];
+ // switch to ECG DC Lead ON
+ Peripherals::max30001()->max30001_Enable_LeadON(0b01);
+ reply[0] = 0x80;
+ FormatReply32(reply, sizeof(reply) / sizeof(uint32_t), replyStrs);
+ return 0;
+}
+int MAX30001_Enable_BIOZ_LeadON(char argStrs[32][32], char replyStrs[32][32]) {
+ uint32_t reply[1];
+ // switch to BIOZ DC Lead ON
+ Peripherals::max30001()->max30001_Enable_LeadON(0b10);
+ reply[0] = 0x80;
+ FormatReply32(reply, sizeof(reply) / sizeof(uint32_t), replyStrs);
+ return 0;
+}
+// uint32_t max30001_LeadOn; // This holds the LeadOn data, BIT1 = BIOZ Lead ON, BIT0 = ECG Lead ON
+int MAX30001_Read_LeadON(char argStrs[32][32], char replyStrs[32][32]) {
+ uint32_t reply[1];
+ // return the max30001_LeadOn var from the MAX30001 driver
+ reply[0] = Peripherals::max30001()->max30001_LeadOn;
+ FormatReply32(reply, sizeof(reply) / sizeof(uint32_t), replyStrs);
+ return 0;
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/HSP/Devices/MAX30001/MAX30001_RPC.h Tue Oct 25 15:22:11 2016 +0000 @@ -0,0 +1,59 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ +#ifndef __MAX300001_RPC_H +#define __MAX300001_RPC_H + +int MAX30001_WriteReg(char argStrs[32][32], char replyStrs[32][32]); +int MAX30001_ReadReg(char argStrs[32][32], char replyStrs[32][32]); +int MAX30001_Start(char argStrs[32][32], char replyStrs[32][32]); +int MAX30001_Stop(char argStrs[32][32], char replyStrs[32][32]); +int MAX30001_Rbias_FMSTR_Init(char argStrs[32][32], char replyStrs[32][32]); +int MAX30001_CAL_InitStart(char argStrs[32][32], char replyStrs[32][32]); +int MAX30001_ECG_InitStart(char argStrs[32][32], char replyStrs[32][32]); +int MAX30001_ECGFast_Init(char argStrs[32][32], char replyStrs[32][32]); +int MAX30001_PACE_InitStart(char argStrs[32][32], char replyStrs[32][32]); +int MAX30001_BIOZ_InitStart(char argStrs[32][32], char replyStrs[32][32]); +int MAX30001_RtoR_InitStart(char argStrs[32][32], char replyStrs[32][32]); +int MAX30001_Stop_ECG(char argStrs[32][32], char replyStrs[32][32]); +int MAX30001_Stop_PACE(char argStrs[32][32], char replyStrs[32][32]); +int MAX30001_Stop_BIOZ(char argStrs[32][32], char replyStrs[32][32]); +int MAX30001_Stop_RtoR(char argStrs[32][32], char replyStrs[32][32]); +int MAX30001_Stop_Cal(char argStrs[32][32], char replyStrs[32][32]); +int MAX30001_Enable_ECG_LeadON(char argStrs[32][32], char replyStrs[32][32]); +int MAX30001_Enable_BIOZ_LeadON(char argStrs[32][32], char replyStrs[32][32]); +int MAX30001_Read_LeadON(char argStrs[32][32], char replyStrs[32][32]); + +int MAX30001_StartTest(char argStrs[32][32], char replyStrs[32][32]); +int MAX30001_INT_assignment(char argStrs[32][32], char replyStrs[32][32]); + +#endif /* __MAX300001_RPC_H */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/Devices/MAX30001/MAX30001_helper.cpp Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,122 @@
+
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+
+#include "MAX30001_helper.h"
+#include "MAX30001.h"
+#include "StringInOut.h"
+#include "Peripherals.h"
+
+static uint8_t flags[4];
+
+int MAX30001_Helper_IsStreaming(eFlags flag) {
+ return flags[(uint32_t)flag];
+}
+
+void MAX30001_Helper_SetStreamingFlag(eFlags flag, uint8_t state) {
+ flags[(uint32_t)flag] = state;
+}
+
+void MAX30001_Helper_Stop(void) {
+ if (flags[(uint32_t)eStreaming_ECG] == 1) {
+ Peripherals::max30001()->max30001_Stop_ECG();
+ }
+ if (flags[(uint32_t)eStreaming_PACE] == 1) {
+ Peripherals::max30001()->max30001_Stop_PACE();
+ }
+ if (flags[(uint32_t)eStreaming_BIOZ] == 1) {
+ Peripherals::max30001()->max30001_Stop_BIOZ();
+ }
+ if (flags[(uint32_t)eStreaming_RtoR] == 1) {
+ Peripherals::max30001()->max30001_Stop_RtoR();
+ }
+ MAX30001_Helper_ClearStreamingFlags();
+}
+
+int MAX30001_AnyStreamingSet(void) {
+ uint32_t i;
+ for (i = 0; i < 4; i++) {
+ if (flags[i] == 1) return 1;
+ }
+ return 0;
+}
+
+void MAX30001_Helper_StartSync(void) {
+ if (MAX30001_AnyStreamingSet() == 1) {
+ Peripherals::max30001()->max30001_synch();
+ }
+}
+
+void MAX30001_Helper_ClearStreamingFlags(void) {
+ uint32_t i;
+ for (i = 0; i < 4; i++) {
+ flags[i] = 0;
+ }
+}
+
+void MAX30001_Helper_Debug_ShowStreamFlags(void) {
+ putStr("\r\n");
+ if (flags[(uint32_t)eStreaming_ECG] == 1) {
+ putStr("eStreaming_ECG, ");
+ }
+ if (flags[(uint32_t)eStreaming_PACE] == 1) {
+ putStr("eStreaming_PACE, ");
+ }
+ if (flags[(uint32_t)eStreaming_BIOZ] == 1) {
+ putStr("eStreaming_BIOZ, ");
+ }
+ if (flags[(uint32_t)eStreaming_RtoR] == 1) {
+ putStr("eStreaming_RtoR, ");
+ }
+ putStr("\r\n");
+}
+
+void MAX30001_Helper_SetupInterrupts() {
+ Peripherals::max30001()->max30001_INT_assignment(MAX30001::MAX30001_INT_B, MAX30001::MAX30001_NO_INT, MAX30001::MAX30001_NO_INT, // en_enint_loc, en_eovf_loc, en_fstint_loc,
+ MAX30001::MAX30001_INT_2B, MAX30001::MAX30001_INT_2B, MAX30001::MAX30001_NO_INT, // en_dcloffint_loc, en_bint_loc, en_bovf_loc,
+ MAX30001::MAX30001_INT_2B, MAX30001::MAX30001_INT_2B, MAX30001::MAX30001_NO_INT, // en_bover_loc, en_bundr_loc, en_bcgmon_loc,
+ MAX30001::MAX30001_INT_B, MAX30001::MAX30001_NO_INT, MAX30001::MAX30001_NO_INT, // en_pint_loc, en_povf_loc, en_pedge_loc,
+ MAX30001::MAX30001_INT_2B, MAX30001::MAX30001_INT_B, MAX30001::MAX30001_NO_INT, // en_lonint_loc, en_rrint_loc, en_samp_loc,
+ MAX30001::MAX30001_INT_ODNR, MAX30001::MAX30001_INT_ODNR); // intb_Type, int2b_Type)
+}
+
+
+
+static uint8_t serialNumber[6];
+uint8_t *MAX30001_Helper_getVersion(void) {
+ // read the id
+ Peripherals::max30001()->max30001_reg_read(MAX30001::INFO, (uint32_t *)serialNumber);
+ // read id twice because it needs to be read twice
+ Peripherals::max30001()->max30001_reg_read(MAX30001::INFO, (uint32_t *)serialNumber);
+ return serialNumber;
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/Devices/MAX30001/MAX30001_helper.h Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,55 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+#ifndef MAX30001_HELPER_H_
+#define MAX30001_HELPER_H_
+
+#include "mbed.h"
+
+typedef enum eFlags {
+ eStreaming_ECG,
+ eStreaming_PACE,
+ eStreaming_BIOZ,
+ eStreaming_RtoR
+} eFlags;
+
+int MAX30001_Helper_IsStreaming(eFlags flag);
+void MAX30001_Helper_SetStreamingFlag(eFlags flag, uint8_t state);
+void MAX30001_Helper_Stop(void);
+void MAX30001_Helper_ClearStreamingFlags(void);
+int MAX30001_AnyStreamingSet(void);
+void MAX30001_Helper_Debug_ShowStreamFlags(void);
+void MAX30001_Helper_StartSync(void);
+void MAX30001_Helper_SetupInterrupts(void);
+uint8_t *MAX30001_Helper_getVersion(void);
+
+#endif /* MAX30001_HELPER_H_ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/Devices/MAX30101/MAX30101/MAX30101.cpp Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,703 @@
+
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+
+#include "mbed.h"
+#include "MAX30101.h"
+
+MAX30101 *MAX30101::instance = NULL;
+
+//******************************************************************************
+MAX30101::MAX30101(PinName sda, PinName scl, int slaveAddress):
+ slaveAddress(slaveAddress) {
+ i2c = new I2C(sda, scl);
+ i2c_owner = true;
+ i2c->frequency(400000);
+ onInterruptCallback = NULL;
+ onDataAvailableCallback = NULL;
+ instance = this;
+}
+
+//******************************************************************************
+MAX30101::MAX30101(I2C *_i2c, int slaveAddress) :
+ slaveAddress(slaveAddress) {
+ i2c = _i2c;
+ i2c_owner = false;
+ i2c->frequency(400000);
+ onInterruptCallback = NULL;
+ onDataAvailableCallback = NULL;
+ instance = this;
+}
+
+//******************************************************************************
+MAX30101::~MAX30101(void) {
+ if (i2c_owner) {
+ delete i2c;
+ }
+}
+
+//******************************************************************************
+int MAX30101::int_handler(void) {
+ uint16_t index, i;
+ uint16_t rx_bytes, second_rx_bytes;
+ char temp_int;
+ char temp_frac;
+ uint16_t num_active_led;
+ uint32_t sample;
+ int loop = 1;
+ static uint8_t cntr_int = 0;
+
+
+ cntr_int++;
+
+ while (loop) {
+ if (i2c_reg_read(REG_INT_STAT_1, &max30101_Interrupt_Status_1.all) != 0) // Read Interrupt flag bits
+ {
+ return -1;
+ }
+
+ if (i2c_reg_read(REG_INT_STAT_2, &max30101_Interrupt_Status_2.all) != 0) // Read Interrupt flag bits
+ {
+ return -1;
+ }
+
+ if (max30101_Interrupt_Status_1.bit.a_full) {
+ /* Read the sample(s) */
+ char reg = REG_FIFO_DATA;
+
+ num_active_led = 0;
+
+ if (max30101_mode_configuration.bit.mode == 0x02) // Heart Rate mode, i.e. 1 led
+ {
+ num_active_led = 1;
+ } else if (max30101_mode_configuration.bit.mode == 0x03) // SpO2 mode, i.e. 2 led
+ {
+ num_active_led = 2;
+ } else if (max30101_mode_configuration.bit.mode == 0x07) // Multi-LED mode, i.e. 1-4 led
+ {
+ if (max30101_multiLED_mode_ctrl_1.bit.slot1 != 0) {
+ num_active_led++;
+ }
+
+ if (max30101_multiLED_mode_ctrl_1.bit.slot2 != 0) {
+ num_active_led++;
+ }
+
+ if (max30101_multiLED_mode_ctrl_2.bit.slot3 != 0) {
+ num_active_led++;
+ }
+
+ if (max30101_multiLED_mode_ctrl_2.bit.slot4 != 0) {
+ num_active_led++;
+ }
+ }
+ // 3bytes/LED x Number of Active LED x FIFO level selected
+ rx_bytes = 3 * num_active_led * (32-max30101_fifo_configuration.bit.fifo_a_full);
+
+ second_rx_bytes = rx_bytes;
+
+ /* The FIFO Size is determined by the Sample size. The number of bytes
+ * in a Sample is dictated by number of LED's
+ *
+ * #LED Selected Bytes in "1" sample
+ * 1 3
+ * 2 6
+ * 3 9
+ * 4 12
+ *
+ * The I2C API function limits the number of bytes to read to 256 (i.e.
+ * char). Therefore, when set for
+ * Multiple LED's and the FIFO size is set to 32. It would mean there is
+ * more than 256 bytes.
+ * In that case two I2C reads have to be made. However It is important
+ * to not that each "Sample"
+ * must be read completely and reading only partial number of bytes from
+ * a sample will result in erroneous data.
+ *
+ * For example:
+ * Num of LED selected = 3 and FIFO size is set to 32 (i.e. 0 value in
+ * register), then the number of bytes
+ * will be 3bytes/Led * 3led's * 32 = 288 bytes in all. Since there are
+ * 3 LED's each sample will contain (3 * 3)
+ * 9bytes. Therefore Sample 1 = 9bytes, Sample 2 = 18,... Sample 28 =
+ * 252. Therefore the first
+ * I2C read should be 252 bytes and the second read should be 288-252 =
+ * 36.
+ *
+ * It turns out that this size issue comes up only when number of LED
+ * selected is 3 or 4 and choosing 252bytes
+ * for the first I2C read would work for both Number of LED selection.
+ */
+
+ if (rx_bytes <= CHUNK_SIZE) {
+ I2CM_Read(slaveAddress, ®, 1, &max30101_rawData[0],
+ (char)rx_bytes /*total_databytes_1*/);
+ } else {
+ I2CM_Read(slaveAddress, ®, 1, &max30101_rawData[0], CHUNK_SIZE);
+
+ second_rx_bytes = second_rx_bytes - CHUNK_SIZE;
+ I2CM_Read(slaveAddress, ®, 1, &max30101_rawData[CHUNK_SIZE],
+ (char)second_rx_bytes);
+ }
+
+ index = 0;
+
+ for (i = 0; i < rx_bytes; i += 3) {
+ sample = ((uint32_t)(max30101_rawData[i] & 0x03) << 16) | (max30101_rawData[i + 1] << 8) | max30101_rawData[i + 2];
+
+ // Right shift the data based on the LED_PW setting
+ sample = sample >>
+ (3 -
+ max30101_spo2_configuration.bit.led_pw); // 0=shift 3, 1=shift 2, 2=shift 1, 3=no shift
+
+ max30101_buffer[index++] = sample;
+ }
+
+ onDataAvailableCallback(MAX30101_OXIMETER_DATA + num_active_led, max30101_buffer, index);
+ }
+
+// This interrupt handles the proximity interrupt, for future enhancements
+#if 0
+ if(max30101_Interrupt_Status_1.bit.prox_int)
+ {
+ max30101_mode_configuration.full=0;
+ max30101_mode_configuration.bit.mode=0x03; // SpO2 mode
+ i2c_reg_write(REG_MODE_CFG, max30101_mode_configuration.full);
+
+ }
+#endif
+
+ // This interrupt handles the temperature interrupt
+ if (max30101_Interrupt_Status_2.bit.die_temp_rdy) {
+ char reg;
+
+ reg = REG_TINT;
+ if (I2CM_Read(slaveAddress, ®, 1, &temp_int, 1) != 0) {
+ return -1;
+ }
+
+ reg = REG_TFRAC;
+ if (I2CM_Read(slaveAddress, ®, 1, &temp_frac, 1) != 0) {
+ return -1;
+ }
+
+ max30101_final_temp = (int8_t)temp_int + 0.0625 * temp_frac;
+
+ if (i2c_reg_write(REG_TEMP_EN, 0x00) != 0) // Die Temperature Config, Temp disable... after one read...
+ {
+ return -1;
+ }
+ }
+
+ if (i2c_reg_read(REG_INT_STAT_1, &max30101_Interrupt_Status_1.all) != 0) // Read Interrupt flag bits
+ {
+ return -1;
+ }
+ if (max30101_Interrupt_Status_1.bit.a_full != 1) {
+ loop = 0;
+ }
+ }
+
+ interruptPostCallback();
+
+
+ return 0;
+}
+
+//******************************************************************************
+int MAX30101::SpO2mode_init(uint8_t fifo_waterlevel_mark, uint8_t sample_avg,
+ uint8_t sample_rate, uint8_t pulse_width,
+ uint8_t red_led_current, uint8_t ir_led_current) {
+
+ char status;
+
+ max30101_mode_configuration.all = 0;
+ max30101_mode_configuration.bit.reset = 1;
+ if (i2c_reg_write(REG_MODE_CFG, max30101_mode_configuration.all) != 0) // Reset the device, Mode = don't use...
+ {
+ return -1;
+ }
+
+ /* Give it some settle time (100ms) */
+ wait(1.0 / 10.0); // Let things settle down a bit
+
+ max30101_fifo_configuration.all = 0;
+ max30101_fifo_configuration.bit.smp_ave = sample_avg; // Sample averaging;
+ max30101_fifo_configuration.bit.fifo_roll_over_en = 1; // FIFO Roll over enabled
+ max30101_fifo_configuration.bit.fifo_a_full = fifo_waterlevel_mark; // Interrupt when certain level is filled
+ if (i2c_reg_write(REG_FIFO_CFG, max30101_fifo_configuration.all) != 0) {
+ return -1;
+ }
+
+ max30101_spo2_configuration.bit.spo2_adc_rge = 0x2; // ADC Range 8192 fullscale
+ max30101_spo2_configuration.bit.spo2_sr = sample_rate; // 100 Samp/sec.
+ max30101_spo2_configuration.bit.led_pw = pulse_width; // Pulse Width=411us and ADC Resolution=18
+ if (i2c_reg_write(REG_SPO2_CFG, max30101_spo2_configuration.all) != 0) {
+ return -1;
+ }
+
+ max30101_led1_pa = red_led_current; // RED LED current
+ if (i2c_reg_write(REG_LED1_PA, max30101_led1_pa) != 0) {
+ return -1;
+ }
+
+ max30101_led2_pa = ir_led_current; // IR LED current
+ if (i2c_reg_write(REG_LED2_PA, max30101_led2_pa) != 0) {
+ return -1;
+ }
+
+ /************/
+
+ if (i2c_reg_read(REG_INT_STAT_1, &status) != 0) // Clear INT1 by reading the status
+ {
+ return -1;
+ }
+
+ if (i2c_reg_read(REG_INT_STAT_2, &status) != 0) // Clear INT2 by reading the status
+ {
+ return -1;
+ }
+
+ if (i2c_reg_write(REG_FIFO_W_PTR, 0x00) != 0) // Clear FIFO ptr
+ {
+ return -1;
+ }
+
+ if (i2c_reg_write(REG_FIFO_OVF_CNT, 0x00) != 0) // Clear FIFO ptr
+ {
+ return -1;
+ }
+
+ if (i2c_reg_write(REG_FIFO_R_PTR, 0x00) != 0) // Clear FIFO ptr
+ {
+ return -1;
+ }
+
+ max30101_Interrupt_Enable_1.all = 0;
+ max30101_Interrupt_Enable_1.bit.a_full_en = 1; // Enable FIFO almost full interrupt
+ if (i2c_reg_write(REG_INT_EN_1, max30101_Interrupt_Enable_1.all) != 0) {
+ return -1;
+ }
+
+ max30101_mode_configuration.all = 0;
+ max30101_mode_configuration.bit.mode = 0x03; // SpO2 mode
+ if (i2c_reg_write(REG_MODE_CFG, max30101_mode_configuration.all) != 0) {
+ return -1;
+ }
+
+ return 0;
+}
+
+//******************************************************************************
+int MAX30101::SpO2mode_stop(void) {
+
+ max30101_Interrupt_Enable_1.all = 0;
+ max30101_Interrupt_Enable_1.bit.a_full_en = 0; // Disable FIFO almost full interrupt
+ if (i2c_reg_write(REG_INT_EN_1, max30101_Interrupt_Enable_1.all) != 0) {
+ return -1;
+ }
+
+ max30101_mode_configuration.all = 0;
+ max30101_mode_configuration.bit.mode = 0x00; // SpO2 mode off
+ if (i2c_reg_write(REG_MODE_CFG, max30101_mode_configuration.all) != 0) {
+ return -1;
+ }
+
+ max30101_led1_pa = 0; // RED LED current, 0.0
+ if (i2c_reg_write(REG_LED1_PA, max30101_led1_pa) != 0) {
+ return -1;
+ }
+
+ max30101_led2_pa = 0; // IR LED current, 0.0
+ if (i2c_reg_write(REG_LED2_PA, max30101_led2_pa) != 0) {
+ return -1;
+ }
+
+ return 0;
+}
+
+//******************************************************************************
+int MAX30101::HRmode_init(uint8_t fifo_waterlevel_mark, uint8_t sample_avg,
+ uint8_t sample_rate, uint8_t pulse_width,
+ uint8_t red_led_current) {
+
+ /*uint8_t*/ char status;
+
+ max30101_mode_configuration.all = 0;
+ max30101_mode_configuration.bit.reset = 1;
+ if (i2c_reg_write(REG_MODE_CFG, max30101_mode_configuration.all) != 0) // Reset the device, Mode = don't use...
+ {
+ return -1;
+ }
+
+ /* Give it some settle time (100ms) */
+ wait(1.0 / 10.0); // Let things settle down a bit
+
+ max30101_fifo_configuration.all = 0;
+ max30101_fifo_configuration.bit.smp_ave = sample_avg; // Sample averaging;
+ max30101_fifo_configuration.bit.fifo_roll_over_en = 1; // FIFO Roll over enabled
+ max30101_fifo_configuration.bit.fifo_a_full = fifo_waterlevel_mark; // Interrupt when certain level is filled
+ if (i2c_reg_write(REG_FIFO_CFG, max30101_fifo_configuration.all) != 0) {
+ return -1;
+ }
+
+ max30101_spo2_configuration.bit.spo2_adc_rge = 0x2; // ADC Range 8192 fullscale
+ max30101_spo2_configuration.bit.spo2_sr = sample_rate; // 100 Samp/sec.
+ max30101_spo2_configuration.bit.led_pw = pulse_width; // Pulse Width=411us and ADC Resolution=18
+ if (i2c_reg_write(REG_SPO2_CFG, max30101_spo2_configuration.all) != 0) {
+ return -1;
+ }
+
+ max30101_led1_pa = red_led_current; // RED LED current, 0.0
+ if (i2c_reg_write(REG_LED1_PA, max30101_led1_pa) != 0) {
+ return -1;
+ }
+
+ /************/
+
+ if (i2c_reg_read(REG_INT_STAT_1, &status) != 0) // Clear INT1 by reading the status
+ {
+ return -1;
+ }
+
+ if (i2c_reg_read(REG_INT_STAT_2, &status) != 0) // Clear INT2 by reading the status
+ {
+ return -1;
+ }
+
+ if (i2c_reg_write(REG_FIFO_W_PTR, 0x00) != 0) // Clear FIFO ptr
+ {
+ return -1;
+ }
+
+ if (i2c_reg_write(REG_FIFO_OVF_CNT, 0x00) != 0) // Clear FIFO ptr
+ {
+ return -1;
+ }
+
+ if (i2c_reg_write(REG_FIFO_R_PTR, 0x00) != 0) // Clear FIFO ptr
+ {
+ return -1;
+ }
+
+ max30101_Interrupt_Enable_1.all = 0;
+ max30101_Interrupt_Enable_1.bit.a_full_en = 1;
+ // max30101_Interrupt_Enable_1.bit.prox_int_en=0; // Enable Proximity
+ // Interrupt
+ if (i2c_reg_write(REG_INT_EN_1, max30101_Interrupt_Enable_1.all) != 0) {
+ return -1;
+ }
+
+ max30101_mode_configuration.all = 0;
+ max30101_mode_configuration.bit.mode = 0x02; // HR mode
+ if (i2c_reg_write(REG_MODE_CFG, max30101_mode_configuration.all) != 0) {
+ return -1;
+ }
+
+ return 0;
+}
+
+//******************************************************************************
+int MAX30101::HRmode_stop(void) {
+
+ max30101_Interrupt_Enable_1.all = 0;
+ max30101_Interrupt_Enable_1.bit.a_full_en = 0; // Disable FIFO almost full interrupt
+ if (i2c_reg_write(REG_INT_EN_1, max30101_Interrupt_Enable_1.all) != 0) {
+ return -1;
+ }
+
+ max30101_mode_configuration.all = 0;
+ max30101_mode_configuration.bit.mode = 0x00; // HR mode off
+ if (i2c_reg_write(REG_MODE_CFG, max30101_mode_configuration.all) != 0) {
+ return -1;
+ }
+
+ max30101_led1_pa = 0; // RED LED current, 0.0
+ if (i2c_reg_write(REG_LED1_PA, max30101_led1_pa) != 0) {
+ return -1;
+ }
+
+ return 0;
+}
+
+//******************************************************************************
+int MAX30101::Multimode_init(uint8_t fifo_waterlevel_mark, uint8_t sample_avg,
+ uint8_t sample_rate, uint8_t pulse_width,
+ uint8_t red_led_current, uint8_t ir_led_current,
+ uint8_t green_led_current, uint8_t slot_1,
+ uint8_t slot_2, uint8_t slot_3, uint8_t slot_4) {
+ char status;
+ max30101_mode_configuration.all = 0;
+ max30101_mode_configuration.bit.reset = 1;
+ if (i2c_reg_write(REG_MODE_CFG, max30101_mode_configuration.all) != 0) // Reset the device, Mode = don't use...
+ {
+ return -1;
+ }
+
+ /* Give it some settle time (100ms) */ // Let things settle down a bit
+ wait(1.0 / 10.0);
+
+ max30101_fifo_configuration.all = 0;
+ max30101_fifo_configuration.bit.smp_ave = sample_avg; // Sample averaging;
+ max30101_fifo_configuration.bit.fifo_roll_over_en = 1; // FIFO Roll over enabled
+ max30101_fifo_configuration.bit.fifo_a_full =
+ fifo_waterlevel_mark; // Interrupt when certain level is filled
+ if (i2c_reg_write(REG_FIFO_CFG, max30101_fifo_configuration.all) != 0) {
+ return -1;
+ }
+
+ max30101_spo2_configuration.bit.spo2_adc_rge = 0x2; // ADC Range 8192 fullscale
+ max30101_spo2_configuration.bit.spo2_sr = sample_rate; // 100 Samp/sec.
+ max30101_spo2_configuration.bit.led_pw = pulse_width; // Pulse Width=411us and ADC Resolution=18
+ if (i2c_reg_write(REG_SPO2_CFG, max30101_spo2_configuration.all) != 0) {
+ return -1;
+ }
+
+ max30101_led1_pa = red_led_current; // RED LED current
+ if (i2c_reg_write(REG_LED1_PA, max30101_led1_pa) != 0) {
+ return -1;
+ }
+
+ max30101_led2_pa = ir_led_current; // IR LED current
+ if (i2c_reg_write(REG_LED2_PA, max30101_led2_pa) != 0) {
+ return -1;
+ }
+
+ max30101_led3_pa = green_led_current; // Green LED current
+ if (i2c_reg_write(REG_LED3_PA, max30101_led3_pa) != 0) {
+ return -1;
+ }
+
+ // 0x01=Red(LED1), 0x02=IR(LED2), 0x03=Green(LED3) : Use LEDn_PA to adjust the intensity
+ // 0x05=Red , 0x06=IR , 0x07=Green : Use PILOT_PA to adjust the intensity DO NOT USE THIS ROW...
+
+ max30101_multiLED_mode_ctrl_1.bit.slot1 = slot_1;
+ max30101_multiLED_mode_ctrl_1.bit.slot2 = slot_2;
+ if (i2c_reg_write(REG_SLT2_SLT1, max30101_multiLED_mode_ctrl_1.all)) {
+ return -1;
+ }
+
+ max30101_multiLED_mode_ctrl_2.all = 0;
+ max30101_multiLED_mode_ctrl_2.bit.slot3 = slot_3;
+ max30101_multiLED_mode_ctrl_2.bit.slot4 = slot_4;
+ if (i2c_reg_write(REG_SLT4_SLT3, max30101_multiLED_mode_ctrl_2.all)) {
+ return -1;
+ }
+
+ /************/
+
+ if (i2c_reg_read(REG_INT_STAT_1, &status) != 0) // Clear INT1 by reading the status
+ {
+ return -1;
+ }
+
+ if (i2c_reg_read(REG_INT_STAT_2, &status) != 0) // Clear INT2 by reading the status
+ {
+ return -1;
+ }
+
+ if (i2c_reg_write(REG_FIFO_W_PTR, 0x00) != 0) // Clear FIFO ptr
+ {
+ return -1;
+ }
+
+ if (i2c_reg_write(REG_FIFO_OVF_CNT, 0x00) != 0) // Clear FIFO ptr
+ {
+ return -1;
+ }
+
+ if (i2c_reg_write(REG_FIFO_R_PTR, 0x00) != 0) // Clear FIFO ptr
+ {
+ return -1;
+ }
+
+ max30101_Interrupt_Enable_1.all = 0;
+ max30101_Interrupt_Enable_1.bit.a_full_en = 1; // Enable FIFO almost full interrupt
+ if (i2c_reg_write(REG_INT_EN_1, max30101_Interrupt_Enable_1.all) != 0) {
+ return -1;
+ }
+
+ max30101_mode_configuration.all = 0;
+ max30101_mode_configuration.bit.mode = 0x07; // Multi-LED mode
+ if (i2c_reg_write(REG_MODE_CFG, max30101_mode_configuration.all) != 0) {
+ return -1;
+ }
+
+ return 0;
+}
+
+//******************************************************************************
+int MAX30101::Multimode_stop(void) {
+
+ max30101_Interrupt_Enable_1.all = 0;
+ max30101_Interrupt_Enable_1.bit.a_full_en = 0; // Disable FIFO almost full interrupt
+ if (i2c_reg_write(REG_INT_EN_1, max30101_Interrupt_Enable_1.all) != 0) {
+ return -1;
+ }
+
+ max30101_mode_configuration.all = 0;
+ max30101_mode_configuration.bit.mode = 0x00; // Multi-LED mode off
+ if (i2c_reg_write(REG_MODE_CFG, max30101_mode_configuration.all) != 0) {
+ return -1;
+ }
+
+ max30101_led1_pa = 0; // RED LED current, 0.0
+ if (i2c_reg_write(REG_LED1_PA, max30101_led1_pa) != 0) {
+ return -1;
+ }
+
+ max30101_led2_pa = 0; // IR LED current, 0.0
+ if (i2c_reg_write(REG_LED2_PA, max30101_led2_pa) != 0) {
+ return -1;
+ }
+
+ max30101_led3_pa = 0; // Green LED current, 0.0
+ if (i2c_reg_write(REG_LED3_PA, max30101_led3_pa) != 0) {
+ return -1;
+ }
+ return 0;
+}
+
+//******************************************************************************
+int MAX30101::tempread(void) {
+ max30101_Interrupt_Enable_2.all = 0;
+ max30101_Interrupt_Enable_2.bit.die_temp_rdy_en = 1; // Enable the Temp Rdy;
+ if (i2c_reg_write(REG_INT_EN_2, 0x02) != 0) // Interrupt Enable 2, Temperature Interrupt
+ {
+ return -1;
+ }
+
+ if (i2c_reg_write(REG_TEMP_EN, 0x01) != 0) // Die Temperature Config, Temp enable...
+ {
+ return -1;
+ }
+ return 0;
+}
+
+//******************************************************************************
+int MAX30101::i2c_reg_write(MAX30101_REG_map_t reg, char value) {
+ char cmdData[2] = {reg, value};
+
+ if (I2CM_Write(slaveAddress, NULL, 0, cmdData, 2) != 0 /*2*/) {
+ return -1;
+ }
+
+ return 0;
+}
+
+//******************************************************************************
+int MAX30101::i2c_reg_read(MAX30101_REG_map_t reg, char *value) {
+ if (I2CM_Read(slaveAddress, (char *)®, 1, value, 1) != 0 /*1*/) {
+ return -1;
+ }
+
+ return 0;
+}
+
+/**
+* @brief Read from an I2C device
+* @param slaveAddress slave address to use with transaction
+* @param writeData pointer of data to write
+* @param writeCount number of data to write
+* @param readData pointer to buffer to read to
+* @param readCount number of bytes to read
+*/
+int MAX30101::I2CM_Read(int slaveAddress, char *writeData, char writeCount,
+ char *readData, char readCount) {
+ if (writeData != NULL && writeCount != 0) {
+ i2c->write(slaveAddress, writeData, writeCount, true);
+ }
+ if (readData != NULL && readCount != 0) {
+ i2c->read(slaveAddress, readData, readCount);
+ }
+ return 0;
+}
+
+/**
+* @brief Write to an I2C device
+* @param slaveAddress slave address to use with transaction
+* @param writeData pointer of data to write
+* @param writeCount1 number of data to write
+* @param writeData2 pointer to buffer to read to
+* @param writeCount2 number of bytes to read
+*/
+int MAX30101::I2CM_Write(int slaveAddress, char *writeData1, char writeCount1,
+ char *writeData2, char writeCount2) {
+ if (writeData1 != NULL && writeCount1 != 0) {
+ i2c->write(slaveAddress, writeData1, writeCount1);
+ }
+ if (writeData2 != NULL && writeCount2 != 0) {
+ i2c->write(slaveAddress, writeData2, writeCount2);
+ }
+ return 0;
+}
+
+//******************************************************************************
+void MAX30101::onDataAvailable(DataCallbackFunction _onDataAvailable) {
+ onDataAvailableCallback = _onDataAvailable;
+}
+
+/**
+* @brief Used to notify an external function that interrupt data is available
+* @param id type of data available
+* @param buffer 32-bit buffer that points to the data
+* @param length length of 32-bit elements available
+*/
+void MAX30101::dataAvailable(uint32_t id, uint32_t *buffer, uint32_t length) {
+ if (onDataAvailableCallback != NULL) {
+ (*onDataAvailableCallback)(id, buffer, length);
+ }
+}
+
+//******************************************************************************
+void MAX30101::onInterrupt(InterruptFunction _onInterrupt) {
+ onInterruptCallback = _onInterrupt;
+}
+
+/**
+* @brief Executed on interrupt
+* @param id type of data available
+* @param buffer 32-bit buffer that points to the data
+* @param length length of 32-bit elements available
+*/
+void MAX30101::interruptPostCallback(void) {
+ if (onInterruptCallback != NULL) {
+ (*onInterruptCallback)();
+ }
+}
+
+int max30101_enableInterrupts = 0;
+/**************************************************************************************************************/
+void MAX30101MidIntHandler(void) {
+ MAX30101::instance->int_handler();
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/Devices/MAX30101/MAX30101/MAX30101.h Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,454 @@
+/*******************************************************************************
+/ * Copyright (C) 2015 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************/
+/*
+ * max30101.h
+ *
+ * Created on: Aug 26, 2015
+ * Author: faisal.tariq
+ */
+
+#ifndef _MAX30101_H_
+#define _MAX30101_H_
+
+#include "mbed.h"
+
+#define MAX30101_RAW_DATA_SIZE 3 * 4 * 32
+#define MAX30101_PROC_DATA_SIZE 4 * 32
+
+#define MAX30101_OXIMETER_DATA 0x10
+
+#define CHUNK_SIZE 252
+
+// MAX30101 Register addresses
+
+#define MAX30101_INT_PORT 4
+#define MAX30101_INT_PIN 0
+#define MAX30101_MASTER_NUM 2
+
+/**
+* Maxim Integrated MAX30101 Oximeter chip
+*/
+class MAX30101 {
+public:
+ float max30101_final_temp; // Global declaration
+ uint32_t max30101_buffer[MAX30101_PROC_DATA_SIZE]; // final Processed data
+ char max30101_rawData[MAX30101_RAW_DATA_SIZE]; // raw data from the chip
+
+ typedef enum { // MAX30101 Register addresses
+
+ /*Status */
+ REG_INT_STAT_1 = 0x00,
+ REG_INT_STAT_2 = 0x01,
+ REG_INT_EN_1 = 0x02,
+ REG_INT_EN_2 = 0x03,
+
+ REG_FIFO_W_PTR = 0x04,
+ REG_FIFO_OVF_CNT = 0x05,
+ REG_FIFO_R_PTR = 0x06,
+ REG_FIFO_DATA = 0x07,
+ /* Configuration */
+ REG_FIFO_CFG = 0x08,
+ REG_MODE_CFG = 0x09,
+ REG_SPO2_CFG = 0x0A,
+ REG_LED1_PA = 0x0C,
+ REG_LED2_PA = 0x0D,
+ REG_LED3_PA = 0x0E,
+ REG_PILOT_PA = 0x10,
+ REG_SLT2_SLT1 = 0x11,
+ REG_SLT4_SLT3 = 0x12,
+ /* Die Temp */
+ REG_TINT = 0x1F,
+ REG_TFRAC = 0x20,
+ REG_TEMP_EN = 0x21,
+ /* Proximity Func */
+ REG_PROX_INT_THR = 0x30,
+ /* Part ID */
+ REG_REV_ID = 0xFE,
+ REG_ID = 0xFF,
+ } MAX30101_REG_map_t;
+
+ /**********/
+ /* STATUS */
+ /**********/
+ /// @brief STATUS1 (0x00)
+ union max30101_Interrupt_Status_1_reg {
+ char all;
+ struct {
+ char pwr_rdy : 1;
+ char reserved : 3;
+ char prox_int : 1;
+ char alc_ovf : 1;
+ char ppg_rdy : 1;
+ char a_full : 1;
+ } bit;
+ } max30101_Interrupt_Status_1;
+
+ /// @brief STATUS2 (0x01)
+ union max30101_Interrupt_Status_2_reg {
+ char all;
+ struct {
+ char reserved1 : 1;
+ char die_temp_rdy : 1;
+ char reserved2 : 6;
+ } bit;
+ } max30101_Interrupt_Status_2;
+
+ /// @brief INTERRUPT_ENABLE1 (0x02)
+ volatile union max30101_Interrupt_Enable_1_reg {
+ uint8_t all;
+ struct {
+ uint8_t reserved1 : 4;
+ uint8_t prox_int_en : 1;
+ uint8_t alc_ovf_en : 1;
+ uint8_t ppg_rdy_en : 1;
+ uint8_t a_full_en : 1;
+ } bit;
+ } max30101_Interrupt_Enable_1;
+
+ /// @brief INTERRUPT_ENABLE2 (0x03)
+ volatile union max30101_Interrupt_Enable_2_reg {
+ uint8_t all;
+ struct {
+ uint8_t reserved1 : 1;
+ uint8_t die_temp_rdy_en : 1;
+ uint8_t reserved2 : 6;
+ } bit;
+ } max30101_Interrupt_Enable_2;
+
+ /*********/
+ /* FIFO */
+ /*********/
+ // 0x04
+ /// @brief FIFO_WR_PTR (0x04)
+ volatile union max30101_fifo_wr_ptr_reg {
+ uint8_t all;
+ struct {
+ uint8_t fifo_wr_ptr : 5;
+ uint8_t reserved1 : 3;
+ } bit;
+ } max30101_fifo_wr_ptr;
+
+ /// @brief OVF_COUNTER (0x05)
+ volatile union max30101_ovf_counter_reg {
+ uint8_t all;
+ struct {
+ uint8_t fifo_ovf_counter : 5;
+ uint8_t reserved1 : 3;
+ } bit;
+ } max30101_ovf_counter_reg;
+
+ /// @brief FIFO_READ_PTR (0x06)
+ volatile union max30101_fifo_rd_ptr_reg {
+ uint8_t all;
+ struct {
+ uint8_t fifo_rd_ptr : 5;
+ uint8_t reserved1 : 3;
+ } bit;
+ } max30101_fifo_rd_ptr;
+
+ // 0x07
+ uint8_t max30101_fifo_data;
+
+ /********************/
+ /* Configuration */
+ /********************/
+ // 0x08
+ /// @brief FIFO_CONFIGURATION (0x08)
+ volatile union max30101_fifo_configuration_reg {
+ uint8_t all;
+ struct {
+ uint8_t fifo_a_full : 4;
+ uint8_t fifo_roll_over_en : 1;
+ uint8_t smp_ave : 3;
+ } bit;
+ } max30101_fifo_configuration;
+
+ /// @brief MODE_CONFIGURATION (0x09)
+ volatile union max30101_mode_configuration_reg {
+ uint8_t all;
+ struct {
+ uint8_t mode : 3;
+ uint8_t reserved1 : 3;
+ uint8_t reset : 1;
+ uint8_t shdn : 1;
+ } bit;
+ } max30101_mode_configuration;
+
+ /// @brief SPO2_CONGIGURATION (0x0A)
+ volatile union max30101_spo2_configuration_reg {
+ uint8_t all;
+ struct {
+ uint8_t led_pw : 2;
+ uint8_t spo2_sr : 3;
+ uint8_t spo2_adc_rge : 2;
+ uint8_t reserved1 : 1;
+ } bit;
+ } max30101_spo2_configuration;
+
+ /// @brief LED1_PA (0x0C)
+ uint8_t max30101_led1_pa;
+
+ /// @brief LED2_PA (0x0D)
+ uint8_t max30101_led2_pa;
+
+ /// @brief LED3_PA (0x0E)
+ uint8_t max30101_led3_pa;
+
+ /// @brief PILOT_PA (0x10)
+ uint8_t max30101_pilot_pa;
+
+ volatile union max30101_multiLED_mode_ctrl_1_reg {
+ uint8_t all;
+ struct {
+ uint8_t slot1 : 3;
+ uint8_t reserved : 1;
+ uint8_t slot2 : 3;
+ uint8_t reserved1 : 1;
+ } bit;
+ } max30101_multiLED_mode_ctrl_1;
+
+ volatile union max30101_multiLED_mode_ctrl_2_reg {
+ uint8_t all;
+ struct {
+ uint8_t slot3 : 3;
+ uint8_t reserved : 1;
+ uint8_t slot4 : 3;
+ uint8_t reserved1 : 1;
+ } bit;
+ } max30101_multiLED_mode_ctrl_2;
+
+ /********************/
+ /* Die Temperature */
+ /********************/
+
+ uint8_t max30101_tinit;
+
+ uint8_t max30101_tfrac;
+
+ volatile union max30101_die_temp_config {
+ uint8_t all;
+ struct {
+ uint8_t temp_en : 1;
+ uint8_t reserved : 7;
+ } bit;
+ } max30101_die_temp_config;
+ /*******************************/
+ /***** Function Prototypes *****/
+ /*******************************/
+
+ uint8_t max30101_prox_int_thresh;
+
+ /**
+ * MAX30101 constructor.
+ *
+ * @param sda mbed pin to use for SDA line of I2C interface.
+ * @param scl mbed pin to use for SCL line of I2C interface.
+ */
+ MAX30101(PinName sda, PinName scl, int slaveAddress);
+
+ /**
+ * MAX30101 constructor.
+ *
+ * @param i2c I2C object to use.
+ */
+ MAX30101(I2C *i2c, int slaveAddress);
+
+ /**
+ * MAX30101 destructor.
+ */
+ ~MAX30101(void);
+
+ /**
+ * @brief Allows reading from MAX30101 register
+ * @param reg: is the register address, to read from (look at max30101.h and the
+ * data sheet for details)
+ * @param value: is the pointer to the value read from the register
+ * @returns 0-if no error. A non-zero value indicates an error.
+ */
+ int i2c_reg_read(MAX30101_REG_map_t reg, char *value);
+
+ /**
+ * @brief Allows writing to MAX30101 register
+ * @param reg: is the register address, to read from (look at max30101.h and
+ * the
+ * data sheet for details)
+ * @param value: is the value to write to the register
+ * @returns 0-if if no error. A non-zero value indicates an error.
+ */
+ int i2c_reg_write(MAX30101_REG_map_t reg, char value);
+
+ /**
+ * @brief This function sets up for the SpO2 mode. The data is returned in
+ * the callback function
+ * @brief max30101_int_handler in global array: buffer[]. SP mode handles two LED (Red,IR) data. Hence it
+ * @brief can fill up the FIFO up to a maximum of 3bytes/sample x 32 x 2 = 192bytes.
+ * @param fifo_waterlevel_mark: corresponds to FIFO_A_FULL, In FIFO Configuration Register (0x08)
+ * @param sample_avg: corresponds to SMP_AVE, in FIFO Configuration Register (0x08)
+ * @param sample_rate: corresponds to SPO2_SR, IN SpO2 Configuration Register (0x0A)
+ * @param pulse_width: corresponds to LED_PW in SpO2 Configuration register(0x0A)
+ * @param red_led_current: corresponds to LED1_PA register (0x0C). Please see data sheet for values
+ * @param ir_led_current: corresponds to LED2_PA register (0x0D). Please see data sheet for values
+ * @returns 0-if everything is good. A non-zero value indicates an error.
+ */
+ int SpO2mode_init(uint8_t fifo_waterlevel_mark, uint8_t sample_avg,
+ uint8_t sample_rate, uint8_t pulse_width,
+ uint8_t red_led_current, uint8_t ir_led_current);
+
+ /**
+ * @brief This function will stop the SpO2 mode and turn off all operating LEDâs.
+ * @return 0-if if no error. A non-zero value indicates an error.
+ */
+ int SpO2mode_stop(void);
+
+ /**
+ * @brief This function sets up for the HR mode. The data is returned in thecallback function
+ * @brief max30101_int_handler in global array: buffer[].HR mode handles one LED (Red) data. Hence it can fill
+ * @brief up the FIFO up to a maximum of 3bytes/sample x 32 = 96bytes.
+ * @brief fifo_waterlevel_mark: corresponds to FIFO_A_FULL, In FIFO Configuration Register (0x08)
+ * @param sample_avg: corresponds to SMP_AVE, in FIFO Configuration Register (0x08)
+ * @param sample_rate:corresponds to SPO2_SR, IN SpO2 Configuration Register (0x0A)
+ * @param pulse_width: corresponds to LED_PW in SpO2 Configuration Register(0x0A)
+ * @param red_led_current: corresponds to LED1_PA register (0x0C). Please see data sheet for values
+ * @returns 0-if if no error. A non-zero value indicates an error.
+ */
+ int HRmode_init(uint8_t fifo_waterlevel_mark, uint8_t sample_avg,
+ uint8_t sample_rate, uint8_t pulse_width,
+ uint8_t red_led_current);
+
+ /**
+ * @brief This function will stop the HR mode and turn off all operating
+ * LEDâs.
+ * @return 0-if if no error. A non-zero value indicates an error.
+ */
+ int HRmode_stop(void);
+
+ /**
+ *@brief This function sets up for the Multi-mode. The data is returned in the callback function max30101_int_handler in global array:
+ *@brief buffer[]. Multi-LED mode can handle 1 to 4 LED combinations. Hence it can fill up the FIFO up to a maximum of
+ *@brief 3bytes/sample x 32 x 4 = 384bytes.
+ *@param fifo_waterlevel_mark: corresponds to FIFO_A_FULL, In FIFO Configuration Register (0x08)
+ *@param sample_avg: corresponds to SMP_AVE, in FIFO Configuration Register (0x08)
+ *@param sample_rate:corresponds to SPO2_SR, IN SpO2 Configuration Register (0x0A)
+ *@param pulse_width: corresponds to LED_PW in SpO2 Configuration register(0x0A)
+ *@param red_led_current: corresponds to LED1_PA register (0x0C). Please see data sheet for values
+ *@param ir_led_current: corresponds to LED2_PA register (0x0D). Please see data sheet for values
+ *@param green_led_current: corresponds to LED3_PA register (0x0E). Please see data sheet for values
+ *@param slot_1,â¦,slot_4: corresponds to Multi-LED Mode control Registers (0x11-0x12).
+ *@returns 0-if if no error. A non-zero value indicates an error.
+ */
+ int Multimode_init(uint8_t fifo_waterlevel_mark, uint8_t sample_avg,
+ uint8_t sample_rate, uint8_t pulse_width,
+ uint8_t red_led_current, uint8_t ir_led_current,
+ uint8_t green_led_current, uint8_t slot_1, uint8_t slot_2,
+ uint8_t slot_3, uint8_t slot_4);
+
+ /**
+ * @brief This function will stop the Multi-mode and turn off all operating LEDâs.
+ * @returns 0-if if no error. A non-zero value indicates an error.
+ */
+ int Multimode_stop(void);
+
+ /**
+ * @brief This is a function that sets up for temperature read and should be called after one of the mode
+ * @brief has been setup. The data is returned in the callback function max30101_int_handler. This
+ * @brief function needs to be called every time temperature reading is required.
+ * @brief Call the temp function after one of the MODES have been started
+ * @brief Note that the temp is disabled after one read... also, it is not necessary
+ * @brief to read the temp frequently...
+ * @returns 0-if if no error. A non-zero value indicates an error.
+ */
+ int tempread(void);
+
+ /**
+ *@brief This is a callback function which collects the data from the FIFO of the MAX30101 in a 32-bit
+ *@brief unsigned global array called max30101_buffer[]. Upon every interrupt from the MAX30101, this
+ *@brief function is called to service the FIFO of the MAX30101. This callback function also services the
+ *@brief interrupt for the temp data. The temp data is collected in a floating point global variable
+ *@brief final_temp.
+ *@param max30101_buffer[], global uint32_t
+ *@returns 0-if everything is good. A non-zero value indicates an error.
+ */
+ int int_handler(void);
+ /**
+ * @brief type definition for data interrupt
+ */
+ typedef void (*DataCallbackFunction)(uint32_t id, uint32_t *buffer,
+ uint32_t length);
+ /**
+ * @brief type definition for general interrupt
+ */
+ typedef void (*InterruptFunction)();
+
+ /**
+ * @brief Used to connect a callback for when interrupt data is available
+ */
+ void onInterrupt(InterruptFunction _onInterrupt);
+
+ /**
+ * @brief Used to connect a callback for when interrupt data is available
+ */
+ void onDataAvailable(DataCallbackFunction _onDataAvailable);
+
+ static MAX30101 *instance;
+
+private:
+ /// called when interrupt data is available
+ void dataAvailable(uint32_t id, uint32_t *buffer, uint32_t length);
+ /// callback function at the end of the interrupt
+ void interruptPostCallback(void);
+ /// callback function when interrupt data is available
+ DataCallbackFunction onDataAvailableCallback;
+ /// callback function when interrupt data is available
+ InterruptFunction onInterruptCallback;
+ /// Read I2c wrapper method
+ int I2CM_Read(int slaveAddress, char *writeData, char writeCount, char *readData, char readCount);
+ /// Write I2c wrapper method
+ int I2CM_Write(int slaveAddress, char *writeData1, char writeCount1, char *writeData2, char writeCount2);
+ /// pointer to I2C object
+ I2C *i2c;
+ /// flag to track if this object is the owner (created) the I2C object
+ bool i2c_owner;
+ /// Device slave address
+ int slaveAddress;
+};
+
+/**
+* @brief Resets the I2C block, when needed
+*/
+extern void I2CM_Init_Reset(uint8_t index, int speed);
+
+ /**
+ * @brief Used for debugging, if needed
+ */
+void MAX30101MidIntHandler(void);
+
+#endif /* _MAX30101_H_ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/Devices/MAX30101/MAX30101_RPC.cpp Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,272 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+#include "MAX30101_RPC.h"
+#include "StringHelper.h"
+#include "MAX30101.h"
+#include "Streaming.h"
+#include "RpcFifo.h"
+#include "RpcServer.h"
+#include "StringInOut.h"
+#include "MAX30101_helper.h"
+#include "LIS2DH.h"
+#include "Peripherals.h"
+#include "DataLoggingService.h"
+
+//******************************************************************************
+int MAX30101_WriteReg(char argStrs[32][32], char replyStrs[32][32]) {
+ uint8_t args[2];
+ uint8_t reply[1];
+ ProcessArgs(argStrs, args, sizeof(args));
+// Peripherals::max30101()->writeReg(args[0] , args[1]); // pass in the register address and the data
+ reply[0] = 0x80;
+ FormatReply(reply, sizeof(reply), replyStrs);
+ return 0;
+}
+
+//******************************************************************************
+int MAX30101_ReadReg(char argStrs[32][32], char replyStrs[32][32]) {
+ uint8_t args[1];
+ uint8_t reply[1];
+ char value;
+ ProcessArgs(argStrs, args, sizeof(args));
+// Peripherals::max30101()->readReg(args[0] , &value, 1);
+ reply[0] = (uint8_t)value;
+ FormatReply(reply, sizeof(reply), replyStrs);
+ return 0;
+}
+
+//******************************************************************************
+int MAX30101_COMMinit(char argStrs[32][32], char replyStrs[32][32])
+{
+ uint8_t args[4];
+ uint8_t return_value;
+ ProcessArgs(argStrs,args,sizeof(args));
+
+ //return_value = max30101_COMMinit(args[0], args[1], args[2], args[3]);
+
+ strcpy(replyStrs[0],"80");
+ return return_value;
+}
+
+//******************************************************************************
+int MAX30101_SpO2mode_stop(char argStrs[32][32], char replyStrs[32][32])
+{
+ uint8_t args[4];
+ uint8_t return_value;
+ ProcessArgs(argStrs,args,sizeof(args));
+
+ //lis2dh_Stop();
+ //max30101_SpO2mode_stop();
+ Peripherals::max30101()->SpO2mode_stop();
+
+ strcpy(replyStrs[0],"80");
+ return return_value;
+}
+
+//******************************************************************************
+int MAX30101_HRmode_stop(char argStrs[32][32], char replyStrs[32][32])
+{
+ uint8_t args[4];
+ ProcessArgs(argStrs,args,sizeof(args));
+
+ //lis2dh_Stop();
+ Peripherals::max30101()->HRmode_stop();
+
+ strcpy(replyStrs[0],"80");
+ return 0;
+}
+
+//******************************************************************************
+int MAX30101_Multimode_stop(char argStrs[32][32], char replyStrs[32][32])
+{
+ uint8_t args[4];
+ ProcessArgs(argStrs,args,sizeof(args));
+
+ //lis2dh_Stop();
+ Peripherals::max30101()->Multimode_stop();
+
+ strcpy(replyStrs[0],"80");
+ return 0;
+}
+
+//******************************************************************************
+void ClearInOutFifos() {
+ fifo_clear(GetStreamOutFifo()); // clear stream out fifo
+ fifo_clear(GetUSBIncomingFifo()); // clear USB serial incoming fifo
+}
+
+int highDataRate = 0;
+#define MAX30101_200HZ 2
+#define MAX30101_400HZ 3
+
+/**
+* Adjust the threshold of the Accel based on the data rate
+* @lis2dhDataRate Data rate of the accel to determine what would be a good threshold value
+*/
+static int adjustAccelThreshold(int lis2dhDataRate) {
+ int lis2dhFifoThreshold;
+ lis2dhFifoThreshold = 31;
+ if (lis2dhDataRate <= LIS2DH_DATARATE_50HZ) lis2dhFifoThreshold = 4;
+ if (lis2dhDataRate == LIS2DH_DATARATE_100HZ) lis2dhFifoThreshold = 8;
+ return lis2dhFifoThreshold;
+}
+
+/**
+* Evaluate the data rate of the Accel to see if we should stream using a high data rate mode
+* @lis2dhDataRate Data rate of the accel to determine if this is a high data rate
+*/
+static void adjustHighDataRate(int lis2dhDataRate) {
+ highDataRate = 0;
+ if (lis2dhDataRate >= LIS2DH_DATARATE_200HZ) highDataRate = 1;
+}
+
+//******************************************************************************
+int MAX30101_SpO2mode_init(char argStrs[32][32], char replyStrs[32][32])
+{
+ uint8_t args[7];
+ uint8_t lis2dhDataRate;
+ uint8_t lis2dhFifoThreshold;
+ ProcessArgs(argStrs, args, sizeof(args));
+
+ ClearInOutFifos();
+ MAX30101_Helper_SetStreamingFlag(eStreaming_SPO2,1);
+ Peripherals::max30101()->SpO2mode_init(args[0], args[1], args[2], args[3], args[4], args[5]);
+
+ lis2dhDataRate = args[6];
+ lis2dhFifoThreshold = adjustAccelThreshold(lis2dhDataRate);
+ adjustHighDataRate(lis2dhDataRate);
+
+ Peripherals::lis2dh()->initStart(lis2dhDataRate,lis2dhFifoThreshold);
+ LoggingService_StartLoggingUsb();
+
+ strcpy(replyStrs[0],"80");
+ return 0;
+}
+
+//******************************************************************************
+int MAX30101_SpO2mode_InitStart(char argStrs[32][32], char replyStrs[32][32])
+{
+ uint8_t args[6]; // Size
+ ProcessArgs(argStrs, args, sizeof(args));
+
+ ClearInOutFifos();
+ MAX30101_Helper_SetStreamingFlag(eStreaming_SPO2,1);
+ if (args[2] >= MAX30101_200HZ) highDataRate = 1;
+ Peripherals::max30101()->SpO2mode_init(args[0], args[1], args[2], args[3], args[4], args[5]);
+
+ strcpy(replyStrs[0],"80");
+ return 0;
+}
+
+//******************************************************************************
+int MAX30101_HRmode_init(char argStrs[32][32], char replyStrs[32][32])
+{
+ uint8_t args[6];
+ uint8_t lis2dhDataRate;
+ uint8_t lis2dhFifoThreshold;
+ ProcessArgs(argStrs, args, sizeof(args));
+
+ ClearInOutFifos();
+ MAX30101_Helper_SetStreamingFlag(eStreaming_HR,1);
+ Peripherals::max30101()->HRmode_init(args[0], args[1], args[2], args[3], args[4]);
+
+ lis2dhDataRate = args[5];
+ lis2dhFifoThreshold = adjustAccelThreshold(lis2dhDataRate);
+ adjustHighDataRate(lis2dhDataRate);
+
+ Peripherals::lis2dh()->initStart(lis2dhDataRate,lis2dhFifoThreshold);
+ LoggingService_StartLoggingUsb();
+ strcpy(replyStrs[0],"80");
+ return 0;
+}
+
+//******************************************************************************
+int MAX30101_HRmode_InitStart(char argStrs[32][32], char replyStrs[32][32])
+{
+ uint8_t args[5];
+ ProcessArgs(argStrs, args, sizeof(args));
+
+ ClearInOutFifos();
+ MAX30101_Helper_SetStreamingFlag(eStreaming_HR,1);
+ if (args[2] >= MAX30101_200HZ) highDataRate = 1;
+ Peripherals::max30101()->HRmode_init(args[0], args[1], args[2], args[3], args[4]);
+ strcpy(replyStrs[0],"80");
+ return 0;
+}
+
+//******************************************************************************
+int MAX30101_Multimode_init(char argStrs[32][32], char replyStrs[32][32])
+{
+ uint8_t args[12];
+ uint8_t lis2dhDataRate;
+ uint8_t lis2dhFifoThreshold;
+ ProcessArgs(argStrs, args, sizeof(args));
+
+ ClearInOutFifos();
+
+ lis2dhDataRate = args[11];
+ lis2dhFifoThreshold = adjustAccelThreshold(lis2dhDataRate);
+ adjustHighDataRate(lis2dhDataRate);
+
+ Peripherals::lis2dh()->initStart(lis2dhDataRate,lis2dhFifoThreshold);
+
+ wait(0.1f);
+ MAX30101_Helper_SetStreamingFlag(eStreaming_MULTI, 1);
+ Peripherals::max30101()->Multimode_init(args[0], args[1], args[2],
+ args[3], args[4], args[5], args[6],
+ args[7], args[8], args[9], args[10]);
+ LoggingService_StartLoggingUsb();
+
+ strcpy(replyStrs[0],"80");
+ return 0;
+}
+
+//******************************************************************************
+int MAX30101_Multimode_InitStart(char argStrs[32][32], char replyStrs[32][32])
+{
+ uint8_t args[11];
+ ProcessArgs(argStrs, args, sizeof(args));
+
+ ClearInOutFifos();
+ MAX30101_Helper_SetStreamingFlag(eStreaming_MULTI, 1);
+ if (args[2] >= MAX30101_200HZ) highDataRate = 1;
+ Peripherals::max30101()->Multimode_init(args[0], args[1], args[2],
+ args[3], args[4], args[5], args[6],
+ args[7], args[8], args[9], args[10]);
+
+ strcpy(replyStrs[0],"80");
+ return 0;
+}
+
+
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/HSP/Devices/MAX30101/MAX30101_RPC.h Tue Oct 25 15:22:11 2016 +0000 @@ -0,0 +1,51 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ +#ifndef _MAX30101_RPC_H_ +#define _MAX30101_RPC_H_ + +int MAX30101_WriteReg(char argStrs[32][32], char replyStrs[32][32]); +int MAX30101_ReadReg(char argStrs[32][32], char replyStrs[32][32]); +int MAX30101_StreamTest(char argStrs[32][32], char replyStrs[32][32]); +int MAX30101_COMMinit(char argStrs[32][32], char replyStrs[32][32]); +int MAX30101_SpO2mode_init(char argStrs[32][32], char replyStrs[32][32]); +int MAX30101_SpO2mode_InitStart(char argStrs[32][32], char replyStrs[32][32]); +int MAX30101_HRmode_init(char argStrs[32][32], char replyStrs[32][32]); +int MAX30101_HRmode_InitStart(char argStrs[32][32], char replyStrs[32][32]); +int MAX30101_Multimode_init(char argStrs[32][32], char replyStrs[32][32]); +int MAX30101_Multimode_InitStart(char argStrs[32][32], char replyStrs[32][32]); + +int MAX30101_SpO2mode_stop(char argStrs[32][32], char replyStrs[32][32]); +int MAX30101_HRmode_stop(char argStrs[32][32], char replyStrs[32][32]); +int MAX30101_Multimode_stop(char argStrs[32][32], char replyStrs[32][32]); + +#endif /* _MAX30101_RPC_H_ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/Devices/MAX30101/MAX30101_helper.cpp Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,74 @@
+
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+
+#include <stdint.h>
+#include "MAX30101_helper.h"
+#include "MAX30101.h"
+#include "Peripherals.h"
+
+// int8_t max30101_SpO2mode_stop(void);
+// int8_t max30101_HRmode_stop(void);
+// int8_t max30101_Multimode_stop(void);
+
+static uint8_t flags[3];
+
+uint8_t MAX30101_Helper_IsStreaming(eMAX30101Flags flag) {
+ return flags[(uint32_t)flag];
+}
+
+void MAX30101_Helper_SetStreamingFlag(eMAX30101Flags flag, uint8_t state) {
+ flags[(uint32_t)flag] = state;
+}
+
+void MAX30101_Helper_Stop(void) {
+ if (flags[(uint32_t)eStreaming_HR] == 1) {
+ Peripherals::max30101()->HRmode_stop();
+ }
+ if (flags[(uint32_t)eStreaming_SPO2] == 1) {
+ Peripherals::max30101()->SpO2mode_stop();
+ }
+ if (flags[(uint32_t)eStreaming_MULTI] == 1) {
+ Peripherals::max30101()->Multimode_stop();
+ }
+ MAX30101_Helper_ClearStreamingFlags();
+}
+
+void MAX30101_Helper_ClearStreamingFlags(void) {
+ uint32_t i;
+ for (i = 0; i < 3; i++) {
+ flags[i] = 0;
+ }
+}
+
+void MAX30101_OnInterrupt(void) { I2CM_Init_Reset(2, 1); }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/Devices/MAX30101/MAX30101_helper.h Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,48 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+#ifndef MAX30101_HELPER_H_
+#define MAX30101_HELPER_H_
+
+typedef enum eMAX30101Flags {
+ eStreaming_HR,
+ eStreaming_SPO2,
+ eStreaming_MULTI
+} eMAX30101Flags;
+
+uint8_t MAX30101_Helper_IsStreaming(eMAX30101Flags flag);
+void MAX30101_Helper_SetStreamingFlag(eMAX30101Flags flag, uint8_t state);
+void MAX30101_Helper_Stop(void);
+void MAX30101_Helper_ClearStreamingFlags(void);
+void MAX30101_OnInterrupt(void);
+
+#endif /* MAX30101_HELPER_H_ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/Devices/MAX30205/MAX30205/MAX30205.cpp Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,134 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+#include "MAX30205.h"
+
+//******************************************************************************
+MAX30205::MAX30205(PinName sda, PinName scl, int slaveAddress) :
+ slaveAddress(slaveAddress) {
+ i2c = new I2C(sda, scl);
+ isOwner = true;
+ i2c->frequency(100000);
+}
+
+//******************************************************************************
+MAX30205::MAX30205(I2C *i2c, int slaveAddress) : slaveAddress(slaveAddress) {
+ this->i2c = i2c;
+ i2c->frequency(100000);
+ isOwner = false;
+}
+
+//******************************************************************************
+MAX30205::~MAX30205(void) {
+ if (isOwner == true) {
+ delete i2c;
+ }
+}
+
+//******************************************************************************
+int MAX30205::reg_write(char reg, char value) {
+ int result;
+ char cmdData[2] = {(char)reg, value};
+ result = i2c->write(slaveAddress, cmdData, 2);
+ if (result != 0) return -1;
+ return 0;
+}
+
+//******************************************************************************
+int MAX30205::reg_write16(char reg, uint16_t value) {
+ int result;
+ char hi = (value >> 8) & 0xFF;
+ char lo = value & 0xFF;
+ char cmdData[3] = {reg, hi, lo};
+ result = i2c->write(slaveAddress, cmdData, 3);
+ if (result != 0) return -1;
+ return 0;
+}
+
+//******************************************************************************
+int MAX30205::reg_read(char reg, char *value) {
+ int result;
+ char cmdData[1] = {reg};
+
+ result = i2c->write(slaveAddress, cmdData, 1);
+ if (result != 0) return -1;
+ result = i2c->read(slaveAddress, value, 1);
+ if (result != 0) return -1;
+ return 0;
+}
+
+//******************************************************************************
+int MAX30205::reg_read16(char reg, uint16_t *value) {
+ int result;
+ char data[2];
+ char cmdData[1] = {reg};
+ result = i2c->write(slaveAddress, cmdData, 1);
+ if (result != 0) return -1;
+ result = i2c->read(slaveAddress, data, 2);
+ if (result != 0) return -1;
+ *value = (data[0] << 8) + data[1];
+ return 0;
+}
+
+//******************************************************************************
+int MAX30205::readTemperature(uint16_t *value) {
+ uint8_t data[2];
+ int status;
+ status = reg_read16(MAX30205_Temperature, (uint16_t *)&data);
+ *value = (data[0] << 8) + data[1];
+ return status;
+}
+
+//******************************************************************************
+float MAX30205::toCelsius(unsigned int rawTemp) {
+ float val;
+ float val1, val2;
+ val1 = (float)(rawTemp >> 8);
+ val2 = (float)(rawTemp & 0xFF);
+ val = val2 + (val1 / 256.0f);
+ return val;
+}
+
+//******************************************************************************
+float MAX30205::toFahrenheit(float temperatureC) {
+ return temperatureC * 9.0f / 5.0f + 32.0f;
+}
+
+//******************************************************************************
+int MAX30205::reg_THYST_Read(uint16_t *value) {
+ return reg_read16(MAX30205_THYST, value);
+}
+
+//******************************************************************************
+int MAX30205::reg_THYST_Write(uint16_t value) {
+ return reg_write16(MAX30205_THYST, value);
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/Devices/MAX30205/MAX30205/MAX30205.h Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,162 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+#ifndef __MAX30205_H_
+#define __MAX30205_H_
+
+#include "mbed.h"
+
+/**
+ * Driver for the MAX30205 on the HSP Platform
+ *
+ * @code
+ * #include <stdio.h>
+ * #include "mbed.h"
+ * #include "xxx.h"
+ *
+ * I2C i2c(I2C_SDA, I2C_SCL);
+ * xxx xxx(&i2c);
+ *
+ * int main(void) {
+ * printf("Initialized xxx\n");
+ * while(1) {
+ * if (xxx.init() != 0) {
+ * printf("Error communicating with xxx\n");
+ * } else {
+ * printf("Initialized xxx\n");
+ * break;
+ * }
+ * wait(1);
+ * }
+ *
+ * while(1) {
+ * printf("");
+ * wait(1);
+ * }
+ * }
+ * @endcode
+ */
+
+class MAX30205 {
+public:
+ /// MAX30205 Register Addresses
+ typedef enum Registers {
+ MAX30205_Temperature = 0x00,
+ MAX30205_Configuration = 0x01,
+ MAX30205_THYST = 0x02,
+ MAX30205_TOS = 0x03
+ };
+
+ /**
+ * @brief Constructor using I2C PinNames
+ * @param sda Pinname for sda
+ * @param scl Pinname for scl
+ */
+ MAX30205(PinName sda, PinName scl, int slaveAddress);
+ /**
+ * @brief Constructor using pointer to I2C object
+ * @param *i2c Pointer to I2C object
+ */
+ MAX30205(I2C *i2c, int slaveAddress);
+
+ /** @brief Destructor */
+ ~MAX30205(void);
+
+ /** @brief Write a register into device at slave address
+ * @param reg register address
+ * @param value value to write
+ */
+ int reg_write(char reg, char value);
+
+ /**
+ * @brief Detect the second instance of the MAX30205
+ * @param reg register address
+ * @param value 8-bit value to writes
+ */
+ int reg_read(char reg, char *value);
+
+ /**
+ * @brief Write a 16-bit value into device at slave address
+ * @param reg register address
+ * @param value 16-bit value to write
+ */
+ int reg_write16(char reg, uint16_t value);
+
+ /**
+ * @brief Read a 16-bit value from a device at a slave address
+ * @param reg register address
+ * @param value pointer to store read value
+ */
+ int reg_read16(char reg, uint16_t *value);
+
+ /**
+ * @brief Read the temperature from the device into a 16 bit value
+ * @param value pointer to a 16 bit short
+ */
+ int readTemperature(uint16_t *value);
+
+ /**
+ * @brief Read the THYST value from a specified device instance
+ * @param value 16-bit pointer of value to read into
+ */
+ int reg_THYST_Read(uint16_t *value);
+
+ /**
+ * @brief Write the THYST to a device instance
+ * @param value 16-bit value to write
+ */
+ int reg_THYST_Write(uint16_t value);
+
+ /**
+ * @brief Convert a raw temperature value into a float
+ * @param rawTemp raw temperature value to convert
+ * @return the convereted value in degrees C
+ */
+ float toCelsius(unsigned int rawTemp);
+
+ /**
+ * @brief Convert the passed in temperature in C to Fahrenheit
+ * @param temperatureC Temperature in C to convert
+ * @returns Returns the converted Fahrenheit value
+ */
+ float toFahrenheit(float temperatureC);
+
+private:
+ /// I2C pointer
+ I2C *i2c;
+ /// Is this object the owner of the I2C object
+ bool isOwner;
+ /// Device slave address
+ int slaveAddress;
+};
+
+#endif /* __MAX30205_H_ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/Devices/MAX30205/MAX30205_RPC.cpp Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,64 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+#include "MAX30205_RPC.h"
+#include "StringHelper.h"
+#include "MAX30205.h"
+#include "Peripherals.h"
+#include "Device_Logging.h"
+#include "RpcServer.h"
+
+extern Device_Logging *bmp280_Logging;
+extern Device_Logging *MAX30205_0_Logging;
+extern Device_Logging *MAX30205_1_Logging;
+
+//******************************************************************************
+int MAX30205_1_InitStart(char argStrs[32][32], char replyStrs[32][32]) {
+ uint8_t args[1];
+ uint8_t reply[1];
+ ProcessArgs(argStrs, args, sizeof(args));
+ MAX30205_0_Logging->initStart(args[0]);
+ reply[0] = 0x80;
+ FormatReply(reply, sizeof(reply), replyStrs);
+ return 0;
+}
+
+//******************************************************************************
+int MAX30205_2_InitStart(char argStrs[32][32], char replyStrs[32][32]) {
+ uint8_t args[1];
+ uint8_t reply[1];
+ ProcessArgs(argStrs, args, sizeof(args));
+ MAX30205_1_Logging->initStart(args[0]);
+ reply[0] = 0x80;
+ FormatReply(reply, sizeof(reply), replyStrs);
+ return 0;
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/HSP/Devices/MAX30205/MAX30205_RPC.h Tue Oct 25 15:22:11 2016 +0000 @@ -0,0 +1,45 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ +#ifndef _MAX30205_RPC_H_ +#define _MAX30205_RPC_H_ + +#include "mbed.h" + +/** Start Temperature logging or Streaming at a specified seconds rate, MAX30205 Top Temp Sensor +*/ +int MAX30205_1_InitStart(char argStrs[32][32], char replyStrs[32][32]); +/** Start Temperature logging or Streaming at a specified seconds rate, MAX30205 Bottom Temp Sensor +*/ +int MAX30205_2_InitStart(char argStrs[32][32], char replyStrs[32][32]); + +#endif /* _MAX30205_RPC_H_ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/Devices/PushButton/PushButton.cpp Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,68 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+
+#include "PushButton.h"
+#include "Peripherals.h"
+
+void pb_hit_interrupt_fall(void);
+
+PushButton::PushButton(PinName pin) : interruptButton(pin) {
+ this->pin = pin;
+
+ interruptButton.mode(PullUp);
+ // Delay for initial pullup to take effect
+ wait(0.01f);
+ // Attach the address of the interrupt handler routine for pushbutton
+ interruptButton.fall(&pb_hit_interrupt_fall);
+}
+
+bool PushButton::GetButtonFallState(void) {
+ return buttonFallState;
+}
+
+void PushButton::SetButtonFallState(bool state) {
+ buttonFallState = state;
+}
+
+void PushButton::clearButtonFallState(void) {
+ buttonFallState = false;
+}
+
+int PushButton::Read(void) {
+ return interruptButton.read();
+}
+
+void pb_hit_interrupt_fall(void) {
+ if (Peripherals::pushButton() != NULL)
+ Peripherals::pushButton()->SetButtonFallState(true);
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/Devices/PushButton/PushButton.h Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,69 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+#ifndef _PUSHBUTTON_H
+#define _PUSHBUTTON_H
+
+#include "mbed.h"
+
+class PushButton {
+public:
+ /**
+ * @brief Constructor with a PinName
+ */
+ PushButton(PinName pin);
+ /**
+ * @brief Get the pushed state of the button
+ */
+ bool GetButtonFallState(void);
+ /**
+ * @brief Clear the pushed state of the button
+ */
+ void clearButtonFallState(void);
+ /**
+ * @brief Read the button input
+ * @return Represented as 0 or 1 (int)
+ */
+ int Read(void);
+ /**
+ * @brief Set the state
+ * @param state Set the button state to this value
+ */
+ void SetButtonFallState(bool state);
+
+private:
+ InterruptIn interruptButton;
+ bool buttonFallState;
+ PinName pin;
+};
+
+#endif /* _PUSHBUTTON_H */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/Devices/S25FS256/S25FS512.cpp Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,472 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+
+//
+// Flash Non-Volatile Memory
+// U27 S25FS512
+// Nimitz SPIM1
+//
+
+#include "mbed.h"
+#include "S25FS512.h"
+#include "QuadSpiInterface.h"
+
+#define IOMUX_IO_ENABLE 1
+
+#define S25FS512_SPI_PORT 1
+#define S25FS512_CS_PIN 0
+#define S25FS512_CS_POLARITY 0
+#define S25FS512_CS_ACTIVITY_DELAY 0
+#define S25FS512_CS_INACTIVITY_DELAY 0
+#define S25FS512_CLK_HI 4
+#define S25FS512_CLK_LOW 4
+#define S25FS512_ALT_CLK 0
+#define S25FS512_CLK_POLARITY 0
+#define S25FS512_CLK_PHASE 0
+#define S25FS512_WRITE 1
+#define S25FS512_READ 0
+
+#define INT_PORT_B 3
+#define INT_PIN_B 6
+
+uint8_t flashBuffer[257 + 10];
+
+//******************************************************************************
+S25FS512::S25FS512(QuadSpiInterface *_quadSpiInterface) {
+ this->quadSpiInterface = _quadSpiInterface;
+}
+
+//******************************************************************************
+S25FS512::~S25FS512(void) {
+}
+
+//******************************************************************************
+int S25FS512::init(void) {
+ setQuadMode();
+ return 0;
+}
+
+//******************************************************************************
+int S25FS512::wren4Wire(void) {
+ uint8_t cmdArray[8];
+ // Send WREN
+ cmdArray[0] = 0x06;
+ wait_1mS();
+ return reg_write_read_multiple_4Wire(cmdArray, 1, flashBuffer, 1);
+}
+
+//******************************************************************************
+uint8_t S25FS512::wren(void) {
+ uint8_t cmdArray[8];
+ // Send WREN
+ cmdArray[0] = 0x06;
+ wait_1mS();
+ return reg_write_read_multiple_quad(cmdArray, 1, flashBuffer, 0);
+}
+
+//******************************************************************************
+int8_t S25FS512::reg_write_read_multiple_quad_last(uint8_t *bufferOut,
+ uint8_t numberOut,
+ uint8_t *bufferIn,
+ uint8_t numberIn,
+ uint8_t last) {
+ int32_t success = 0;
+
+ success = quadSpiInterface->SPI_Transmit(
+ bufferOut, numberOut,
+ bufferIn, numberIn, (int)last);
+
+ if (success != 0) return -1;
+ return 0;
+}
+
+//******************************************************************************
+int8_t S25FS512::reg_write_read_multiple_4Wire(uint8_t *bufferOut,
+ uint8_t numberOut,
+ uint8_t *bufferIn,
+ uint8_t numberIn) {
+ int32_t success = 0;
+ success = quadSpiInterface->SPI_Transmit4Wire(bufferOut, numberOut, bufferIn,
+ numberIn, (int)1);
+
+ if (success != 0) return -1;
+ return 0;
+}
+
+//******************************************************************************
+int8_t S25FS512::reg_write_read_multiple_quad(uint8_t *bufferOut,
+ uint8_t numberOut,
+ uint8_t *bufferIn,
+ uint8_t numberIn) {
+ int8_t ret;
+ ret = reg_write_read_multiple_quad_last(bufferOut, numberOut, bufferIn,
+ numberIn, 1);
+ return ret;
+}
+
+//******************************************************************************
+void S25FS512::readID(uint8_t *id) {
+ uint8_t cmd = 0x9F;
+ reg_write_read_multiple_quad(&cmd, 1, id, 4);
+}
+
+//******************************************************************************
+int8_t S25FS512::writeAnyRegister(uint32_t address, uint8_t data) {
+ uint8_t cmdArray[5];
+ cmdArray[0] = 0x71;
+ cmdArray[1] = (address >> 16) & 0xFF;
+ cmdArray[2] = (address >> 8) & 0xFF;
+ cmdArray[3] = (address >> 0) & 0xFF;
+ cmdArray[4] = data;
+ return reg_write_read_multiple_quad(cmdArray, 5, flashBuffer, 0);
+}
+
+int8_t S25FS512::writeAnyRegister4Wire(uint32_t address, uint8_t data) {
+ uint8_t cmdArray[5];
+ cmdArray[0] = 0x71;
+ cmdArray[1] = (address >> 16) & 0xFF;
+ cmdArray[2] = (address >> 8) & 0xFF;
+ cmdArray[3] = (address >> 0) & 0xFF;
+ cmdArray[4] = data;
+ return reg_write_read_multiple_4Wire(cmdArray, 5, flashBuffer, 5);
+}
+
+//******************************************************************************
+int8_t S25FS512::writeRegisters(void) {
+ uint8_t cmdArray[3];
+ wait_1mS();
+ cmdArray[0] = 0x01;
+ cmdArray[1] = 0x00;
+ cmdArray[2] = 0x02; // set Quad to 1
+ reg_write_read_multiple_quad(cmdArray, 3, flashBuffer, 0);
+ return 0;
+}
+
+//******************************************************************************
+int8_t S25FS512::readAnyRegister(uint32_t address, uint8_t *data,
+ uint32_t length) {
+ uint8_t cmdArray[4];
+ cmdArray[0] = 0x65;
+ cmdArray[1] = (address >> 16) & 0xFF;
+ cmdArray[2] = (address >> 8) & 0xFF;
+ cmdArray[3] = (address >> 0) & 0xFF;
+ return reg_write_read_multiple_quad(cmdArray, 4, data, length);
+}
+
+//******************************************************************************
+int8_t S25FS512::bulkErase(void) {
+ uint8_t cmdArray[1];
+ cmdArray[0] = 0x60;
+ return reg_write_read_multiple_quad(cmdArray, 1, flashBuffer, 0);
+}
+
+//******************************************************************************
+int8_t S25FS512::pageProgram(uint32_t address, uint8_t *buffer) {
+ uint32_t i;
+ uint8_t cmdArray[5 + 256];
+ uint8_t *ptr;
+
+ // for (i = 0; i < 256; i++) {
+ // dataArray[i] = i;
+ //}
+ cmdArray[0] = 0x02; // 0x71;
+ // cmdArray[1] = (address >> 24) & 0xFF;
+ cmdArray[1] = (address >> 16) & 0xFF;
+ cmdArray[2] = (address >> 8) & 0xFF;
+ cmdArray[3] = (address >> 0) & 0xFF;
+ for (i = 0; i < 256; i++) {
+ cmdArray[4 + i] = buffer[i];
+ }
+ // reg_write_read_multiple_quad(cmdArray,256 + 4,flashBuffer,256 + 4);
+
+ ptr = cmdArray;
+ reg_write_read_multiple_quad_last(ptr, 4 + 64, flashBuffer, 0, 0);
+ wait_1mS();
+ ptr += (4 + 64);
+ reg_write_read_multiple_quad_last(ptr, 64, flashBuffer, 0, 0);
+ wait_1mS();
+ ptr += 64;
+ reg_write_read_multiple_quad_last(ptr, 64, flashBuffer, 0, 0);
+ wait_1mS();
+ ptr += 64;
+ reg_write_read_multiple_quad_last(ptr, 64, flashBuffer, 0, 1);
+ wait_1mS();
+ return 0;
+}
+
+//******************************************************************************
+int8_t S25FS512::quadIoRead_Pages(uint32_t address, uint8_t *buffer,
+ uint32_t numberOfPages) {
+ uint8_t cmdArray[5];
+ uint8_t *ptr;
+ uint8_t last;
+ uint32_t i;
+
+ cmdArray[0] = 0xEB;
+ cmdArray[1] = (address >> 16) & 0xFF;
+ cmdArray[2] = (address >> 8) & 0xFF;
+ cmdArray[3] = (address >> 0) & 0xFF;
+ ptr = buffer;
+ last = 0;
+ // only send the command
+ reg_write_read_multiple_quad_last(cmdArray, 4, ptr, 0, 0);
+ wait_1mS();
+ reg_write_read_multiple_quad_last(cmdArray, 0, ptr, 5, 0);
+ wait_1mS();
+ for (i = 0; i < numberOfPages; i++) {
+ reg_write_read_multiple_quad_last(cmdArray, 0, ptr, 64, 0);
+ wait_1mS();
+ ptr += 64;
+ reg_write_read_multiple_quad_last(cmdArray, 0, ptr, 64, 0);
+ wait_1mS();
+ ptr += 64;
+ reg_write_read_multiple_quad_last(cmdArray, 0, ptr, 64, 0);
+ wait_1mS();
+ ptr += 64;
+ // check if this is the last page
+ if ((i + 1) == numberOfPages) {
+ last = 1;
+ }
+ reg_write_read_multiple_quad_last(cmdArray, 0, ptr, 64, last);
+ wait_1mS();
+ ptr += 64;
+ }
+ return 0;
+}
+
+//******************************************************************************
+int8_t S25FS512::checkBusy(void) {
+ uint8_t cmdArray[5];
+ cmdArray[0] = 0x05;
+ reg_write_read_multiple_quad(cmdArray, 1, flashBuffer, 2);
+ return flashBuffer[1] & 0x1;
+}
+
+//******************************************************************************
+void S25FS512::waitTillNotBusy(void) {
+ while (checkBusy() == 1) {
+ }
+}
+
+//******************************************************************************
+int8_t S25FS512::sectorErase(uint32_t address) {
+ uint8_t cmdArray[5];
+ cmdArray[0] = 0xD8;
+ cmdArray[1] = (address >> 16) & 0xFF;
+ cmdArray[2] = (address >> 8) & 0xFF;
+ cmdArray[3] = (address >> 0) & 0xFF;
+ return reg_write_read_multiple_quad(cmdArray, 4, flashBuffer, 0);
+}
+
+//******************************************************************************
+int8_t S25FS512::parameterSectorErase(uint32_t address) {
+ uint8_t cmdArray[5];
+ cmdArray[0] = 0x20;
+ cmdArray[1] = (address >> 16) & 0xFF;
+ cmdArray[2] = (address >> 8) & 0xFF;
+ cmdArray[3] = (address >> 0) & 0xFF;
+ reg_write_read_multiple_quad(cmdArray, 4, flashBuffer, 0);
+ return 0;
+}
+
+#define ONE_MS (32768 / 500)
+#define ONEHUNDRED_US (32768 / 1000)
+#define TEM_MS (32768 / 50)
+
+//******************************************************************************
+void S25FS512::wait_1mS(void) {
+ wait_ms(1);
+}
+
+//******************************************************************************
+void S25FS512::wait_100uS(void) {
+wait_us(100);
+}
+
+//******************************************************************************
+void S25FS512::wait_10mS(void) {
+wait_ms(10);
+}
+
+//******************************************************************************
+int8_t S25FS512::readIdentification(uint8_t *dataArray, uint8_t length) {
+ // 4QIOR = 0x9F
+ uint8_t cmdArray[1];
+ cmdArray[0] = 0x9F; // read ID command
+ return reg_write_read_multiple_quad(cmdArray, 1, dataArray, length);
+}
+
+//******************************************************************************
+uint8_t S25FS512::reset(void) {
+ uint8_t cmdArray[8];
+ wait_1mS();
+ cmdArray[0] = 0x66;
+ reg_write_read_multiple_quad(cmdArray, 1, flashBuffer, 0);
+ wait_1mS();
+ cmdArray[0] = 0x99;
+ reg_write_read_multiple_quad(cmdArray, 1, flashBuffer, 0);
+ return 0;
+}
+
+//******************************************************************************
+uint8_t S25FS512::enableHWReset(void) {
+ uint8_t data[8];
+ wait_1mS();
+ // CR2V Configuration Register-2 Volatile
+ // bit 5
+ readAnyRegister(0x00800003, data, 8);
+ writeAnyRegister(0x00800003, 0x64);
+ return 0;
+}
+
+//******************************************************************************
+uint8_t S25FS512::detect(void) {
+ uint8_t array[8];
+ uint8_t array2[8];
+
+ // Send WREN
+ wren();
+ // Send WREN
+ wren();
+ // delay
+ wait_1mS();
+ // Send WREN
+ wren();
+ // delay
+ wait_1mS();
+
+ // Send write any register cmd
+ writeAnyRegister(0x0003, 0x48);
+ // delay
+ wait_1mS();
+ array[0] = 0x9F; // read ID command
+ reg_write_read_multiple_quad(array, 1, array2, 7);
+ return 0;
+}
+
+//******************************************************************************
+int S25FS512::setQuadMode(void) {
+ wait_1mS();
+ wren4Wire();
+ wait_1mS();
+ writeAnyRegister4Wire(0x800002, 0x02); // set Quad = 1
+ wait_1mS();
+ wren4Wire();
+ wait_1mS();
+ writeAnyRegister4Wire(0x800003, 0x48); // set 8 latency, set QPI 4-4-4
+}
+
+//******************************************************************************
+uint32_t S25FS512::isPageEmpty(uint8_t *ptr) {
+ int i;
+ for (i = 0; i < 256; i++) {
+ if (ptr[i] != 0xFF)
+ return 0;
+ }
+ return 1;
+}
+
+//******************************************************************************
+int8_t S25FS512::parameterSectorErase_Helper(uint32_t address) {
+ waitTillNotBusy();
+ wait_100uS();
+ wren();
+ wait_100uS();
+ parameterSectorErase(address);
+ wait_100uS();
+ waitTillNotBusy();
+ wait_100uS();
+ return 0;
+}
+
+//******************************************************************************
+int8_t S25FS512::sectorErase_Helper(uint32_t address) {
+ waitTillNotBusy();
+ wait_100uS();
+ wren();
+ wait_100uS();
+ if (address < 0x8000) {
+ parameterSectorErase(address);
+ } else {
+ sectorErase(address);
+ }
+ wait_100uS();
+ waitTillNotBusy();
+ wait_100uS();
+ return 0;
+}
+
+//******************************************************************************
+int8_t S25FS512::bulkErase_Helper(void) {
+ waitTillNotBusy();
+ wait_100uS();
+ wren();
+ wait_100uS();
+ bulkErase();
+ wait_100uS();
+ waitTillNotBusy();
+ wait_100uS();
+ return 0;
+}
+
+//******************************************************************************
+// write a page worth of data (256 bytes) from buffer, offset defined where in
+// the buffer to begin write
+int8_t S25FS512::writePage_Helper(uint32_t pageNumber, uint8_t *buffer,
+ uint32_t offset) {
+ uint8_t *ptr;
+ waitTillNotBusy();
+ wait_1mS();
+ wren();
+ ptr = &buffer[offset];
+ wait_1mS();
+ pageProgram(pageNumber << 8, ptr);
+ wait_1mS();
+ return 0;
+}
+
+//******************************************************************************
+// read pages from flash into buffer, offset defined where in the buffer use
+int8_t S25FS512::readPages_Helper(uint32_t startPageNumber,
+ uint32_t endPageNumber, uint8_t *buffer,
+ uint32_t offset) {
+ uint8_t *ptr;
+ uint32_t page;
+ ptr = &buffer[offset];
+ for (page = startPageNumber; page <= endPageNumber; page++) {
+ wait_100uS();
+ quadIoRead_Pages((uint32_t)(page << 8), (uint8_t *)ptr, 1);
+ ptr += 0x100;
+ }
+ return 0;
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/Devices/S25FS256/S25FS512.h Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,127 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+#ifndef S25FS512_H_
+#define S25FS512_H_
+
+#include "mbed.h"
+#include "QuadSpiInterface.h"
+
+class S25FS512 {
+public:
+ S25FS512(QuadSpiInterface *_quadSpiInterface);
+ ~S25FS512(void);
+
+ QuadSpiInterface *quadSpiInterface;
+
+ /** Initialize the driver
+ */
+ int init(void);
+
+ /** Detect the presence of the flash device
+ */
+ uint8_t detect(void);
+
+ /** Read the identification of the flash
+ */
+ int8_t readIdentification(uint8_t *dataArray, uint8_t length);
+
+ /** Bulk erase the flash device
+ */
+ int8_t bulkErase_Helper(void);
+
+ /** Erase Parameter Sectors
+ */
+ int8_t parameterSectorErase_Helper(uint32_t address);
+
+ /** Write a Page
+ */
+ int8_t writePage_Helper(uint32_t pageNumber, uint8_t *buffer,
+ uint32_t offset);
+
+ /** Read a Page
+ * @param
+ */
+ int8_t readPages_Helper(uint32_t startPageNumber, uint32_t endPageNumber,
+ uint8_t *buffer, uint32_t offset);
+
+ /** Erase a Sector
+ @param address Address of sector to erase
+ */
+
+ int8_t sectorErase_Helper(uint32_t address);
+ /** Scans through byte pointer for a page worth of data to see if the page is all FFs
+ @param ptr Byte pointer to buffer to scan
+ @return Returns a 1 if the page is empty, 0 if it is not all FFs
+ */
+ uint32_t isPageEmpty(uint8_t *ptr);
+
+ /** Issue a software reset to the flash device
+ */
+
+ uint8_t reset(void);
+ /** Enable a hardware reset
+ */
+
+ uint8_t enableHWReset(void);
+ /** Read the id byte of this device
+ */
+
+ void readID(uint8_t *id);
+
+private:
+ int8_t reg_write_read_multiple_quad_last(uint8_t *dataIn, uint8_t numberIn, uint8_t *dataOut, uint8_t numberOut, uint8_t last);
+ int8_t reg_write_read_multiple_quad(uint8_t *dataIn, uint8_t numberIn, uint8_t *dataOut, uint8_t numberOut);
+ int8_t reg_write_read_multiple_4Wire(uint8_t *bufferOut, uint8_t numberOut, uint8_t *bufferIn, uint8_t numberIn);
+ uint8_t spiWriteRead (uint8_t writeNumber,uint8_t *writeData, uint8_t readNumber, uint8_t *readData);
+ uint8_t spiWriteRead4Wire(uint8_t writeNumber,uint8_t *writeData, uint8_t readNumber, uint8_t *readData);
+
+ int8_t writeAnyRegister(uint32_t address, uint8_t data);
+ int8_t writeAnyRegister4Wire(uint32_t address, uint8_t data);
+ int8_t writeRegisters(void);
+ uint8_t wren(void);
+ int setQuadMode(void);
+ int wren4Wire(void);
+ // int8_t setQuadMode();
+ int8_t readAnyRegister(uint32_t address, uint8_t *data, uint32_t length);
+ int8_t bulkErase(void);
+ int8_t pageProgram(uint32_t address, uint8_t *buffer);
+ int8_t quadIoRead_Pages(uint32_t address, uint8_t *buffer, uint32_t numberOfPages);
+ int8_t checkBusy(void);
+ void waitTillNotBusy(void);
+ int8_t sectorErase(uint32_t address);
+ int8_t parameterSectorErase(uint32_t address);
+ void wait_1mS(void);
+ void wait_100uS(void);
+ void wait_10mS(void);
+};
+#endif /* S25FS512_H_ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/Devices/S25FS256/S25FS512_RPC.cpp Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,122 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+
+#include "S25FS512_RPC.h"
+#include "S25FS512.h"
+#include "StringInOut.h"
+#include "StringHelper.h"
+#include "Peripherals.h"
+
+int S25FS512_Reset(char argStrs[32][32], char replyStrs[32][32]) {
+ uint32_t reply[1];
+ Peripherals::s25FS512()->reset();
+ reply[0] = 0x80;
+ FormatReply32(reply, sizeof(reply) / sizeof(uint32_t), replyStrs);
+ return 0;
+}
+
+int S25FS512_EnableHWReset(char argStrs[32][32], char replyStrs[32][32]) {
+ uint32_t reply[1];
+ Peripherals::s25FS512()->enableHWReset();
+ reply[0] = 0x80;
+ FormatReply32(reply, sizeof(reply) / sizeof(uint32_t), replyStrs);
+ return 0;
+}
+
+int S25FS512_SpiWriteRead(char argStrs[32][32], char replyStrs[32][32]) {
+ uint8_t args[16];
+ uint8_t reply[16];
+ uint8_t writeNumber;
+ uint8_t readNumber;
+ // get the number of bytes to write
+ ProcessArgs(argStrs, args, 1);
+ writeNumber = args[0];
+ ProcessArgs(argStrs, args, writeNumber + 2);
+ readNumber = args[writeNumber + 1];
+ FormatReply(reply, readNumber, replyStrs);
+ return 0;
+}
+
+int S25FS512_SpiWriteRead4Wire(char argStrs[32][32], char replyStrs[32][32]) {
+ uint8_t args[16];
+ uint8_t reply[16];
+ uint8_t writeNumber;
+ uint8_t readNumber;
+ // get the number of bytes to write
+ ProcessArgs(argStrs, args, 1);
+ writeNumber = args[0];
+ ProcessArgs(argStrs, args, writeNumber + 2);
+ readNumber = args[writeNumber + 1];
+ FormatReply(reply, readNumber, replyStrs);
+ return 0;
+}
+
+int S25FS512_ReadPage(char argStrs[32][32], char replyStrs[32][32]) {
+ uint32_t args[2];
+ uint32_t reply[1];
+ ProcessArgs32(argStrs, args, sizeof(args) / sizeof(uint32_t));
+ reply[0] = 0x80;
+ FormatReply32(reply, sizeof(reply) / sizeof(uint32_t), replyStrs);
+ return 0;
+}
+
+int S25FS512_ReadPagesBinary(char argStrs[32][32], char replyStrs[32][32]) {
+ uint32_t args[2];
+ uint32_t reply[1];
+ uint8_t pageData[256];
+
+ uint32_t startPage;
+ uint32_t endPage;
+ uint32_t page;
+
+ ProcessArgs32(argStrs, args, sizeof(args) / sizeof(uint32_t));
+ startPage = args[0];
+ endPage = args[1];
+ for (page = startPage; page <= endPage; page++) {
+ Peripherals::s25FS512()->readPages_Helper(page, page, pageData, 0);
+ putBytes256Block(pageData, 1);
+ }
+ reply[0] = 0x80;
+ FormatReply32(reply, sizeof(reply) / sizeof(uint32_t), replyStrs);
+ return 0;
+}
+
+int S25FS512_ReadId(char argStrs[32][32], char replyStrs[32][32]) {
+ char str[32];
+ uint8_t data[128];
+ Peripherals::s25FS512()->readIdentification(data, sizeof(data));
+ Peripherals::s25FS512()->readIdentification(data, sizeof(data));
+ sprintf(str, "%02X%02X%02X%02X", data[0], data[1], data[2], data[3]);
+ strcpy(replyStrs[0], str);
+ return 0;
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/HSP/Devices/S25FS256/S25FS512_RPC.h Tue Oct 25 15:22:11 2016 +0000 @@ -0,0 +1,47 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ +#ifndef _S25FS512_RPC_H_ +#define _S25FS512_RPC_H_ + +#include "mbed.h" + +int S25FS512_ReadPagesBinary(char argStrs[32][32], char replyStrs[32][32]); +int S25FS512_ReadPage(char argStrs[32][32], char replyStrs[32][32]); +int S25FS512_ReadPagesBinary(char argStrs[32][32], char replyStrs[32][32]); +int S25FS512_ReadId(char argStrs[32][32], char replyStrs[32][32]); +int S25FS512_Reset(char argStrs[32][32], char replyStrs[32][32]); +int S25FS512_EnableHWReset(char argStrs[32][32], char replyStrs[32][32]); +int S25FS512_SpiWriteRead(char argStrs[32][32], char replyStrs[32][32]); +int S25FS512_SpiWriteRead4Wire(char argStrs[32][32], char replyStrs[32][32]); + +#endif /* _S25FS512_RPC_H_ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/Hsp_BLE/BluetoothLE/BluetoothLE.cpp Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,172 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+#include "BluetoothLE.h"
+#include "Characteristic.h"
+
+/**
+ * @brief Constructor for class
+ */
+BluetoothLE::BluetoothLE(BLE *ble, int numberOfCharacteristics)
+ : ble(ble), runningIndex(0),
+ numberOfCharacteristics(numberOfCharacteristics) {
+ characteristics = new Characteristic *[numberOfCharacteristics];
+ gattCharacteristics = new GattCharacteristic *[numberOfCharacteristics];
+}
+
+/**
+ * @brief Destructor for class
+ */
+BluetoothLE::~BluetoothLE(void) {
+ for (int i = 0; i < numberOfCharacteristics; i++) delete characteristics[i];
+ delete[] gattCharacteristics;
+ delete[] characteristics;
+}
+
+/**
+ * @brief Initialize the advertising, characteristics, service for this platform
+ */
+void BluetoothLE::addCharacteristic(Characteristic *characteristic) {
+ characteristic->setBLE(ble);
+ characteristic->setIndex(runningIndex);
+ characteristics[runningIndex] = characteristic;
+ gattCharacteristics[runningIndex] = characteristic->getGattCharacteristic();
+ runningIndex++;
+}
+
+/**
+ * @brief Initialize the advertising, characteristics, service for this platform
+ */
+void BluetoothLE::initService(uint8_t *serialNumber, uint8_t *deviceName,
+ int nameSize, uint8_t *serviceUUID) {
+ ble->init();
+ ble->onDisconnection(this, &BluetoothLE::disconnectionCallback);
+
+ ble->gap().setAddress((BLEProtocol::AddressType_t)0, serialNumber);
+
+ // Setup Advertising
+ ble->accumulateAdvertisingPayload(
+ GapAdvertisingData::BREDR_NOT_SUPPORTED |
+ GapAdvertisingData::LE_GENERAL_DISCOVERABLE);
+ ble->accumulateAdvertisingPayload(GapAdvertisingData::COMPLETE_LOCAL_NAME,
+ (uint8_t *)deviceName, nameSize);
+ ble->setAdvertisingType(GapAdvertisingParams::ADV_CONNECTABLE_UNDIRECTED);
+ ble->setAdvertisingInterval(1600); // 1000ms; in multiples of 0.625ms.
+ GattService envService(serviceUUID, gattCharacteristics,
+ numberOfCharacteristics);
+ ble->gattServer().addService(envService);
+ ble->onDataWritten(this, &BluetoothLE::onDataWritten);
+ // Start Advertising
+ ble->startAdvertising();
+}
+
+static const Gap::ConnectionParams_t paramsLowPower = {
+ 400, /**< Minimum Connection Interval in 1.25 ms units, see @ref BLE_GAP_CP_LIMITS.*/
+ 400, /**< Maximum Connection Interval in 1.25 ms units, see @ref BLE_GAP_CP_LIMITS.*/
+ 60, /**< Slave Latency in number of connection events, see @ref BLE_GAP_CP_LIMITS.*/
+ 3100 /**< Connection Supervision Timeout in 10 ms units, see @ref BLE_GAP_CP_LIMITS.*/
+};
+
+static Gap::Handle_t connHandle = 0;
+
+/**
+ * @brief Called on BLE connection
+ */
+void BluetoothLE::connectionCallback(
+ const Gap::ConnectionCallbackParams_t *params) {
+ connHandle = params->handle;
+}
+
+/**
+ * @brief Start advertising on a disconnect
+ */
+void BluetoothLE::disconnectionCallback(
+ const Gap::DisconnectionCallbackParams_t *params) {
+ _isConnected = false;
+ ble->startAdvertising();
+}
+
+/**
+ * @brief Called when the client writes to a writable characteristic
+ * @param params Pointer to a structure that contains details on what was
+ * written
+ */
+void BluetoothLE::onDataWritten(const GattWriteCallbackParams *params) {
+ int i;
+ int index = 0;
+ // match the characteristic handle
+ printf("BluetoothLE::onDataWritten ");
+ for (i = 0; i < numberOfCharacteristics; i++) {
+ if (params->handle == gattCharacteristics[i]->getValueHandle()) {
+ characteristics[i]->copyDataWritten(params);
+ index = i;
+ break;
+ }
+ }
+ (*_onDataWritten)(index);
+}
+
+/**
+* @brief Update the characteristic notification
+* @param index Index of the characteristic
+* @param data Pointer to the byte data to update the charateristic payload
+*/
+void BluetoothLE::notifyCharacteristic(int index, uint8_t *data) {
+ for (int i = 0; i < characteristics[index]->getPayloadLength(); i++) {
+ characteristics[index]->getPayloadBytes()[i] = data[i];
+ }
+ characteristics[index]->update();
+}
+
+/**
+* @brief Update the characteristic notification
+* @param index Index of the characteristic
+* @param data Pointer to the byte data to update the charateristic payload
+*/
+void BluetoothLE::notifyCharacteristicTest(int index) {
+ for (int i = 0; i < characteristics[index]->getPayloadLength(); i++) {
+ characteristics[index]->getPayloadBytes()[i]++;
+ }
+ characteristics[index]->update();
+}
+
+uint8_t *BluetoothLE::getDataWritten(int index, int *length) {
+ return characteristics[index]->getDataWritten(length);
+}
+
+/**
+* @brief Function to query if a BLE connection is active
+* @return true if BLE connected, false if BLE is not connected
+*/
+bool BluetoothLE::isConnected(void) {
+ return (ble->getGapState().connected == 1 ? true : false);
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/Hsp_BLE/BluetoothLE/BluetoothLE.h Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,137 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+#ifndef _BLUETOOTHLE_H_
+#define _BLUETOOTHLE_H_
+
+#include "mbed.h"
+#include "BLE.h"
+#include "Characteristic.h"
+
+class BluetoothLE {
+public:
+ BluetoothLE(BLE *ble, int numberOfCharacteristics);
+ ~BluetoothLE(void);
+ void addCharacteristic(Characteristic *characteristic);
+ void initService(uint8_t *serialNumber, uint8_t *deviceName, int nameSize, uint8_t *serviceUUID);
+ void notifyCharacteristic(int index, uint8_t *data);
+
+
+ /**
+ * @brief Return a characteristic based on incoming index
+ * @param index index into an array of characteristics
+ */
+ Characteristic *getCharacteristic(int index) {
+ return characteristics[index];
+ }
+
+ /**
+ * @brief Get the payload for this characteristic
+ */
+ uint8_t *getCharacteristicPayload(int index) {
+ return characteristics[index]->getPayloadPtr();
+ }
+ typedef void (*PtrFunction)(int index);
+
+ /**
+ * @brief Used to connect a connection callback
+ */
+ template<typename T>
+ void onConnect(T *object, void (T::*member)(void)) {
+ _onConnect.attach( object, member );
+ }
+ /**
+ * @brief Used to connect a disconnection callback
+ */
+ template<typename T>
+ void onDisconnect(T *object, void (T::*member)(void)) {
+ _onDisconnect.attach( object, member );
+ }
+ /**
+ * @brief Used to connect a characteristic written callback
+ */
+ void onDataWritten(PtrFunction _onDataWritten) {
+ this->_onDataWritten = _onDataWritten;
+ }
+ /**
+ * @brief Get the connection state of the BLE
+ * @return true if connection BLE connection is present, false if no connection
+ */
+ bool isConnected(void);
+
+ /**
+ * @brief Perform a notification test
+ * @param index Index into an array of characteristic objects
+ */
+ void notifyCharacteristicTest(int index);
+
+ /**
+ * @brief Get the data that was written to the indexed characteristic
+ * @return true if connection BLE connection is present, false if no connection
+ */
+ uint8_t *getDataWritten(int index, int *length);
+
+private:
+ /**
+ * @brief Disconnection callback
+ */
+ void disconnectionCallback(const Gap::DisconnectionCallbackParams_t *params);
+ /**
+ * @brief Connection callback
+ */
+ void connectionCallback(const Gap::ConnectionCallbackParams_t *params);
+ /**
+ * @brief Characteristic written callback
+ */
+ void onDataWritten(const GattWriteCallbackParams *params);
+
+ /// array of characteristic class pointers
+ Characteristic **characteristics;
+ /// array of gatt characteristic pointers
+ GattCharacteristic **gattCharacteristics;
+ /// pointer to mbed BLE layer
+ BLE *ble;
+ /// total number of characteristics
+ int numberOfCharacteristics;
+ /// flag to keep track of BLE connection state
+ bool _isConnected;
+ /// running index for building characteristic array
+ int runningIndex;
+ /// callback function for when a connection is made
+ FunctionPointer _onConnect;
+ /// callback function for when a connection is disconnected
+ FunctionPointer _onDisconnect;
+ /// callback function for when characteristic data is written
+ PtrFunction _onDataWritten;
+};
+
+#endif // _BLUETOOTHLE_H_
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/Hsp_BLE/BluetoothLE/Characteristic.cpp Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,61 @@
+/*******************************************************************************
+* Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+*
+* Permission is hereby granted, free of charge, to any person obtaining a
+* copy of this software and associated documentation files (the "Software"),
+* to deal in the Software without restriction, including without limitation
+* the rights to use, copy, modify, merge, publish, distribute, sublicense,
+* and/or sell copies of the Software, and to permit persons to whom the
+* Software is furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included
+* in all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+* IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+* OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+* OTHER DEALINGS IN THE SOFTWARE.
+*
+* Except as contained in this notice, the name of Maxim Integrated
+* Products, Inc. shall not be used except as stated in the Maxim Integrated
+* Products, Inc. Branding Policy.
+*
+* The mere transfer of this software does not imply any licenses
+* of trade secrets, proprietary technology, copyrights, patents,
+* trademarks, maskwork rights, or any other form of intellectual
+* property whatsoever. Maxim Integrated Products, Inc. retains all
+* ownership rights.
+*******************************************************************************
+*/
+#include "Characteristic.h"
+
+Characteristic::Characteristic(uint16_t length, const UUID &uuid,
+ uint8_t additionalProperties,
+ GattAttribute *descriptors[],
+ unsigned numDescriptors)
+ : gattCharacteristic(
+ uuid, reinterpret_cast<uint8_t *>(payload.getPointer()), length,
+ length, additionalProperties, descriptors, numDescriptors) {
+ payloadLength = length;
+ dataWrittenLength = -1;
+}
+
+void Characteristic::update(void) {
+ if (ble->getGapState().connected) {
+ ble->gattServer().write(gattCharacteristic.getValueHandle(),
+ payload.getPointer(), payloadLength);
+ }
+}
+
+int Characteristic::getPayloadLength(void) { return payloadLength; }
+
+GattAttribute::Handle_t Characteristic::getValueHandle(void) {
+ return gattCharacteristic.getValueHandle();
+}
+
+GattCharacteristic *Characteristic::getGattCharacteristic(void) {
+ return &gattCharacteristic;
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/Hsp_BLE/BluetoothLE/Characteristic.h Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,112 @@
+/*******************************************************************************
+* Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+*
+* Permission is hereby granted, free of charge, to any person obtaining a
+* copy of this software and associated documentation files (the "Software"),
+* to deal in the Software without restriction, including without limitation
+* the rights to use, copy, modify, merge, publish, distribute, sublicense,
+* and/or sell copies of the Software, and to permit persons to whom the
+* Software is furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included
+* in all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+* IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+* OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+* OTHER DEALINGS IN THE SOFTWARE.
+*
+* Except as contained in this notice, the name of Maxim Integrated
+* Products, Inc. shall not be used except as stated in the Maxim Integrated
+* Products, Inc. Branding Policy.
+*
+* The mere transfer of this software does not imply any licenses
+* of trade secrets, proprietary technology, copyrights, patents,
+* trademarks, maskwork rights, or any other form of intellectual
+* property whatsoever. Maxim Integrated Products, Inc. retains all
+* ownership rights.
+*******************************************************************************
+*/
+#ifndef _CHARACTERISTIC_H_
+#define _CHARACTERISTIC_H_
+
+#include "mbed.h"
+#include "BLE.h"
+#include "GattCharacteristic.h"
+
+class Characteristic {
+public:
+ /**
+ * @brief ticker handler static method
+ */
+ Characteristic(uint16_t length, const UUID &uuid,
+ uint8_t additionalProperties =
+ GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_NONE,
+ GattAttribute *descriptors[] = NULL,
+ unsigned numDescriptors = 0);
+
+ void setIndex(int index) { this->index = index; }
+ /**
+ * @brief Set a pointer reference to the mbed BLE framework
+ */
+ void setBLE(BLE *ble) { this->ble = ble; }
+ /**
+ * @brief Get the pointer to the byte payload
+ */
+ uint8_t *getPayloadPtr(void) { return payload.getPointer(); }
+ /**
+ * @brief Get the handle of the characteristic
+ */
+ GattAttribute::Handle_t getValueHandle();
+ /**
+ * @brief Update the characteristic
+ */
+ void update(void);
+ /**
+ * @brief Get the GattCharacteristic
+ */
+ GattCharacteristic *getGattCharacteristic();
+ /**
+ * @brief Get the length of the payload
+ */
+ int getPayloadLength(void);
+
+ uint8_t *getPayloadBytes(void) { return payload.bytes; }
+
+ void copyDataWritten(const GattWriteCallbackParams *params) {
+ int i = 0;
+ while (i < params->len && i < sizeof(dataWritten)) {
+ dataWritten[i] = params->data[i];
+ i++;
+ }
+ dataWrittenLength = params->len;
+ }
+
+ uint8_t *getDataWritten(int *length) {
+ *length = dataWrittenLength;
+ return dataWritten;
+ }
+
+private:
+ int payloadLength;
+ struct PayloadStruct {
+ uint8_t bytes[32];
+ uint8_t *getPointer(void) { return bytes; }
+ };
+ /// local copy of data written to this characteristic
+ uint8_t dataWritten[64];
+ int dataWrittenLength;
+ /// payload structure for this characteristic
+ PayloadStruct payload;
+ /// gatt characteristic
+ GattCharacteristic gattCharacteristic;
+ /// mbed BLE framework pointer
+ BLE *ble;
+ /// index of this characteristic
+ int index;
+};
+
+#endif /* _CHARACTERISTIC_H_ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/Hsp_BLE/HspBLE.cpp Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,197 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+#include "HspBLE.h"
+#include "Peripherals.h"
+#include "MAX30001_helper.h"
+
+#define LOW_BYTE(x) ((uint8_t)((x)&0xFF))
+#define HIGH_BYTE(x) ((uint8_t)(((x) >> 8) & 0xFF))
+
+/// define all of the characteristic UUIDs
+uint8_t HspBLE::temperatureTopCharUUID[] = {0x35,0x44,0x53,0x1b,0x00,0xc3,0x43,0x42,0x97,0x55,0xb5,0x6a,0xbe,0x8e,0x6c,0x67};
+uint8_t HspBLE::temperatureBottomCharUUID[] = {0x35,0x44,0x53,0x1b,0x00,0xc3,0x43,0x42,0x97,0x55,0xb5,0x6a,0xbe,0x8e,0x6a,0x66};
+uint8_t HspBLE::accelerometerCharUUID[] = {0xe6,0xc9,0xda,0x1a,0x80,0x96,0x48,0xbc,0x83,0xa4,0x3f,0xca,0x38,0x37,0x05,0xaf};
+uint8_t HspBLE::heartrateCharUUID[] = {0x62,0x1a,0x00,0xe3,0xb0,0x93,0x46,0xbf,0xaa,0xdc,0xab,0xe4,0xc6,0x48,0xc5,0x69};
+uint8_t HspBLE::pressureCharUUID[] = {0x1d,0x8a,0x19,0x32,0xda,0x49,0x49,0xad,0x91,0xd8,0x80,0x08,0x32,0xe7,0xe9,0x40};
+uint8_t HspBLE::dataCharUUID[] = {0xaa,0x8a,0x19,0x32,0xda,0x49,0x49,0xad,0x91,0xd8,0x80,0x08,0x32,0xe7,0xe9,0x40};
+uint8_t HspBLE::commandCharUUID[] = {0x36,0xe5,0x5e,0x37,0x6b,0x5b,0x42,0x0b,0x91,0x07,0x0d,0x34,0xa0,0xe8,0x67,0x5a};
+
+
+/// define the BLE device name
+uint8_t HspBLE::deviceName[] = "MAXREFDES100";
+/// define the BLE serial number
+uint8_t HspBLE::serialNumber[] = {0x77, 0x22, 0x33, 0x45, 0x67, 0x89};
+/// define the BLE service UUID
+uint8_t HspBLE::envServiceUUID[] = {0x5c,0x6e,0x40,0xe8,0x3b,0x7f,0x42,0x86,0xa5,0x2f,0xda,0xec,0x46,0xab,0xe8,0x51};
+
+HspBLE *HspBLE::instance = NULL;
+
+/**
+* @brief Constructor that inits the BLE helper object
+* @param ble Pointer to the mbed BLE object
+*/
+HspBLE::HspBLE(BLE *ble) {
+ bluetoothLE = new BluetoothLE(ble, NUMBER_OF_CHARACTERISTICS);
+ instance = this;
+ notificationUpdateRoundRobin = 0;
+}
+
+/**
+* @brief Constructor that deletes the bluetoothLE object
+*/
+HspBLE::~HspBLE(void) { delete bluetoothLE; }
+
+/**
+* @brief Initialize all of the HSP characteristics, initialize the ble service
+* and attach callbacks
+*/
+void HspBLE::init(void) {
+ uint8_t *serialNumberPtr;
+ // uint8_t serialNumberBuffer[6];
+ serialNumberPtr = MAX30001_Helper_getVersion();
+ printf("MAX30001 Version = %02X:%02X:%02X:%02X:%02X:%02X...\n",
+ serialNumberPtr[0], serialNumberPtr[1], serialNumberPtr[2],
+ serialNumberPtr[3], serialNumberPtr[4], serialNumberPtr[5]);
+ serialNumberPtr[3] = 0x00;
+ serialNumberPtr[4] = 0x00;
+ serialNumberPtr[5] = 0x03;
+ printf("BLE DeviceID = %02X:%02X:%02X:%02X:%02X:%02X...\n",
+ serialNumberPtr[0], serialNumberPtr[1], serialNumberPtr[2],
+ serialNumberPtr[3], serialNumberPtr[4], serialNumberPtr[5]);
+
+ bluetoothLE->addCharacteristic(new Characteristic(2 /* number of bytes */,temperatureTopCharUUID,GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_READ | GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_NOTIFY));
+ bluetoothLE->addCharacteristic(new Characteristic(2 /* number of bytes */,temperatureBottomCharUUID,GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_READ | GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_NOTIFY));
+ bluetoothLE->addCharacteristic(new Characteristic(6 /* number of bytes */,accelerometerCharUUID,GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_READ | GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_NOTIFY));
+ bluetoothLE->addCharacteristic(new Characteristic(4 /* number of bytes */,heartrateCharUUID,GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_READ | GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_NOTIFY));
+ bluetoothLE->addCharacteristic(new Characteristic(8 /* number of bytes */,pressureCharUUID,GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_READ | GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_NOTIFY));
+ bluetoothLE->addCharacteristic(new Characteristic(32 /* number of bytes */,dataCharUUID,GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_READ | GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_WRITE));
+ bluetoothLE->addCharacteristic(new Characteristic(1 /* number of bytes */,commandCharUUID,GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_READ | GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_WRITE));
+ bluetoothLE->initService(serialNumberPtr, deviceName, sizeof(deviceName),envServiceUUID);
+
+ bluetoothLE->onDataWritten(&HspBLE::_onDataWritten);
+ ticker.attach(this, &HspBLE::tickerHandler, 1);
+}
+
+void HspBLE::_onDataWritten(int index) {
+ HspBLE::instance->onDataWritten(index);
+}
+
+/**
+* @brief Callback for written characteristics
+* @param index Index of whose characteristic is written to
+*/
+void HspBLE::onDataWritten(int index) {
+ int length;
+ uint8_t *data;
+ printf("onDataWritten ");
+ if (index == CHARACTERISTIC_CMD) {
+ data = bluetoothLE->getDataWritten(index, &length);
+ if (length >= 1) {
+ if (data[0] == 0x00) startDataLogging = false;
+ if (data[0] == 0x01) startDataLogging = true;
+ printf("onDataWritten index %d, data %02X, length %d ",index,data[0],length); fflush(stdout);
+
+ }
+ }
+}
+
+void HspBLE::pollSensor(int sensorId, uint8_t *data) {
+
+ switch (sensorId) {
+ case CHARACTERISTIC_TEMP_TOP: {
+ uint16_t uShort;
+ Peripherals::max30205_top()->readTemperature(&uShort);
+ data[0] = HIGH_BYTE(uShort);
+ data[1] = LOW_BYTE(uShort);
+ } break;
+ case CHARACTERISTIC_TEMP_BOTTOM: {
+ uint16_t uShort;
+ Peripherals::max30205_bottom()->readTemperature(&uShort);
+ data[0] = HIGH_BYTE(uShort);
+ data[1] = LOW_BYTE(uShort);
+ } break;
+ case CHARACTERISTIC_ACCELEROMETER: {
+ int i;
+ uint8_t *bytePtr;
+ int16_t acclPtr[3];
+ Peripherals::lis2dh()->get_motion_cached(&acclPtr[0], &acclPtr[1],
+ &acclPtr[2]);
+ bytePtr = reinterpret_cast<uint8_t *>(&acclPtr);
+ for (i = 0; i < sizeof(acclPtr); i++)
+ data[i] = bytePtr[i];
+ } break;
+ case CHARACTERISTIC_PRESSURE: {
+ int i;
+ uint8_t *bytePtr;
+ float temperature;
+ float pressure;
+ Peripherals::bmp280()->ReadCompData(&temperature, &pressure);
+ bytePtr = reinterpret_cast<uint8_t *>(&temperature);
+ for (i = 0; i < sizeof(float); i++)
+ data[i] = bytePtr[i];
+ bytePtr = reinterpret_cast<uint8_t *>(&pressure);
+ for (i = 0; i < sizeof(float); i++)
+ data[i + sizeof(float)] = bytePtr[i];
+ } break;
+ case CHARACTERISTIC_HEARTRATE: {
+ int i;
+ uint8_t *bytePtr;
+ MAX30001::max30001_t heartrateData;
+ Peripherals::max30001()->max30001_ReadHeartrateData(&heartrateData);
+ bytePtr = reinterpret_cast<uint8_t *>(&heartrateData);
+ for (i = 0; i < sizeof(MAX30001::max30001_t); i++)
+ data[i] = bytePtr[i];
+ } break;
+ }
+}
+
+bool HspBLE::getStartDataLogging(void) { return startDataLogging; }
+
+/**
+* @brief Timer Callback that updates all sensor characteristic notifications
+*/
+void HspBLE::tickerHandler(void) {
+ uint8_t data[8];
+ if (bluetoothLE->isConnected()) {
+ pollSensor(CHARACTERISTIC_TEMP_TOP, data);
+ bluetoothLE->notifyCharacteristic(CHARACTERISTIC_TEMP_TOP, data);
+ pollSensor(CHARACTERISTIC_TEMP_BOTTOM, data);
+ bluetoothLE->notifyCharacteristic(CHARACTERISTIC_TEMP_BOTTOM, data);
+ pollSensor(CHARACTERISTIC_ACCELEROMETER, data);
+ bluetoothLE->notifyCharacteristic(CHARACTERISTIC_ACCELEROMETER, data);
+ pollSensor(CHARACTERISTIC_HEARTRATE, data);
+ bluetoothLE->notifyCharacteristic(CHARACTERISTIC_HEARTRATE, data);
+ pollSensor(CHARACTERISTIC_PRESSURE, data);
+ bluetoothLE->notifyCharacteristic(CHARACTERISTIC_PRESSURE, data);
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/Hsp_BLE/HspBLE.h Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,92 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+#ifndef _HSPBLE_H_
+#define _HSPBLE_H_
+
+#include "mbed.h"
+#include "BluetoothLE.h"
+
+/// define the number of characteristics used on the HSP platform
+#define NUMBER_OF_CHARACTERISTICS (7)
+
+/// indicies of the characteristics used
+#define CHARACTERISTIC_TEMP_TOP (0)
+#define CHARACTERISTIC_TEMP_BOTTOM (1)
+#define CHARACTERISTIC_ACCELEROMETER (2)
+#define CHARACTERISTIC_HEARTRATE (3)
+#define CHARACTERISTIC_PRESSURE (4)
+#define CHARACTERISTIC_DATA (5)
+#define CHARACTERISTIC_CMD (6)
+
+class HspBLE {
+public:
+ HspBLE(BLE *ble);
+ ~HspBLE(void);
+ void init(void);
+ static void _onDataWritten(int index);
+ void onDataWritten(int index);
+ void updateNotification(int index);
+ void pollSensor(int sensorId, uint8_t *data);
+ bool getStartDataLogging(void);
+ static HspBLE *instance;
+
+private:
+ void tickerHandler(void);
+ void testPattern(uint8_t *data, int length, bool clear);
+
+ /// pointer to the helper BLE object
+ BluetoothLE *bluetoothLE;
+ /// ticker that is used to periodically update the characteristic
+ /// notifications
+ Ticker ticker;
+
+ /// value that controls the notifications to be sent in a round robin fashion
+ int notificationUpdateRoundRobin;
+
+ /// charateristic UUIDs statically defined
+ static uint8_t temperatureTopCharUUID[];
+ static uint8_t temperatureBottomCharUUID[];
+ static uint8_t accelerometerCharUUID[];
+ static uint8_t heartrateCharUUID[];
+ static uint8_t pressureCharUUID[];
+ static uint8_t dataCharUUID[];
+ static uint8_t commandCharUUID[];
+ static uint8_t envServiceUUID[];
+ static uint8_t deviceName[];
+ static uint8_t serialNumber[];
+
+ /// application specific
+ bool startDataLogging;
+};
+
+#endif // _HSPBLE_H_
\ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/Interfaces/I2C_RPC.cpp Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,85 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+#include <stdint.h>
+#include "StringHelper.h"
+#include "I2C_RPC.h"
+#include "Peripherals.h"
+
+//******************************************************************************
+// input
+// [instance] [slaveAddress] [writeNumber] [](data to write) [readNumber]
+// output data to read
+int I2C_WriteRead(char argStrs[32][32], char replyStrs[32][32]) {
+ uint8_t args[16];
+ uint8_t reply[16];
+ uint8_t writeNumber;
+ uint8_t readNumber;
+ uint8_t instance;
+ uint8_t slaveAddress;
+ int ret1;
+ int ret2;
+ I2C *i2c;
+ // get the number of bytes to write
+ ProcessArgs(argStrs, args, 3); // parse [instance] [slaveAddress] [writeNumber]
+ instance = args[0];
+ slaveAddress = args[1];
+ writeNumber = args[2];
+ // parse [instance] [slaveAddress] [writeNumber] [](data to write)
+ // [readNumber]
+ ProcessArgs(argStrs, args, writeNumber + 4);
+ readNumber = args[writeNumber + 3];
+
+ if (instance == 1) {
+ i2c = Peripherals::i2c1();
+ }
+ if (instance == 2) {
+ i2c = Peripherals::i2c2();
+ }
+ ret1 = 0;
+ ret2 = 0;
+
+ if (writeNumber != 0) {
+ ret1 = i2c->write((int)slaveAddress, (char *)&args[3], (int)writeNumber);
+ }
+ if (readNumber != 0) {
+ ret2 = i2c->read((int)slaveAddress, (char *)reply, (int)readNumber);
+ }
+
+ if (ret1 != 0) reply[0] = 0xFF;
+ if (ret2 != 0) reply[0] = 0xFF;
+
+
+ // reply[0] = 0x80;
+ FormatReply(reply, readNumber, replyStrs);
+ return 0;
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/HSP/Interfaces/I2C_RPC.h Tue Oct 25 15:22:11 2016 +0000 @@ -0,0 +1,43 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ +#ifndef _I2C_RPC_H_ +#define _I2C_RPC_H_ + +#include "mbed.h" + +int I2C_Init(char argStrs[32][32], char replyStrs[32][32]); +int I2C_Write(char argStrs[32][32], char replyStrs[32][32]); +int I2C_Read(char argStrs[32][32], char replyStrs[32][32]); +int I2C_WriteRead(char argStrs[32][32], char replyStrs[32][32]); + +#endif /* _I2C_RPC_H_ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/Interfaces/QuadSpiInterface.cpp Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,107 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+#include "QuadSpiInterface.h"
+
+/**
+* @brief Constructor that accepts pin names for the QUAD SPI interface
+* @param mosi master out slave in pin name
+* @param miso master in slave out pin name
+* @param sclk serial clock pin name
+* @param cs chip select pin name
+*/
+QuadSpiInterface::QuadSpiInterface(PinName mosi, PinName miso, PinName sclk,
+ PinName cs)
+ : spi(mosi, miso, sclk), csPin(cs) {
+
+ }
+
+/**
+* @brief Transmit and recieve QUAD SPI data
+* @param tx_buf pointer to transmit byte buffer
+* @param tx_size number of bytes to transmit
+* @param rx_buf pointer to the recieve buffer
+* @param rx_size number of bytes to recieve
+* @param last flag to indicate if this is the last QUAD SPI transaction for the
+* current chip select cycle
+*/
+int QuadSpiInterface::SPI_Transmit(const uint8_t *tx_buf, uint32_t tx_size,
+ uint8_t *rx_buf, uint32_t rx_size,
+ int last) {
+ uint32_t i;
+ int result = 0;
+ int index = 0;
+ // lower chip select
+ csPin = 0;
+ // write bytes out QUAD SPI
+ spi.setQuadMode();
+ for (i = 0; i < tx_size; i++) {
+ rx_buf[index] = spi.write((int)tx_buf[i]);
+ index++;
+ }
+ // read in bytes from QUAD SPI
+ for (i = 0; i < rx_size; i++) {
+ rx_buf[index] = (uint8_t)spi.read();
+ index++;
+ }
+ // raise chip select if this is the last transaction
+ if (last) csPin = 1;
+ return result;
+}
+
+/**
+* @brief Transmit and recieve QUAD SPI data
+* @param tx_buf pointer to transmit byte buffer
+* @param tx_size number of bytes to transmit
+* @param rx_buf pointer to the recieve buffer
+* @param rx_size number of bytes to recieve
+* @param last flag to indicate if this is the last QUAD SPI transaction for the
+* current chip select cycle
+*/
+int QuadSpiInterface::SPI_Transmit4Wire(const uint8_t *tx_buf, uint32_t tx_size,
+ uint8_t *rx_buf, uint32_t rx_size,
+ int last) {
+ uint32_t i;
+ int result = 0;
+ int index = 0;
+ // lower chip select
+ csPin = 0;
+ // write bytes out Single SPI
+ spi.setSingleMode();
+ for (i = 0; i < tx_size; i++) {
+ rx_buf[index] = spi.write((int)tx_buf[i]);
+ index++;
+ }
+ // raise chip select if this is the last transaction
+ if (last) csPin = 1;
+ return result;
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/Interfaces/QuadSpiInterface.h Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,80 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+#ifndef _QUADSPIINTERFACE_H_
+#define _QUADSPIINTERFACE_H_
+
+#include "mbed.h"
+#include "QuadSpi.h"
+
+class QuadSpiInterface {
+public:
+ /**
+ * @brief Constructor that accepts pin names for the QUAD SPI interface
+ * @param mosi master out slave in pin name
+ * @param miso master in slave out pin name
+ * @param sclk serial clock pin name
+ * @param cs chip select pin name
+ */
+ QuadSpiInterface(PinName mosi, PinName miso, PinName sclk, PinName cs);
+ /**
+ * @brief Transmit and recieve QUAD SPI data
+ * @param tx_buf pointer to transmit byte buffer
+ * @param tx_size number of bytes to transmit
+ * @param rx_buf pointer to the recieve buffer
+ * @param rx_size number of bytes to recieve
+ * @param last flag to indicate if this is the last QUAD SPI transaction for
+ * the current chip select cycle
+ */
+ int SPI_Transmit(const uint8_t *tx_buf, uint32_t tx_size, uint8_t *rx_buf,
+ uint32_t rx_size, int last = 1);
+
+ /**
+ * @brief Transmit and recieve Four Wrire SPI data
+ * @param tx_buf pointer to transmit byte buffer
+ * @param tx_size number of bytes to transmit
+ * @param rx_buf pointer to the recieve buffer
+ * @param rx_size number of bytes to recieve
+ * @param last flag to indicate if this is the last QUAD SPI transaction for
+ * the current chip select cycle
+ */
+ int SPI_Transmit4Wire(const uint8_t *tx_buf, uint32_t tx_size,
+ uint8_t *rx_buf, uint32_t rx_size, int last = 1);
+
+private:
+ // QUAD SPI object
+ QuadSPI spi;
+ // chip select object
+ DigitalOut csPin;
+};
+
+#endif // _QUADSPIINTERFACE_H_
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/LoggingService/DataLoggingService.cpp Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,567 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+#include "mbed.h"
+#include "Logging.h"
+#include "Streaming.h"
+#include "RpcServer.h"
+#include "S25FS512.h"
+#include "BMP280.h"
+#include "PacketFifo.h"
+#include "DataLoggingService.h"
+#include "ServiceNonInterrupt.h"
+#include "HspLed.h"
+#include "MAX30001_helper.h"
+#include "MAX30101_helper.h"
+#include "StringInOut.h"
+#include "StringHelper.h"
+#include "Peripherals.h"
+#include "Device_Logging.h"
+
+/// BMP280 logging object reference
+extern Device_Logging *bmp280_Logging;
+/// MAX14720 instance 0 logging object reference
+extern Device_Logging *MAX30205_0_Logging;
+/// MAX14720 instance 1 logging object reference
+extern Device_Logging *MAX30205_1_Logging;
+
+#define PING_PONG_BUFFER_SIZE 512
+#define HALF_OF_PING_PONG_BUFFER_SIZE PING_PONG_BUFFER_SIZE / 2
+#define MISSION_DEFINITION_SIZE 4096
+
+eLoggingTrigger loggingTrigger;
+
+/// buffer where mission strings are stored
+char loggingMissionCmds[MISSION_DEFINITION_SIZE];
+/// This houses two 256 byte ram concatenated to act as a ping-pong
+uint8_t PingPong_SRAM[PING_PONG_BUFFER_SIZE];
+uint32_t buttonTrigger = 0;
+
+eLoggingOutput loggingOutput;
+// extern int bleStartCommand;
+bool volatile globalFlag;
+extern int highDataRate;
+static uint32_t currentPage;
+static uint32_t sramIndex;
+/// flag to indicate that sram buffer 0 is dirty and will need to be flushed
+static uint32_t sram_buffer_0_dirty;
+/// flag to indicate that sram buffer 1 is dirty and will need to be flushed
+static uint32_t sram_buffer_1_dirty;
+/// usb byte buffer for sending out a bulk transfer
+static uint8_t usb_block[64];
+/// running index used to accumulate bytes to send as a block via bulk transfer
+static uint16_t usb_block_index = 0;
+
+typedef enum {
+ eStartEvent_NULL,
+ eStartEvent_BLE,
+ eStartEvent_BUTTON,
+ eStartEvent_RPC_TO_USB,
+ eStartEvent_RPC_TO_FLASH
+} eStartEvent;
+static eStartEvent startEvent;
+
+/**
+* @brief Sets a flag to start USB logging (streaming)
+*/
+void LoggingService_StartLoggingUsb(void) {
+ loggingTrigger = eTriggerLog_RPC_USB;
+}
+
+/**
+* @brief Sets a flag to start flash logging
+*/
+void LoggingService_StartLoggingFlash(void) {
+ loggingTrigger = eTriggerLog_RPC_FLASH;
+}
+
+/**
+* @brief Checks the various logging start condition
+* @return 1 if a start condition is true, 0 if there is no start condition
+*/
+static bool _LoggingService_CheckStartCondition(void) {
+ bool buttonPressed;
+ buttonPressed = Peripherals::pushButton()->GetButtonFallState();
+
+ // default not logging USB or flash
+ loggingOutput = eLogToNothing;
+ startEvent = eStartEvent_NULL;
+ if (buttonPressed) {
+ Peripherals::pushButton()->clearButtonFallState();
+ // a falling state has been detected... wait for a fraction of a second and
+ // re-read the pin
+ // only start datalogging if the pin was released within this wait time
+ wait(0.75f);
+ int buttonRead = Peripherals::pushButton()->Read();
+ // if after a period of time the button is still pressed then get out
+ if (buttonRead == 0)
+ return 0;
+ buttonTrigger = 0;
+
+ loggingTrigger = eTriggerLog_BUTTON;
+ loggingOutput = eLogToFlash;
+ startEvent = eStartEvent_BUTTON;
+ return true;
+ }
+ if (loggingTrigger == eTriggerLog_RPC_FLASH) {
+ loggingOutput = eLogToFlash;
+ startEvent = eStartEvent_RPC_TO_FLASH;
+ return true;
+ }
+ if (Peripherals::hspBLE()->getStartDataLogging()) {
+ loggingTrigger = eTriggerLog_BLE;
+ loggingOutput = eLogToFlash;
+ startEvent = eStartEvent_BLE;
+ return true;
+ }
+ // check if start is from RPC call for USB streaming
+ if (loggingTrigger == eTriggerLog_RPC_USB) {
+ loggingOutput = eLogtoUsb;
+ startEvent = eStartEvent_RPC_TO_USB;
+ return true;
+ }
+ return false;
+}
+
+/**
+* @brief Read the mission string from flash into a buffer
+* @return false if a mission was not defined, true if mission was read and
+* buffered
+*/
+static bool _LoggingService_ReadMissionFromFlash(void) {
+ // get mission from flash
+ Logging_ReadMissionFromFlash((uint8_t *)loggingMissionCmds);
+ if (Logging_IsMissionDefined((uint8_t *)loggingMissionCmds) == 0) {
+ return false;
+ }
+ printf(loggingMissionCmds);
+ fflush(stdout);
+ RPC_ProcessCmds(loggingMissionCmds);
+ return true;
+}
+
+/**
+* @brief Process a RPC command that is pointed to.
+* @param cmd RPC string to process
+*/
+void ProcessCmd(char *cmd) {
+ char cmd_[256];
+ char reply[512];
+ strcpy(cmd_, cmd);
+ RPC_call(cmd_, reply);
+}
+
+/**
+* @brief Buffer sensor fifo data in ram buffers, when a ram buffer is full (a
+* flash page worth of data is accumulated) then flash that buffer.
+* A buffer ping pong method is used so that one buffer can be flashing as
+* the other buffer fills with sensor fifo data.
+* @param fifoData Sensor data taken from the fifo to be stored into flash
+*/
+static void _LoggingServer_OutputToFlash(uint32_t fifoData) {
+ uint32_t index;
+ char str[128];
+ uint8_t *ptr;
+ //
+ // Log To Flash
+ //
+ // i.e. there is data, read one 32-bit size data at a time.
+ // put the fifo data into the ping-pong SRAM
+ PingPong_SRAM[sramIndex++] = fifoData & 0xFF; // LSByte goes into index N
+ PingPong_SRAM[sramIndex++] = (fifoData >> 8) & 0xFF;
+ PingPong_SRAM[sramIndex++] = (fifoData >> 16) & 0xFF;
+ PingPong_SRAM[sramIndex++] = (fifoData >> 24) & 0xFF; // MSByte goes into index N+3
+
+ // flag this buffer as dirty
+ if (sramIndex <= 256)
+ sram_buffer_0_dirty = 1;
+ else
+ sram_buffer_1_dirty = 1;
+
+ if (sramIndex == 256 ||
+ sramIndex == 512) // Either Ping SRAM or Pong SRAM location is full
+ { // therefore write to Flash
+
+ index = sramIndex - 256;
+ ptr = &PingPong_SRAM[index];
+ sprintf(str, "currentPage=%d", currentPage);
+ Peripherals::s25FS512()->writePage_Helper(currentPage, ptr, 0);
+
+ // this page is no longer dirty
+ if (index == 0)
+ sram_buffer_0_dirty = 0;
+ if (index == 256)
+ sram_buffer_1_dirty = 0;
+
+ currentPage++;
+ }
+ sramIndex = sramIndex % 512; // Wrap around the index
+}
+
+/**
+* @brief If flash ram buffers are flagged as dirty, flush to flash
+*/
+static void _LoggingServer_WriteDirtySramBufferToFlash(void) {
+ uint8_t *ptr = PingPong_SRAM;
+ if (sram_buffer_0_dirty == 0 && sram_buffer_1_dirty == 0)
+ return;
+ if (sram_buffer_0_dirty == 1) {
+ ptr += 0;
+ }
+ if (sram_buffer_1_dirty == 1) {
+ ptr += 256;
+ }
+ printf("_LoggingServer_WriteDirtySramBufferToFlash:%d,%d\n",
+ sram_buffer_0_dirty, sram_buffer_1_dirty);
+ fflush(stdout);
+ // s25fs512_WritePage_Helper(currentPage, ptr, 0);
+ Peripherals::s25FS512()->writePage_Helper(currentPage, ptr, 0);
+}
+
+/**
+* @brief Initialize the USB block running index
+* @param fifoData Sensor data taken from the fifo to be sent out USB
+*/
+static void _LoggingServer_OutputToCdcAcm(uint32_t fifoData) {
+ uint8_t *ptr;
+ uint8_t str[16];
+ sprintf((char *)str, "%X ", fifoData);
+ ptr = str;
+ usb_block_index = 0;
+ while (*ptr != 0) {
+ usb_block[usb_block_index] = *ptr;
+ ptr++;
+ usb_block_index++;
+ }
+ Peripherals::usbSerial()->writeBlock(usb_block, usb_block_index);
+}
+
+/**
+* @brief Initialize the USB block running index
+*/
+static void _LoggingServer_OutputToCdcAcm_Start(void) { usb_block_index = 0; }
+
+/**
+* @brief Buffer up fifoData from sensors, do a USB block transfer if buffer is
+* full
+* @param fifoData Sensor data taken from the fifo to be send out USB within a
+* bulk block transfer
+* @return Return the success status of the writeblock operation
+*/
+static bool _LoggingServer_OutputToCdcAcm_Block(uint32_t fifoData) {
+ uint8_t str[64];
+ uint8_t *ptr;
+ bool result;
+ //
+ // Log to CDCACM
+ //
+ result = true;
+ sprintf((char *)str, "%X ", fifoData);
+ ptr = str;
+ while (*ptr != 0) {
+ usb_block[usb_block_index] = *ptr;
+ ptr++;
+ usb_block_index++;
+ if (usb_block_index >= 64) {
+ result = Peripherals::usbSerial()->writeBlock(usb_block, 64);
+ usb_block_index = 0;
+ }
+ }
+ return result;
+}
+
+/**
+* @brief Output a full USB block via bulk transfer
+*/
+static void _LoggingServer_OutputToCdcAcm_End(void) {
+ if (usb_block_index == 0)
+ return;
+ Peripherals::usbSerial()->writeBlock(usb_block, usb_block_index - 1);
+}
+
+/**
+* @brief Blink LED pattern that indicates that the flash end boundary has been
+* reached
+*/
+static void BlinkEndOfDatalogging(void) {
+ // blink to signal end of logging
+ Peripherals::hspLed()->pattern(0x55555555, 20);
+ wait(2);
+}
+
+/**
+* @brief Reads the first data page of flash, if all FF's then the page is empty
+* @return 1 if the flash is empty as indicated by the first data page of the
+* flash, 0 if not
+*/
+int isFlashEmpty(void) {
+ int i;
+ uint8_t data[256];
+ int firstDataPage = Logging_GetLoggingStartPage();
+ Peripherals::s25FS512()->readPages_Helper(firstDataPage, firstDataPage, data, 0);
+ for (i = 0; i < 256; i++) {
+ if (data[i] != 0xFF)
+ return 0;
+ }
+ return 1;
+}
+
+/**
+* @brief Blink LED pattern that indicates that the flash is not empty and a new
+* flash logging session can not occur
+*/
+void BlinkFlashNotEmpty(void) {
+ Peripherals::hspLed()->pattern(0x55555555, 20);
+ wait(1);
+}
+
+void ExecuteDefaultMission(void) {
+ ProcessCmd("/MAX30001/CAL_InitStart 01 01 01 03 7FF 00");
+ ProcessCmd("/MAX30001/ECG_InitStart 01 01 01 00 02 03 1F 0 00 00 01");
+ ProcessCmd("/MAX30001/RtoR_InitStart 01 03 0F 00 03 01 00 00 01");
+ ProcessCmd("/MAX30001/Rbias_FMSTR_Init 01 02 01 01 00");
+ ProcessCmd("/LIS2DH/InitStart 02 01");
+}
+
+void LoggingService_Init(void) { loggingTrigger = eTriggerLog_NULL; }
+
+/**
+* @brief This routine checks to see if a USB or flash logging action needs to be taken
+* The routine checks for a start condition via button press, USB command, or BLE command
+* Once one of these start conditions is present, the logging begins until stopped or memory is full
+* @return 1 if successful, 0 if error or logging was aborted and no logging occurred
+*/
+uint8_t LoggingService_ServiceRoutine(void) {
+ uint32_t fifoData;
+ uint32_t endPage;
+ USBSerial *usbSerial = Peripherals::usbSerial();
+ // BMP280 *bmp280 = Peripherals::bmp280();
+ bool buttonPressed;
+ int packetBurstCount = 0;
+ HspLed *hspLed = Peripherals::hspLed();
+
+ sramIndex = 0;
+ // only start logging if conditions exist
+
+ if (_LoggingService_CheckStartCondition() == false) return 0;
+ printf("Begin Logging...");
+ if (startEvent == eStartEvent_NULL) printf("eStartEvent_NULL...");
+ if (startEvent == eStartEvent_BLE) printf("eStartEvent_BLE...");
+ if (startEvent == eStartEvent_BUTTON) printf("eStartEvent_BUTTON...");
+ if (startEvent == eStartEvent_RPC_TO_USB) printf("eStartEvent_RPC_TO_USB...");
+ if (startEvent == eStartEvent_RPC_TO_FLASH) printf("eStartEvent_RPC_TO_FLASH...");
+ fflush(stdout);
+
+ // start logging stuttered blink pattern
+ hspLed->pattern(0xA0F3813, 20);
+
+ if (startEvent == eStartEvent_RPC_TO_FLASH ||
+ startEvent == eStartEvent_BUTTON) {
+ // check to see if datalog already in flash... abort and force user to erase
+ // flash if needed
+ if (loggingOutput == eLogToFlash) {
+ if (isFlashEmpty() == 0) {
+ Logging_SetStart(false);
+ // bleStartCommand = 0x00;
+ BlinkFlashNotEmpty();
+ hspLed->blink(1000);
+ printf("Abort Logging, flash log exists. ");
+ fflush(stdout);
+ return 0;
+ }
+ }
+ }
+
+ if (startEvent == eStartEvent_BLE) {
+ // check for mission in flash
+ if (_LoggingService_ReadMissionFromFlash() == false) {
+ // if there is no mission in flash then do a default mission for the sake
+ // of ble Android app working "out-of-the-box" and stream RtoR and Accel
+ printf("No Mission in Flash...ExecuteDefaultMission...");
+ fflush(stdout);
+ ExecuteDefaultMission();
+ // do not log this data
+ loggingOutput = eLogToNothing;
+ } else {
+ // there is a mission in flash check if there is already logged data
+ if (isFlashEmpty() == 0) {
+ // just do default mission
+ printf("Logged Data Detected...ExecuteDefaultMission...");
+ fflush(stdout);
+ ExecuteDefaultMission();
+ // do not log this data
+ loggingOutput = eLogToNothing;
+ } else {
+ // flag that we are logging to flash
+ loggingOutput = eLogToFlash;
+ }
+ }
+ }
+
+ // if we are logging to flash then read mission in flash
+ if (loggingOutput == eLogToFlash) {
+ if (_LoggingService_ReadMissionFromFlash() ==
+ false) { // if there is no mission in flash then get out
+ Logging_SetStart(false);
+ Peripherals::hspLed()->pattern(0xC3C3C3C3, 20);
+ wait(2);
+ printf("Abort Logging, Mission does not exist. ");
+ fflush(stdout);
+ return 0;
+ }
+ currentPage = Logging_GetLoggingStartPage();
+ endPage = Logging_GetLoggingEndPage();
+ }
+
+ MAX30001_Helper_SetupInterrupts();
+ if (MAX30001_AnyStreamingSet() == 1) {
+ MAX30001_Helper_StartSync();
+ }
+
+ SetDataLoggingStream(TRUE);
+ ServiceNonInterrupt_Init();
+ ServiceNonInterrupt_StartTimer();
+
+ while (usbSerial->readable()) {
+ usbSerial->_getc();
+ }
+ fifo_clear(GetUSBIncomingFifo()); // clear USB serial incoming fifo
+ fifo_clear(GetStreamOutFifo());
+
+ sram_buffer_0_dirty = 0;
+ sram_buffer_1_dirty = 0;
+
+
+ if (loggingOutput == eLogToNothing) printf("eLogToNothing..."); fflush(stdout);
+ if (loggingOutput == eLogToFlash) printf("eLogToFlash..."); fflush(stdout);
+ if (loggingOutput == eLogtoUsb) printf("eLogtoUsb..."); fflush(stdout);
+ printf("highDataRate=%d...",highDataRate); fflush(stdout);
+
+
+ Peripherals::timestampTimer()->reset();
+ Peripherals::timestampTimer()->start();
+
+ _LoggingServer_OutputToCdcAcm_Start();
+ while (1) {
+ if (loggingOutput == eLogToFlash) {
+ // check if we are at the end of flash
+ if (currentPage >= endPage) {
+ BlinkEndOfDatalogging(); // blink for 3 seconds to signal end of logging
+ break;
+ }
+ }
+
+ if (startEvent == eStartEvent_BUTTON) {
+ buttonPressed = Peripherals::pushButton()->GetButtonFallState();
+ if (buttonPressed) {
+ Peripherals::pushButton()->clearButtonFallState();
+ // if there is a dirty sram buffer... flush it to flash
+ _LoggingServer_WriteDirtySramBufferToFlash();
+ BlinkEndOfDatalogging(); // blink for 3 seconds to signal end of logging
+ break;
+ }
+ }
+
+ if (loggingTrigger == eTriggerLog_BLE) {
+ if (Peripherals::hspBLE()->getStartDataLogging() == false) {
+ // if there is a dirty sram buffer... flush it to flash
+ _LoggingServer_WriteDirtySramBufferToFlash();
+ BlinkEndOfDatalogging(); // blink for 3 seconds to signal end of logging
+ break;
+ }
+ }
+
+ if (startEvent == eStartEvent_RPC_TO_USB ||
+ startEvent == eStartEvent_RPC_TO_FLASH) {
+ if (usbSerial->available()) {
+ if (loggingOutput == eLogToFlash) {
+ _LoggingServer_WriteDirtySramBufferToFlash();
+ }
+ wait(0.2f);
+ while (usbSerial->available()) {
+ usbSerial->_getc();
+ }
+ fifo_clear(GetUSBIncomingFifo()); // clear USB serial incoming fifo
+ fifo_clear(GetStreamOutFifo());
+ break;
+ }
+ }
+
+ // check to see if data is available
+ packetBurstCount = 0;
+ while (PacketFifo_Empty() == 0) {
+ if (packetBurstCount >= 100)
+ break;
+ fifoData = PacketFifo_GetUint32();
+ if (loggingOutput == eLogToFlash) {
+ _LoggingServer_OutputToFlash(fifoData);
+ }
+ if (loggingOutput == eLogtoUsb) {
+ if (highDataRate == 0)
+ _LoggingServer_OutputToCdcAcm(fifoData);
+ else
+ _LoggingServer_OutputToCdcAcm_Block(fifoData);
+ }
+ packetBurstCount++;
+ }
+
+ if (PacketFifo_Empty() != 0) {
+ Peripherals::ble()->waitForEvent();
+ }
+ ServiceNonInterrupt_BMP280(bmp280_Logging);
+ ServiceNonInterrupt_MAX30205(MAX30205_0_Logging,
+ Peripherals::max30205_top(),
+ PACKET_MAX30205_TEMP_TOP);
+ ServiceNonInterrupt_MAX30205(MAX30205_1_Logging,
+ Peripherals::max30205_bottom(),
+ PACKET_MAX30205_TEMP_BOTTOM);
+ }
+ _LoggingServer_OutputToCdcAcm_End();
+ printf("End Logging.\n");
+ fflush(stdout);
+
+ bmp280_Logging->stop();
+ MAX30205_0_Logging->stop();
+ MAX30205_1_Logging->stop();
+ MAX30001_Helper_Stop(); // if any MAX30001 streams have been started, stop
+ // them
+ MAX30101_Helper_Stop(); // if any MAX30101 streams have been started, stop
+ // them
+ Peripherals::lis2dh()->stop();
+ SetDataLoggingStream(FALSE);
+ Peripherals::timestampTimer()->stop();
+ hspLed->blink(1000);
+ // default to non-usb packet speed optimizing
+ highDataRate = 0;
+ loggingTrigger = eTriggerLog_NULL;
+ return 1;
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/LoggingService/DataLoggingService.h Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,84 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+#ifndef _LOGGINGSERVICE_H_
+#define _LOGGINGSERVICE_H_
+
+#include "mbed.h"
+
+/// types of logging
+typedef enum {
+ /// do not log
+ eLogToNothing,
+ /// log to USB
+ eLogtoUsb,
+ /// Log to external flash memory
+ eLogToFlash
+} eLoggingOutput;
+
+/// types of logging
+typedef enum {
+ eTriggerLog_NULL,
+ eTriggerLog_RPC_USB,
+ eTriggerLog_RPC_FLASH,
+ eTriggerLog_BUTTON,
+ eTriggerLog_BLE,
+} eLoggingTrigger;
+
+/// extern that indicates the hardware button on the HSP was pressed
+extern uint32_t buttonTrigger;
+
+void LoggingService_Init(void);
+
+/**
+* @brief This routine checks to see if a USB or flash logging action needs to be
+* taken
+* The routine checks for a start condition via button press, USB
+* command, or BLE command
+* Once one of these start conditions is present, the logging begins
+* until stopped or memory is full
+* @return 1 if successful, 0 if error or logging was aborted and no logging
+* occurred
+*/
+uint8_t LoggingService_ServiceRoutine(void);
+/**
+* @brief This is called via one of the RPC USB functions to set start conditons
+* to start streaming USB
+*/
+void LoggingService_StartLoggingUsb(void);
+/**
+* @brief This is called via one of the RPC USB functions to set start conditons
+* to start logging to flash
+*/
+void LoggingService_StartLoggingFlash(void);
+
+#endif /* _LOGGINGSERVICE_H_ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/LoggingService/Device_Logging.cpp Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,72 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+
+#include "Device_Logging.h"
+
+/**
+* @brief Check if logging is enabled for this device
+*/
+int Device_Logging::isLoggingEnabled(void) { return enabled; }
+
+/**
+* @brief Returns the sample rate for the device, rate is in seconds
+*/
+int Device_Logging::getLoggingSampleRate(void) { return sampleRate; }
+
+/**
+* @brief Initialize the sampling rate for the device
+* @param sampleRate Rate to log device output in seconds
+*/
+void Device_Logging::initStart(int sampleRate) {
+ this->sampleRate = sampleRate;
+ enabled = 1;
+}
+
+/**
+* @brief Disables further datalog and streaming sampling for the device
+* @param time Time for next sample in seconds, time is relative to a timer
+*/
+void Device_Logging::stop(void) { enabled = 0; }
+
+/**
+* @brief Gets a value that represents when device needs to be sampled again,
+* used for datalogging and usb streaming
+*/
+int Device_Logging::getNextSampleTime(void) { return nextSampleTime; }
+
+/**
+* @brief Sets a value that represents when device needs to be sampled again,
+* used for datalogging and usb streaming
+* @param time Time for next sample in seconds, time is relative to a timer
+*/
+void Device_Logging::setNextSampleTime(int time) { nextSampleTime = time; }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/LoggingService/Device_Logging.h Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,83 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+#ifndef _DEVICE_LOGGING_H_
+#define _DEVICE_LOGGING_H_
+
+#include "mbed.h"
+
+/**
+* @brief Class that is used to store device logging parameters when logging to
+* flash or streaming usb
+*/
+class Device_Logging {
+public:
+ /**
+ * @brief Check if logging is enabled for this device
+ */
+ int isLoggingEnabled(void);
+ /**
+ * @brief Returns the sample rate for the device, rate is in seconds
+ */
+ int getLoggingSampleRate(void);
+ /**
+ * @brief Initialize the sampling rate for the device
+ * @param sampleRate Rate to log device output in seconds
+ */
+ void initStart(int sampleRate);
+ /**
+ * @brief Gets a value that represents when device needs to be sampled again,
+ * used for datalogging and usb streaming
+ */
+ int getNextSampleTime(void);
+ /**
+ * @brief Sets a value that represents when device needs to be sampled again,
+ * used for datalogging and usb streaming
+ * @param time Time for next sample in seconds, time is relative to a timer
+ */
+ void setNextSampleTime(int time);
+ /**
+ * @brief Disables further datalog and streaming sampling for the device
+ * @param time Time for next sample in seconds, time is relative to a timer
+ */
+ void stop(void);
+
+private:
+ /// The sample rate in seconds
+ int sampleRate;
+ /// If logging is enabled or not
+ int enabled;
+ /// Bookkeeping var to keep track of the next sample time
+ int nextSampleTime;
+};
+
+#endif /* _DEVICE_LOGGING_H_ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/LoggingService/Logging.cpp Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,105 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+#include "mbed.h"
+#include "RpcServer.h"
+#include "Logging.h"
+#include "S25FS512.h"
+#include "Peripherals.h"
+
+/// length of flash page as dictated by the device
+#define LENGTH_OF_FLASH_PAGE 256 // length of flash page in bytes
+/// size in bytes of the external flash device on the HSP platform
+#define SIZE_OF_EXTERNAL_FLASH \
+ (16777216 / 2) // length of external flash in bytes
+/// start page of where the mission is defined
+#define MISSION_DEFINITION_START_PAGE 0x00
+/// end page of the mission
+#define MISSION_DEFINITION_END_PAGE 0x0F
+/// page of where the logging data starts
+#define LOGGING_START_PAGE 0x12
+/// the last logging page
+#define LOGGING_END_PAGE (SIZE_OF_EXTERNAL_FLASH / LENGTH_OF_FLASH_PAGE)
+
+/// static flag to know if logging was started via RPC
+static bool startLoggingViaRpc = false;
+
+/**
+* @brief This will read the mission location and if there is something valid,
+* then run the Logging_ProcessMissionCmds()
+* @param cmdBuffer buffer
+*/
+uint32_t Logging_IsMissionDefined(uint8_t *cmdBuffer) {
+ uint32_t valid = 1;
+ if ((cmdBuffer[0] == 0xFF) || (cmdBuffer[0] == 0x0))
+ valid = 0;
+ return valid;
+}
+
+/**
+* @brief Read the mission from flash and place in buffer
+* @param buffer pointer to byte array that will contain the read results
+*/
+int8_t Logging_ReadMissionFromFlash(uint8_t *buffer) {
+ return Peripherals::s25FS512()->readPages_Helper(
+ MISSION_DEFINITION_START_PAGE, MISSION_DEFINITION_END_PAGE, buffer, 0);
+}
+
+//******************************************************************************
+// return the page where mission is defined, Mission specific
+uint32_t Logging_GetMissionStartPage(void) {
+ return MISSION_DEFINITION_START_PAGE;
+}
+
+//******************************************************************************
+// return the page where the mission definition ends, Mission specific
+uint32_t Logging_GetMissionEndPage(void) { return MISSION_DEFINITION_END_PAGE; }
+
+//******************************************************************************
+// Returns the location where the Writing can start from, for data logging...
+uint32_t Logging_GetLoggingStartPage(void) { return LOGGING_START_PAGE; }
+
+//******************************************************************************
+// Returns the end location available where the Flash ends essentially.... for
+// data logging.
+uint32_t Logging_GetLoggingEndPage(void) { return LOGGING_END_PAGE; }
+
+//******************************************************************************
+void Logging_SetStart(bool state) { startLoggingViaRpc = state; }
+
+//******************************************************************************
+bool Logging_GetStart(void) { return startLoggingViaRpc; }
+
+//******************************************************************************
+// for debugging... always say that usb is not connected... for easy bench
+// testing
+uint32_t Usb_IsConnected(void) { return 0; }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/HSP/LoggingService/Logging.h Tue Oct 25 15:22:11 2016 +0000 @@ -0,0 +1,35 @@ +#ifndef _LOGGING_H_ +#define _LOGGING_H_ + +#include "mbed.h" + +/** +* @brief This will read the mission location and if there is something valid, +* then run the Logging_ProcessMissionCmds() +* @param cmdBuffer buffer +*/ +uint32_t Logging_IsMissionDefined(uint8_t *cmdBuffer); + +int8_t Logging_ReadMissionFromFlash(uint8_t *buffer); + +// return the page where mission is defined, Mission specific +uint32_t Logging_GetMissionStartPage(void); + +// return the page where the mission definition ends, Mission specific +uint32_t Logging_GetMissionEndPage(void); + +// Returns the location where the Writing can start from, for data logging... +uint32_t Logging_GetLoggingStartPage(void); + +// Returns the end location available where the Flash ends essentially.... for +// data logging. +uint32_t Logging_GetLoggingEndPage(void); + +// returns one if the usb is connected, zero if not +uint32_t Usb_IsConnected(void); + +void Logging_SetStart(bool state); + +bool Logging_GetStart(void); + +#endif /* _LOGGING_H_ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/LoggingService/Logging_RPC.cpp Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,279 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ ******************************************************************************
+ */
+#include "StringHelper.h"
+#include <stdint.h>
+#include "Streaming.h"
+#include "StringInOut.h"
+#include "DataLoggingService.h"
+#include "Peripherals.h"
+#include "Logging.h"
+
+extern char loggingMissionCmds[4096];
+uint32_t missionCmdIndex;
+
+ //******************************************************************************
+ int Logging_RPC_StartMissionDefine(char argStrs[32][32],
+ char replyStrs[32][32]) {
+ uint32_t i;
+ uint32_t reply[1];
+
+ // reset the missionCmdIndex to the beginning of the cmd buffer
+ missionCmdIndex = 0;
+ // clear the mission command buffer, fill with zeros
+ for (i = 0; i < sizeof(loggingMissionCmds); i++) {
+ loggingMissionCmds[i] = 0;
+ }
+
+ reply[0] = 0x80;
+ FormatReply32(reply, sizeof(reply) / sizeof(uint32_t), replyStrs);
+ return 0;
+}
+
+//******************************************************************************
+int Logging_RPC_AppendMissionCmd(char argStrs[32][32], char replyStrs[32][32]) {
+ uint32_t reply[1];
+ char *strPtr;
+ uint32_t count = 0;
+ uint8_t result = 0x80;
+ // append the string to the mission cmd log
+ strPtr = argStrs[0];
+ while (*strPtr != 0) {
+ loggingMissionCmds[missionCmdIndex] = *strPtr;
+ missionCmdIndex++;
+ strPtr++;
+ // do not overrun buffer
+ if (missionCmdIndex > (sizeof(loggingMissionCmds) - 2)) {
+ result = 0xFF;
+ break;
+ }
+ count++;
+ // do not read more than max count in incoming string
+ if (count > (32 * 32)) {
+ result = 0xFF;
+ break;
+ }
+ }
+ if (result != 0x80) {
+ reply[0] = 0xFF;
+ FormatReply32(reply, sizeof(reply) / sizeof(uint32_t), replyStrs);
+ return 0;
+ }
+ // add cr/lf to the end of this cmd string
+ loggingMissionCmds[missionCmdIndex++] = 13;
+ loggingMissionCmds[missionCmdIndex++] = 10;
+
+ reply[0] = 0x80;
+ FormatReply32(reply, sizeof(reply) / sizeof(uint32_t), replyStrs);
+ return 0;
+}
+
+//******************************************************************************
+int Logging_RPC_EndMissionDefine(char argStrs[32][32], char replyStrs[32][32]) {
+ uint32_t reply[1];
+ reply[0] = 0x80;
+ FormatReply32(reply, sizeof(reply) / sizeof(uint32_t), replyStrs);
+ return 0;
+}
+
+//******************************************************************************
+int Logging_RPC_WriteMission(char argStrs[32][32], char replyStrs[32][32]) {
+ uint8_t page;
+ char *ptr;
+ uint32_t reply[1];
+
+ Peripherals::s25FS512()->parameterSectorErase_Helper(0x0);
+ ptr = loggingMissionCmds;
+ for (page = 0; page < 16; page++) {
+ Peripherals::s25FS512()->writePage_Helper(page, (uint8_t *)ptr, 0);
+ ptr += 256;
+ }
+
+ reply[0] = 0x80;
+ FormatReply32(reply, sizeof(reply) / sizeof(uint32_t), replyStrs);
+ return 0;
+}
+
+//******************************************************************************
+int Logging_RPC_ReadMission(char argStrs[32][32], char replyStrs[32][32]) {
+ char *ptr;
+ uint32_t i;
+ // read sector 0
+ ptr = loggingMissionCmds;
+ for (i = 0; i < 16; i++) {
+ Peripherals::s25FS512()->readPages_Helper(i, i, (uint8_t *)ptr, 0);
+ ptr += 256;
+ }
+ // strip header by shifting payload left
+ ptr = loggingMissionCmds;
+ for (i = 0; i < sizeof(loggingMissionCmds); i++) {
+ if (*ptr == 13) {
+ *ptr = ':';
+ } else if (*ptr == 10) {
+ *ptr = ' ';
+ }
+ ptr++;
+ }
+ if (loggingMissionCmds[0] == 0xFF || loggingMissionCmds[0] == 0x0) {
+ sprintf(loggingMissionCmds, "%s", "null ");
+ }
+ // send it out via uart
+ putStr(loggingMissionCmds);
+ replyStrs[0][0] = 0;
+ return 0;
+}
+
+//******************************************************************************
+int Logging_RPC_EraseMission(char argStrs[32][32], char replyStrs[32][32]) {
+ uint32_t reply[1];
+ Peripherals::s25FS512()->parameterSectorErase_Helper(0x0);
+ reply[0] = 0x80;
+ FormatReply32(reply, sizeof(reply) / sizeof(uint32_t), replyStrs);
+ return 0;
+}
+
+#define SECTOR_SIZE_256K 0x10000
+#define PAGE_INC_256K 0x400
+#define SECTOR_SIZE_4K 0x1000
+#define PAGE_INC_4K 0x10
+#define TOTAL_SECTOR_NUMBER 263
+
+//******************************************************************************
+int Logging_EraseWrittenSectors(char argStrs[32][32], char replyStrs[32][32]) {
+ uint32_t reply[1];
+ uint8_t data[512];
+ uint32_t address;
+ uint32_t pageNumber;
+ uint32_t pageEmpty;
+ uint32_t currentSector;
+
+ pageNumber = PAGE_INC_4K;
+ address = SECTOR_SIZE_4K;
+ currentSector = 0;
+ printf("Logging_EraseWrittenSectors ");
+ fflush(stdout);
+ printf("pageNumber %d 0x%X ", pageNumber, pageNumber);
+ fflush(stdout);
+ printf("SECTOR_SIZE_4K %d 0x%X ...", SECTOR_SIZE_4K, SECTOR_SIZE_4K);
+ fflush(stdout);
+ // always erase this sector... the first part is used for the mission resume
+ // table
+ Peripherals::s25FS512()->sectorErase_Helper(address);
+ address += SECTOR_SIZE_4K;
+ while (currentSector < TOTAL_SECTOR_NUMBER) {
+ // sample the page
+ pageNumber = address >> 8;
+ Peripherals::s25FS512()->readPages_Helper(pageNumber, pageNumber, data, 0);
+ pageEmpty = Peripherals::s25FS512()->isPageEmpty(data);
+ if (pageEmpty == 0) {
+ Peripherals::s25FS512()->sectorErase_Helper(address);
+ } else {
+ // stop processing... all of the sectors from here on out should be empty
+ // printf("Logging_EraseWrittenSectors break "); fflush(stdout);
+ // break;
+ }
+ currentSector++;
+ if (currentSector < 8) {
+ address += SECTOR_SIZE_4K;
+ }
+ if (currentSector == 8) {
+ address = SECTOR_SIZE_256K;
+ }
+ if (currentSector > 8) {
+ address += SECTOR_SIZE_256K;
+ }
+ }
+ reply[0] = 0x80;
+ FormatReply32(reply, sizeof(reply) / sizeof(uint32_t), replyStrs);
+ printf("Logging_EraseWrittenSectors done. \n");
+ fflush(stdout);
+ return 0;
+}
+
+//******************************************************************************
+int Logging_Start(char argStrs[32][32], char replyStrs[32][32]) {
+ uint32_t reply[1];
+ Logging_SetStart(true);
+ reply[0] = 0x80; // indicate success
+ FormatReply32(reply, sizeof(reply) / sizeof(uint32_t), replyStrs);
+ return 0;
+}
+
+//******************************************************************************
+int Logging_GetLastWrittenPage(char argStrs[32][32], char replyStrs[32][32]) {
+ uint32_t reply[1];
+
+ uint32_t page;
+ uint32_t lastPage;
+ uint32_t pageEmpty;
+ uint8_t data[512];
+
+ printf("Logging_GetLastWrittenPage ");
+ fflush(stdout);
+ lastPage = Logging_GetLoggingEndPage();
+ for (page = 2; page <= lastPage; page++) {
+ // Peripherals::serial()->printf("checking page %d ",page); fflush(stdout);
+ // sample the page
+ Peripherals::s25FS512()->readPages_Helper(page, page, data, 0);
+ pageEmpty = Peripherals::s25FS512()->isPageEmpty(data);
+ if (pageEmpty != 0) {
+ break;
+ }
+ }
+ if (page > lastPage)
+ page = lastPage;
+ printf("last page %d, 0x%X ", page, page);
+ fflush(stdout);
+ reply[0] = page;
+ FormatReply32(reply, sizeof(reply) / sizeof(uint32_t), replyStrs);
+ return 0;
+}
+
+extern int highDataRate;
+//******************************************************************************
+int Logging_StartLoggingUsb(char argStrs[32][32], char replyStrs[32][32]) {
+ uint32_t reply[1];
+ // highDataRate = 0;
+ LoggingService_StartLoggingUsb();
+ reply[0] = 0x80;
+ FormatReply32(reply, sizeof(reply) / sizeof(uint32_t), replyStrs);
+ return 0;
+}
+//******************************************************************************
+int Logging_StartLoggingFlash(char argStrs[32][32], char replyStrs[32][32]) {
+ uint32_t reply[1];
+ // highDataRate = 0;
+ LoggingService_StartLoggingFlash();
+ reply[0] = 0x80;
+ FormatReply32(reply, sizeof(reply) / sizeof(uint32_t), replyStrs);
+ return 0;
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/HSP/LoggingService/Logging_RPC.h Tue Oct 25 15:22:11 2016 +0000 @@ -0,0 +1,55 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ +#ifndef _LOGGING_H_ +#define _LOGGING_H_ + +int Logging_RPC_StartMissionDefine(char argStrs[32][32], char replyStrs[32][32]); +int Logging_RPC_AppendMissionCmd(char argStrs[32][32], char replyStrs[32][32]); +int Logging_RPC_EndMissionDefine(char argStrs[32][32], char replyStrs[32][32]); +int Logging_RPC_WriteMission(char argStrs[32][32], char replyStrs[32][32]); +int Logging_RPC_ReadMission(char argStrs[32][32], char replyStrs[32][32]); +int Logging_RPC_EraseMission(char argStrs[32][32], char replyStrs[32][32]); +int Logging_RPC_TestMission(char argStrs[32][32], char replyStrs[32][32]); +int Logging_RPC_TestWriteLog(char argStrs[32][32], char replyStrs[32][32]); +int Logging_RPC_TestReadLog(char argStrs[32][32], char replyStrs[32][32]); +int Logging_RPC_TestBulkErase(char argStrs[32][32], char replyStrs[32][32]); +int Logging_RPC_TestSectorsErase(char argStrs[32][32], char replyStrs[32][32]); +int Logging_RPC_TestReadPage(char argStrs[32][32], char replyStrs[32][32]); +int Logging_RPC_TestWritePage(char argStrs[32][32], char replyStrs[32][32]); +int Logging_EraseWrittenSectors(char argStrs[32][32], char replyStrs[32][32]); +int Logging_StartLoggingUsb(char argStrs[32][32], char replyStrs[32][32]); +int Logging_StartLoggingFlash(char argStrs[32][32], char replyStrs[32][32]); +int Logging_GetLastWrittenPage(char argStrs[32][32], char replyStrs[32][32]); +int Logging_Start(char argStrs[32][32], char replyStrs[32][32]); + +#endif /* _LOGGING_H_ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/LoggingService/ServiceNonInterrupt.cpp Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,142 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+#include "ServiceNonInterrupt.h"
+#include "Streaming.h"
+#include "BMP280.h"
+#include "PacketFifo.h"
+#include "MAX30205.h"
+#include "Stream.h"
+#include "BMP280.h"
+#include "PacketFifo.h"
+#include "Peripherals.h"
+#include "Device_Logging.h"
+
+/// timer used for devices that do not have interrupt capability
+static Timer nonInterruptTimer;
+
+/// reference to logging object for the BMP280
+extern Device_Logging *bmp280_Logging;
+/// reference to logging object for the MAX30205 (instance 0)
+extern Device_Logging *MAX30205_0_Logging;
+/// reference to logging object for the MAX30205 (instance 1)
+extern Device_Logging *MAX30205_1_Logging;
+
+/**
+* @brief Initialize the book keeping variables for non interrupt devices
+*/
+void ServiceNonInterrupt_Init(void) {
+ // clear out the next time member in the device logging class
+ // this is so that the devices are sampled the very first go-around
+ bmp280_Logging->setNextSampleTime(0);
+ MAX30205_0_Logging->setNextSampleTime(0);
+ MAX30205_1_Logging->setNextSampleTime(0);
+}
+
+/**
+* @brief Stop the 1 second timer
+*/
+void ServiceNonInterrupt_StartTimer(void) {
+ nonInterruptTimer.start();
+ nonInterruptTimer.reset();
+}
+
+/**
+* @brief Stop the 1 second timer
+*/
+void ServiceNonInterrupt_StopTimer(void) { nonInterruptTimer.stop(); }
+
+/**
+* @brief Get the current count of the timer
+* @return timer count in seconds
+*/
+static int ServiceNonInterrupt_GetTimerCount(void) {
+ return nonInterruptTimer.read();
+}
+
+/**
+* @brief Log the BMP280 sensor value if it is time
+* @param deviceLogging pointer to object that keeps track of logging for a
+* device
+*/
+void ServiceNonInterrupt_BMP280(Device_Logging *deviceLogging) {
+ int currentTime;
+ uint32_t bmp280_data[2]; // index 0 - Temp (deg C), index 1 - Press (Pa).
+ // Divide the result by 10 to get the correct answer.
+ float temp_C, press_P;
+ int nextTime;
+
+ if (deviceLogging->isLoggingEnabled() == 0)
+ return;
+ currentTime = ServiceNonInterrupt_GetTimerCount();
+ nextTime = deviceLogging->getNextSampleTime();
+ if ((nextTime == 0) || (currentTime >= nextTime)) {
+ nextTime = currentTime + deviceLogging->getLoggingSampleRate();
+ deviceLogging->setNextSampleTime(nextTime);
+ Peripherals::bmp280()->ReadCompData(
+ &temp_C, &press_P); // Read the Temp (index 0) and Pressure (index 1)
+ bmp280_data[0] = (int32_t)(temp_C * 10);
+ bmp280_data[1] = (int32_t)(press_P * 10);
+ PacketFifo_InsertPacket(PACKET_BMP280_PRESSURE, &bmp280_data[0],
+ 2); // Read it and insert it into the FIFO
+ }
+}
+
+/**
+* @brief Log the BMP280 sensor value if it is time
+* @param deviceLogging pointer to object that keeps track of logging for a
+* device
+* @param device pointer to the device instance (MAX30205 instance 0 or MAX30205
+* instance 1)
+* @param packetId packet id that is used when building a packet
+*/
+void ServiceNonInterrupt_MAX30205(Device_Logging *deviceLogging,
+ MAX30205 *device, uint32_t packetId) {
+ int currentTime;
+ uint32_t data;
+ uint16_t tempData;
+ int nextTime;
+
+ if (deviceLogging->isLoggingEnabled() == 0)
+ return;
+ currentTime = ServiceNonInterrupt_GetTimerCount();
+ nextTime = deviceLogging->getNextSampleTime();
+ if ((nextTime == 0) || (currentTime >= nextTime)) {
+ nextTime = currentTime + deviceLogging->getLoggingSampleRate();
+ deviceLogging->setNextSampleTime(nextTime);
+ device->readTemperature(&tempData);
+ // assemble this in the correct order
+ data = (uint32_t)((tempData >> 8) + ((tempData & 0xFF) << 8));
+ PacketFifo_InsertPacket(packetId, &data,
+ 1); // Read it and insert it into the FIFO
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/HSP/LoggingService/ServiceNonInterrupt.h Tue Oct 25 15:22:11 2016 +0000 @@ -0,0 +1,66 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ +#ifndef _SERVICENONINTERRUPT_H_ +#define _SERVICENONINTERRUPT_H_ + +#include "mbed.h" +#include "Device_Logging.h" +#include "MAX30205.h" +/** +* @brief Initialize the book keeping variables for non interrupt devices +*/ +void ServiceNonInterrupt_Init(void); +/** +* @brief Start the 1 second timer +*/ +void ServiceNonInterrupt_StartTimer(void); +/** +* @brief Stop the 1 second timer +*/ +void ServiceNonInterrupt_StopTimer(void); +/** +* @brief Log the BMP280 sensor value if it is time +* @param deviceLogging pointer to object that keeps track of logging for a device +*/ +void ServiceNonInterrupt_BMP280(Device_Logging *deviceLogging); +/** +* @brief Log the BMP280 sensor value if it is time +* @param deviceLogging pointer to object that keeps track of logging for a device +* @param device pointer to the device instance (MAX30205 instance 0 or MAX30205 instance 1) +* @param packetId packet id that is used when building a packet +*/ +void ServiceNonInterrupt_MAX30205(Device_Logging *deviceLogging, MAX30205 *device, uint32_t packetId); + +#endif /* _SERVICENONINTERRUPT_H_ */ + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/QuadSPI/QuadSpi.cpp Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,70 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+#include "QuadSpi.h"
+#include "spi_multi_api.h"
+
+/** Initialize a SPI master for Quad SPI
+ *
+ * @param mosi Pin used for Master Out Slave In
+ * @param miso Pin used for Master In Slave Out
+ * @param sclk Pin used for Clock
+ * @param ssel Pin used for Chip Select
+ */
+QuadSPI::QuadSPI(PinName mosi, PinName miso, PinName sclk, PinName ssel)
+ : SPI(mosi, miso, sclk, ssel) {
+}
+
+/******************************************************************************/
+void QuadSPI::setQuadMode() { spi_master_width(&_spi, WidthQuad); }
+/******************************************************************************/
+void QuadSPI::setSingleMode() { spi_master_width(&_spi, WidthSingle); }
+
+/** Write a byte out in master mode and receive a value
+ *
+ * @param value Byte Value to send
+ * @return Returns Zero
+ */
+int QuadSPI::write(int value) {
+ aquire();
+ spi_master_write(&_spi, value);
+ return 0;
+}
+
+/** Read a byte in master mode using Quad SPI simplex transfer
+ *
+ * @return Returns the value received from Quad SPI
+ */
+int QuadSPI::read(void) {
+ aquire();
+ return spi_master_read(&_spi);
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/QuadSPI/QuadSpi.h Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,88 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+#ifndef _QUADSPI_H_
+#define _QUADSPI_H_
+
+#include "mbed.h"
+
+
+
+
+/**
+* This class provides a Quad SPI interface for quad spi devices
+* the class also allows single (4-Wire) communication
+*/
+class QuadSPI : SPI {
+
+public:
+ /** Create a QuadSPI master connected to the specified pins
+ *
+ * mosi or miso can be specfied as NC if not used
+ *
+ * @param mosi QuadSPI Master Out, Slave In pin
+ * @param miso QuadSPI Master In, Slave Out pin
+ * @param sclk QuadSPI Clock pin
+ * @param ssel QuadSPI chip select pin
+ */
+ QuadSPI(PinName mosi, PinName miso, PinName sclk, PinName ssel = NC);
+
+ /** Write to the Quad SPI Slave and return the response
+ *
+ * @param value Data to be sent to the SPI slave
+ *
+ * @returns
+ * none
+ */
+ int write(int value);
+
+ /** Read from the Quad SPI Slave and return the response
+ *
+ * @param none
+ *
+ * @returns
+ * Response from the SPI slave
+ */
+ int read(void);
+
+ /** Allow switching to and from Single SPI and Quad SPI
+ *
+ * @param none
+ *
+ * @returns
+ * Response from the SPI slave
+ */
+ void setSingleMode();
+ void setQuadMode();
+};
+
+#endif /* _QUADSPI_H_ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/RpcServer/PacketFifo.cpp Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,56 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+#include "RpcFifo.h"
+#include "Streaming.h"
+#include "RpcServer.h"
+
+// this will create a packet and insert it on the "jFifo" to be streamed out or
+// saved in flash
+void PacketFifo_InsertPacket(uint32_t packetId, uint32_t *buffer,
+ uint32_t numberInBuffer) {
+ StreamPacketUint32(packetId, buffer, numberInBuffer);
+}
+
+// clears the packet fifo "jFifo"
+void PacketFifo_Clear(void) { fifo_clear(GetStreamOutFifo()); }
+
+// returns one if fifo is empty, zero if not empty
+int PacketFifo_Empty(void) { return fifo_empty(GetStreamOutFifo()); }
+
+// returns a uint32 from the fifo, this uint32 is destined to be streamed out
+// USB or saved in flash
+uint32_t PacketFifo_GetUint32(void) {
+ uint32_t val;
+ fifo_get32(GetStreamOutFifo(), &val);
+ return val;
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/HSP/RpcServer/PacketFifo.h Tue Oct 25 15:22:11 2016 +0000 @@ -0,0 +1,61 @@ +/******************************************************************************* +* Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. +* +* Permission is hereby granted, free of charge, to any person obtaining a +* copy of this software and associated documentation files (the "Software"), +* to deal in the Software without restriction, including without limitation +* the rights to use, copy, modify, merge, publish, distribute, sublicense, +* and/or sell copies of the Software, and to permit persons to whom the +* Software is furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included +* in all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +* IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES +* OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +* OTHER DEALINGS IN THE SOFTWARE. +* +* Except as contained in this notice, the name of Maxim Integrated +* Products, Inc. shall not be used except as stated in the Maxim Integrated +* Products, Inc. Branding Policy. +* +* The mere transfer of this software does not imply any licenses +* of trade secrets, proprietary technology, copyrights, patents, +* trademarks, maskwork rights, or any other form of intellectual +* property whatsoever. Maxim Integrated Products, Inc. retains all +* ownership rights. +******************************************************************************* +*/ +#ifndef _PACKETFIFO_H_ +#define _PACKETFIFO_H_ + +#include "mbed.h" + +/** +* this will create a packet and insert it into an outbound fifo to be streamed out or saved in flash +* @param packetId number id to assign to this packet +* @param buffer a 32-bit buffer that contains data that will be used in the packet +* @param numberInBuffer the number of 32-bit elements to be copied from the buffer +*/ +void PacketFifo_InsertPacket(uint32_t packetId, uint32_t *buffer, uint32_t numberInBuffer); + +/** +* clears the packet outbound fifo +*/ +void PacketFifo_Clear(void); + +/** +* returns one if outbound fifo is empty, zero if not empty +*/ +uint32_t PacketFifo_Empty(void); + +/** +* returns a uint32 from the fifo, this uint32 is destined to be streamed out USB or saved in flash +*/ +uint32_t PacketFifo_GetUint32(void); + +#endif /* _PACKETFIFO_H_ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/RpcServer/RpcDeclarations.h Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,688 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+#ifndef _RPCDECLARATIONS_H_
+#define _RPCDECLARATIONS_H_
+
+/// define the parts of a RPC. ObjectName, MethodName and function
+struct RPC_registeredProcedure {
+ const char *objectName;
+ const char *methodName;
+ //enum eArgType argTypes[4];
+ int (*func)(char args[32][32], char results[32][32]);
+ struct RPC_registeredProcedure *next;
+};
+
+/// used to keep track of the head of the list and the end of a list
+struct RPC_Object {
+ struct RPC_registeredProcedure *head;
+ struct RPC_registeredProcedure *last;
+};
+
+
+#define I2C_NAME "I2c"
+/**
+* @brief /I2c/WriteRead instance slaveAddress writeNumber dataToWrite readNumber
+* @details Command allows you to write and read generic I2c commands using a given I2c instance master
+* @param instance The I2c master on the Nimitz to use
+* @param slaveAddress Slave address to use when communicating
+* @param writeNumber The number of bytes to write
+* @param dataToWrite A series of space separated hex values that are to be written
+* @param readNumber The number of bytes to read may be 0 if reading is not needed
+* @details Example: /I2c/WriteRead 1 A0 3 11 22 33 2
+* @details This performs an I2c write and read using instance 1, slave address A0, and writes 3 bytes,
+* @details the 3 bytes that are written are 11 22 33, 2 bytes are meant to be read after the write
+*/
+struct RPC_registeredProcedure Define_I2c_WriteRead = { I2C_NAME, "WriteRead", I2C_WriteRead };
+
+//example /I2c/WriteRead 1 A0 3 11 22 33 2
+#define System_NAME "System"
+
+/**
+* @brief /System/ReadVer
+* @details Returns the version string of the FW that is currently running
+* @details Example: /System/ReadVer
+* @details The command returns a version string similar to this: "HSP FW Version 2.0.1f 8/23/16"
+*/
+struct RPC_registeredProcedure Define_System_ReadVer = { System_NAME, "ReadVer", System_ReadVer };
+/**
+* @brief /System/ReadBuildTime
+* @details Returns the build string of the FW that is currently running, this is the time and date that the firmware was built
+* @details Example: /System/ReadBuildTime
+* @details The command returns a build string similar to this: "Build Time: Fri Jul 1 15:48:31 2016"
+*/
+struct RPC_registeredProcedure Define_System_ReadBuildTime = { System_NAME, "ReadBuildTime", System_ReadBuildTime };
+
+#define MAX30101_NAME "MAX30101" //"MAX30101"
+/**
+* @brief /MAX30101/WriteReg address data
+* @details Returns the version string of the FW that is currently running
+* @param address Register address to write to within the MAX30101
+* @param data The data to write to the MAX30101
+* @details Example: /MAX30101/WriteReg 01 123456
+*/
+struct RPC_registeredProcedure Define_MAX30101_WriteReg = { MAX30101_NAME, "WriteReg", MAX30101_WriteReg };
+/**
+* @brief /MAX30101/ReadReg address data
+* @details Returns the version string of the FW that is currently running
+* @param address Register address to write to within the MAX30101
+* @param data The data to write to the MAX30101
+* @details Example: /MAX30101/WriteReg 01 123456
+*/
+struct RPC_registeredProcedure Define_MAX30101_ReadReg = { MAX30101_NAME, "ReadReg", MAX30101_ReadReg };
+/**
+* @brief /MAX30101/SpO2mode_init fifo_waterlevel_mark sample_avg sample_rate pulse_width red_led_current ir_led_current
+* @details This function sets up for the SpO2 mode.
+* @param fifo_waterlevel_mark
+* @param sample_avg
+* @param sample_rate
+* @param pulse_width
+* @param red_led_current
+* @param ir_led_current
+*/
+struct RPC_registeredProcedure Define_MAX30101_SpO2mode_Init = { MAX30101_NAME, "SpO2mode_init", MAX30101_SpO2mode_init };
+/**
+* @brief /MAX30101/SpO2mode_init fifo_waterlevel_mark sample_avg sample_rate pulse_width red_led_current ir_led_current
+* @details This function sets up for the SpO2 mode.
+* @param fifo_waterlevel_mark
+* @param sample_avg
+* @param sample_rate
+* @param pulse_width
+* @param red_led_current
+* @param ir_led_current
+*/
+struct RPC_registeredProcedure Define_MAX30101_SpO2mode_InitStart = { MAX30101_NAME, "SpO2mode_InitStart", MAX30101_SpO2mode_InitStart };
+/**
+* @brief /MAX30101/SpO2mode_init fifo_waterlevel_mark sample_avg sample_rate pulse_width red_led_current ir_led_current
+* @details This function sets up for the SpO2 mode.
+* @param fifo_waterlevel_mark
+* @param sample_avg
+* @param sample_rate
+* @param pulse_width
+* @param red_led_current
+* @param ir_led_current
+*/
+struct RPC_registeredProcedure Define_MAX30101_HRmode_Init = { MAX30101_NAME, "HRmode_init", MAX30101_HRmode_init };
+/**
+* @brief /MAX30101/SpO2mode_init fifo_waterlevel_mark sample_avg sample_rate pulse_width red_led_current ir_led_current
+* @details This function sets up for the SpO2 mode.
+* @param fifo_waterlevel_mark
+* @param sample_avg
+* @param sample_rate
+* @param pulse_width
+* @param red_led_current
+* @param ir_led_current
+*/
+struct RPC_registeredProcedure Define_MAX30101_HRmode_InitStart = { MAX30101_NAME, "HRmode_InitStart", MAX30101_HRmode_InitStart };
+/**
+* @brief /MAX30101/SpO2mode_init fifo_waterlevel_mark sample_avg sample_rate pulse_width red_led_current ir_led_current
+* @details This function sets up for the SpO2 mode.
+* @param fifo_waterlevel_mark
+* @param sample_avg
+* @param sample_rate
+* @param pulse_width
+* @param red_led_current
+* @param ir_led_current
+*/
+struct RPC_registeredProcedure Define_MAX30101_Multimode_init = { MAX30101_NAME, "Multimode_init", MAX30101_Multimode_init };
+/**
+* @brief /MAX30101/SpO2mode_init fifo_waterlevel_mark sample_avg sample_rate pulse_width red_led_current ir_led_current
+* @details This function sets up for the SpO2 mode.
+* @param fifo_waterlevel_mark
+* @param sample_avg
+* @param sample_rate
+* @param pulse_width
+* @param red_led_current
+* @param ir_led_current
+*/
+struct RPC_registeredProcedure Define_MAX30101_Multimode_InitStart = { MAX30101_NAME, "Multimode_InitStart", MAX30101_Multimode_InitStart };
+/**
+* @brief /MAX30101/SpO2mode_init fifo_waterlevel_mark sample_avg sample_rate pulse_width red_led_current ir_led_current
+* @details This function sets up for the SpO2 mode.
+* @param fifo_waterlevel_mark
+* @param sample_avg
+* @param sample_rate
+* @param pulse_width
+* @param red_led_current
+* @param ir_led_current
+*/
+struct RPC_registeredProcedure Define_MAX30101_SpO2mode_stop = { MAX30101_NAME, "SpO2mode_stop", MAX30101_SpO2mode_stop };
+/**
+* @brief /MAX30101/SpO2mode_init fifo_waterlevel_mark sample_avg sample_rate pulse_width red_led_current ir_led_current
+* @details This function sets up for the SpO2 mode.
+* @param fifo_waterlevel_mark
+* @param sample_avg
+* @param sample_rate
+* @param pulse_width
+* @param red_led_current
+* @param ir_led_current
+*/
+struct RPC_registeredProcedure Define_MAX30101_HRmode_stop = { MAX30101_NAME, "HRmode_stop", MAX30101_HRmode_stop };
+/**
+* @brief /MAX30101/SpO2mode_init fifo_waterlevel_mark sample_avg sample_rate pulse_width red_led_current ir_led_current
+* @details This function sets up for the SpO2 mode.
+* @param fifo_waterlevel_mark
+* @param sample_avg
+* @param sample_rate
+* @param pulse_width
+* @param red_led_current
+* @param ir_led_current
+*/
+struct RPC_registeredProcedure Define_MAX30101_Multimode_stop = { MAX30101_NAME, "Multimode_stop", MAX30101_Multimode_stop };
+
+#define MAX30001_NAME "MAX30001"
+#define MAX30003_NAME "MAX30003"
+
+#define MAX31725_NAME "MAX31725"
+#define MAX30205_NAME "MAX30205"
+
+/**
+* @brief /MAX30101/SpO2mode_init fifo_waterlevel_mark sample_avg sample_rate pulse_width red_led_current ir_led_current
+* @details This function sets up for the SpO2 mode.
+* @param fifo_waterlevel_mark
+* @param sample_avg
+* @param sample_rate
+* @param pulse_width
+* @param red_led_current
+* @param ir_led_current
+*/
+struct RPC_registeredProcedure Define_MAX30001_WriteReg = { MAX30001_NAME, "WriteReg", MAX30001_WriteReg };
+/**
+* @brief /MAX30101/SpO2mode_init fifo_waterlevel_mark sample_avg sample_rate pulse_width red_led_current ir_led_current
+* @details This function sets up for the SpO2 mode.
+* @param fifo_waterlevel_mark
+* @param sample_avg
+* @param sample_rate
+* @param pulse_width
+* @param red_led_current
+* @param ir_led_current
+*/
+struct RPC_registeredProcedure Define_MAX30001_ReadReg = { MAX30001_NAME, "ReadReg", MAX30001_ReadReg };
+/**
+* @brief /MAX30101/SpO2mode_init fifo_waterlevel_mark sample_avg sample_rate pulse_width red_led_current ir_led_current
+* @details This function sets up for the SpO2 mode.
+* @param fifo_waterlevel_mark
+* @param sample_avg
+* @param sample_rate
+* @param pulse_width
+* @param red_led_current
+* @param ir_led_current
+*/
+struct RPC_registeredProcedure Define_MAX30001_Start = { MAX30001_NAME, "Start", MAX30001_Start };
+/**
+* @brief /MAX30101/SpO2mode_init fifo_waterlevel_mark sample_avg sample_rate pulse_width red_led_current ir_led_current
+* @details This function sets up for the SpO2 mode.
+* @param fifo_waterlevel_mark
+* @param sample_avg
+* @param sample_rate
+* @param pulse_width
+* @param red_led_current
+* @param ir_led_current
+*/
+struct RPC_registeredProcedure Define_MAX30001_Stop = { MAX30001_NAME, "Stop", MAX30001_Stop };
+/**
+* @brief /MAX30101/SpO2mode_init fifo_waterlevel_mark sample_avg sample_rate pulse_width red_led_current ir_led_current
+* @details This function sets up for the SpO2 mode.
+* @param fifo_waterlevel_mark
+* @param sample_avg
+* @param sample_rate
+* @param pulse_width
+* @param red_led_current
+* @param ir_led_current
+*/
+struct RPC_registeredProcedure Define_MAX30001_Rbias_FMSTR_Init = { MAX30001_NAME, "Rbias_FMSTR_Init", MAX30001_Rbias_FMSTR_Init };
+/**
+* @brief /MAX30101/SpO2mode_init fifo_waterlevel_mark sample_avg sample_rate pulse_width red_led_current ir_led_current
+* @details This function sets up for the SpO2 mode.
+* @param fifo_waterlevel_mark
+* @param sample_avg
+* @param sample_rate
+* @param pulse_width
+* @param red_led_current
+* @param ir_led_current
+*/
+struct RPC_registeredProcedure Define_MAX30001_CAL_InitStart = { MAX30001_NAME, "CAL_InitStart", MAX30001_CAL_InitStart };
+/**
+* @brief /MAX30101/SpO2mode_init fifo_waterlevel_mark sample_avg sample_rate pulse_width red_led_current ir_led_current
+* @details This function sets up for the SpO2 mode.
+* @param fifo_waterlevel_mark
+* @param sample_avg
+* @param sample_rate
+* @param pulse_width
+* @param red_led_current
+* @param ir_led_current
+*/
+struct RPC_registeredProcedure Define_MAX30001_ECG_InitStart = { MAX30001_NAME, "ECG_InitStart", MAX30001_ECG_InitStart };
+/**
+* @brief /MAX30101/SpO2mode_init fifo_waterlevel_mark sample_avg sample_rate pulse_width red_led_current ir_led_current
+* @details This function sets up for the SpO2 mode.
+* @param fifo_waterlevel_mark
+* @param sample_avg
+* @param sample_rate
+* @param pulse_width
+* @param red_led_current
+* @param ir_led_current
+*/
+struct RPC_registeredProcedure Define_MAX30001_ECGFast_Init = { MAX30001_NAME, "ECGFast_Init", MAX30001_ECGFast_Init };
+/**
+* @brief /MAX30101/SpO2mode_init fifo_waterlevel_mark sample_avg sample_rate pulse_width red_led_current ir_led_current
+* @details This function sets up for the SpO2 mode.
+* @param fifo_waterlevel_mark
+* @param sample_avg
+* @param sample_rate
+* @param pulse_width
+* @param red_led_current
+* @param ir_led_current
+*/
+struct RPC_registeredProcedure Define_MAX30001_PACE_InitStart = { MAX30001_NAME, "PACE_InitStart", MAX30001_PACE_InitStart };
+/**
+* @brief /MAX30101/SpO2mode_init fifo_waterlevel_mark sample_avg sample_rate pulse_width red_led_current ir_led_current
+* @details This function sets up for the SpO2 mode.
+* @param fifo_waterlevel_mark
+* @param sample_avg
+* @param sample_rate
+* @param pulse_width
+* @param red_led_current
+* @param ir_led_current
+*/
+struct RPC_registeredProcedure Define_MAX30001_BIOZ_InitStart = { MAX30001_NAME, "BIOZ_InitStart", MAX30001_BIOZ_InitStart };
+/**
+* @brief /MAX30101/SpO2mode_init fifo_waterlevel_mark sample_avg sample_rate pulse_width red_led_current ir_led_current
+* @details This function sets up for the SpO2 mode.
+* @param fifo_waterlevel_mark
+* @param sample_avg
+* @param sample_rate
+* @param pulse_width
+* @param red_led_current
+* @param ir_led_current
+*/
+struct RPC_registeredProcedure Define_MAX30001_RtoR_InitStart = { MAX30001_NAME, "RtoR_InitStart", MAX30001_RtoR_InitStart };
+/**
+* @brief /MAX30101/SpO2mode_init fifo_waterlevel_mark sample_avg sample_rate pulse_width red_led_current ir_led_current
+* @details This function sets up for the SpO2 mode.
+* @param fifo_waterlevel_mark
+* @param sample_avg
+* @param sample_rate
+* @param pulse_width
+* @param red_led_current
+* @param ir_led_current
+*/
+struct RPC_registeredProcedure Define_MAX30001_Stop_ECG = { MAX30001_NAME, "Stop_ECG", MAX30001_Stop_ECG };
+/**
+* @brief /MAX30101/SpO2mode_init fifo_waterlevel_mark sample_avg sample_rate pulse_width red_led_current ir_led_current
+* @details This function sets up for the SpO2 mode.
+* @param fifo_waterlevel_mark
+* @param sample_avg
+* @param sample_rate
+* @param pulse_width
+* @param red_led_current
+* @param ir_led_current
+*/
+struct RPC_registeredProcedure Define_MAX30001_Stop_PACE = { MAX30001_NAME, "Stop_PACE", MAX30001_Stop_PACE };
+/**
+* @brief /MAX30101/SpO2mode_init fifo_waterlevel_mark sample_avg sample_rate pulse_width red_led_current ir_led_current
+* @details This function sets up for the SpO2 mode.
+* @param fifo_waterlevel_mark
+* @param sample_avg
+* @param sample_rate
+* @param pulse_width
+* @param red_led_current
+* @param ir_led_current
+*/
+struct RPC_registeredProcedure Define_MAX30001_Stop_BIOZ = { MAX30001_NAME, "Stop_BIOZ", MAX30001_Stop_BIOZ };
+/**
+* @brief /MAX30101/SpO2mode_init fifo_waterlevel_mark sample_avg sample_rate pulse_width red_led_current ir_led_current
+* @details This function sets up for the SpO2 mode.
+* @param fifo_waterlevel_mark
+* @param sample_avg
+* @param sample_rate
+* @param pulse_width
+* @param red_led_current
+* @param ir_led_current
+*/
+struct RPC_registeredProcedure Define_MAX30001_Stop_RtoR = { MAX30001_NAME, "Stop_RtoR", MAX30001_Stop_RtoR };
+/**
+* @brief /MAX30101/SpO2mode_init fifo_waterlevel_mark sample_avg sample_rate pulse_width red_led_current ir_led_current
+* @details This function sets up for the SpO2 mode.
+* @param fifo_waterlevel_mark
+* @param sample_avg
+* @param sample_rate
+* @param pulse_width
+* @param red_led_current
+* @param ir_led_current
+*/
+struct RPC_registeredProcedure Define_MAX30001_Stop_Cal = { MAX30001_NAME, "Stop_Cal", MAX30001_Stop_Cal };
+/**
+* @brief /MAX30101/SpO2mode_init fifo_waterlevel_mark sample_avg sample_rate pulse_width red_led_current ir_led_current
+* @details This function sets up for the SpO2 mode.
+* @param fifo_waterlevel_mark
+* @param sample_avg
+* @param sample_rate
+* @param pulse_width
+* @param red_led_current
+* @param ir_led_current
+*/
+struct RPC_registeredProcedure Define_MAX30001_Enable_ECG_LeadON = { MAX30001_NAME, "Enable_ECG_LeadON", MAX30001_Enable_ECG_LeadON };
+/**
+* @brief /MAX30101/SpO2mode_init fifo_waterlevel_mark sample_avg sample_rate pulse_width red_led_current ir_led_current
+* @details This function sets up for the SpO2 mode.
+* @param fifo_waterlevel_mark
+* @param sample_avg
+* @param sample_rate
+* @param pulse_width
+* @param red_led_current
+* @param ir_led_current
+*/
+struct RPC_registeredProcedure Define_MAX30001_Enable_BIOZ_LeadON = { MAX30001_NAME, "Enable_BIOZ_LeadON", MAX30001_Enable_BIOZ_LeadON };
+/**
+* @brief /MAX30101/SpO2mode_init fifo_waterlevel_mark sample_avg sample_rate pulse_width red_led_current ir_led_current
+* @details This function sets up for the SpO2 mode.
+* @param fifo_waterlevel_mark
+* @param sample_avg
+* @param sample_rate
+* @param pulse_width
+* @param red_led_current
+* @param ir_led_current
+*/
+struct RPC_registeredProcedure Define_MAX30001_Read_LeadON = { MAX30001_NAME, "Read_LeadON", MAX30001_Read_LeadON };
+/**
+* @brief /MAX30101/SpO2mode_init fifo_waterlevel_mark sample_avg sample_rate pulse_width red_led_current ir_led_current
+* @details This function sets up for the SpO2 mode.
+* @param fifo_waterlevel_mark
+* @param sample_avg
+* @param sample_rate
+* @param pulse_width
+* @param red_led_current
+* @param ir_led_current
+*/
+struct RPC_registeredProcedure Define_MAX30001_StartTest = { MAX30001_NAME, "StartTest", MAX30001_StartTest };
+/**
+* @brief /MAX30101/SpO2mode_init fifo_waterlevel_mark sample_avg sample_rate pulse_width red_led_current ir_led_current
+* @details This function sets up for the SpO2 mode.
+* @param fifo_waterlevel_mark
+* @param sample_avg
+* @param sample_rate
+* @param pulse_width
+* @param red_led_current
+* @param ir_led_current
+*/
+struct RPC_registeredProcedure Define_MAX30001_INT_assignment = { MAX30001_NAME, "INT_assignment", MAX30001_INT_assignment };
+
+#define LOGGING_NAME "Logging"
+/**
+* @brief /Logging/StartMissionDefine
+* @details A command to send when you are starting to define a mission
+*/
+struct RPC_registeredProcedure Define_Logging_StartMissionDefine = { LOGGING_NAME, "StartMissionDefine", Logging_RPC_StartMissionDefine };
+/**
+* @brief /Logging/AppendMissionCmd missionString
+* @details Specify a RPC command that is part of a mission
+*/
+struct RPC_registeredProcedure Define_Logging_AppendMissionCmd = { LOGGING_NAME, "AppendMissionCmd", Logging_RPC_AppendMissionCmd };
+/**
+* @brief /Logging/EndMissionDefine
+* @details RPC command that indicated the end of defining a mission
+*/
+struct RPC_registeredProcedure Define_Logging_EndMissionDefine = { LOGGING_NAME, "EndMissionDefine", Logging_RPC_EndMissionDefine };
+/**
+* @brief /Logging/WriteMission
+* @details Write the described mission to flash
+*/
+struct RPC_registeredProcedure Define_Logging_WriteMission = { LOGGING_NAME, "WriteMission", Logging_RPC_WriteMission };
+/**
+* @brief /Logging/ReadMission
+* @details Read the mission from flash
+*/
+struct RPC_registeredProcedure Define_Logging_ReadMission = { LOGGING_NAME, "ReadMission", Logging_RPC_ReadMission };
+/**
+* @brief /Logging/EraseMission
+* @details Erase the mission in flash
+*/
+struct RPC_registeredProcedure Define_Logging_EraseMission = { LOGGING_NAME, "EraseMission", Logging_RPC_EraseMission };
+/**
+* @brief /Logging/EraseWrittenSectors
+* @details Erase the datalog in flash, this erases all of the datalog that has been written to the flash
+*/
+struct RPC_registeredProcedure Define_Logging_EraseWrittenSectors = { LOGGING_NAME, "EraseWrittenSectors", Logging_EraseWrittenSectors };
+/**
+* @brief /Logging/StartLoggingUsb
+* @details Start streaming data through USB
+*/
+struct RPC_registeredProcedure Define_Logging_StartLoggingUsb = { LOGGING_NAME, "StartLoggingUsb", Logging_StartLoggingUsb };
+/**
+* @brief /Logging/StartLoggingFlash
+* @details Start logging data to flash
+*/
+struct RPC_registeredProcedure Define_Logging_StartLoggingFlash = { LOGGING_NAME, "StartLoggingFlash", Logging_StartLoggingFlash };
+/**
+* @brief /Logging/GetLastWrittenPage
+* @details Returns the last page that has been written to flash, this call searchs until it finds an empty flash page
+*/
+struct RPC_registeredProcedure Define_Logging_GetLastWrittenPage = { LOGGING_NAME, "GetLastWrittenPage", Logging_GetLastWrittenPage };
+/**
+* @brief /Logging/Start
+* @details Starts a datalogging session into flash, allows the ability to start datalogging via RPC call
+*/
+struct RPC_registeredProcedure Define_Logging_Start = { LOGGING_NAME, "Start", Logging_Start };
+
+#define LIS2DH_NAME "LIS2DH"
+/**
+* @brief /LIS2DH/InitStart
+* @details Starts streaming interrupts from the LIS2DH device
+*/
+struct RPC_registeredProcedure Define_LIS2DH_InitStart = { LIS2DH_NAME, "InitStart", LIS2DH_InitStart };
+/**
+* @brief /LIS2DH/ReadReg address
+* @details Reads a register
+* @param address Register address to read from
+*/
+struct RPC_registeredProcedure Define_LIS2DH_ReadReg = { LIS2DH_NAME, "ReadReg", LIS2DH_ReadReg };
+/**
+* @brief /LIS2DH/WriteReg address data
+* @details Write a register
+* @param address Register address to read from
+* @param data Data to write
+*/
+struct RPC_registeredProcedure Define_LIS2DH_WriteReg = { LIS2DH_NAME, "WriteReg", LIS2DH_WriteReg };
+/**
+* @brief /LIS2DH/Stop
+* @details Stop the interrupts within the LIS2DH
+*/
+struct RPC_registeredProcedure Define_LIS2DH_Stop = { LIS2DH_NAME, "Stop", LIS2DH_Stop };
+
+#define BMP280_NAME "BMP280"
+/**
+* @brief /BMP280/InitStart
+* @details Start the polling process for the BMP280
+*/
+struct RPC_registeredProcedure Define_BMP280_InitStart = { BMP280_NAME, "InitStart", BMP280_InitStart };
+
+#define MAX30205_1_NAME "MAX30205_1"
+#define MAX31725_1_NAME "MAX31725_1"
+/**
+* @brief /MAX30205_1/InitStart
+* @details Start the polling process for the MAX30205 instance 1
+*/
+struct RPC_registeredProcedure Define_MAX30205_1_InitStart = { MAX30205_1_NAME, "InitStart", MAX30205_1_InitStart };
+struct RPC_registeredProcedure Define_MAX31725_1_InitStart = { MAX31725_1_NAME, "InitStart", MAX30205_1_InitStart };
+
+#define MAX30205_2_NAME "MAX30205_2"
+#define MAX31725_2_NAME "MAX31725_2"
+/**
+* @brief /MAX30205_2/InitStart
+* @details Start the polling process for the MAX30205 instance 2
+*/
+struct RPC_registeredProcedure Define_MAX30205_2_InitStart = { MAX30205_2_NAME, "InitStart", MAX30205_2_InitStart };
+struct RPC_registeredProcedure Define_MAX31725_2_InitStart = { MAX31725_2_NAME, "InitStart", MAX30205_2_InitStart };
+
+#define LED_NAME "Led"
+/**
+* @brief /Led/On
+* @details Turn on the HSP onboard LED
+*/
+struct RPC_registeredProcedure Define_Led_On = { LED_NAME, "On", Led_On };
+/**
+* @brief /Led/Off
+* @details Turn off the HSP onboard LED
+*/
+struct RPC_registeredProcedure Define_Led_Off = { LED_NAME, "Off", Led_Off };
+/**
+* @brief /Led/Blink mS
+* @details Start blinking the HSP onboard LED
+* @param mS Blink using a mS period
+*/
+struct RPC_registeredProcedure Define_Led_BlinkHz = { LED_NAME, "Blink", Led_BlinkHz };
+/**
+* @brief /Led/Pattern pattern
+* @details Rotate a 32-bit pattern through the LED so that specific blink patterns can be obtained
+* @param pattern A 32-bit pattern to rotate through
+*/
+struct RPC_registeredProcedure Define_Led_BlinkPattern = { LED_NAME, "Pattern", Led_BlinkPattern };
+
+#define S25FS512_NAME "S25FS512"
+/**
+* @brief /S25FS512/ReadId
+* @details Rotate a 32-bit pattern through the LED so that specific blink patterns can be obtained
+* @param pattern A 32-bit pattern to rotate through
+*/
+struct RPC_registeredProcedure Define_S25FS512_ReadId = { S25FS512_NAME, "ReadId", S25FS512_ReadId };
+/**
+* @brief /S25FS512/ReadPagesBinary startPage endPage
+* @details Read a page from flash, return the data in binary (non-ascii)
+* @param startPage The Starting page to read from
+* @param endPage The last page to read from
+*/
+struct RPC_registeredProcedure Define_S25FS512_ReadPagesBinary = { S25FS512_NAME, "ReadPagesBinary", S25FS512_ReadPagesBinary };
+/**
+* @brief /S25FS512/Reset
+* @details Issue a soft reset to the flash device
+*/
+struct RPC_registeredProcedure Define_S25FS512_Reset = { S25FS512_NAME, "Reset", S25FS512_Reset };
+/**
+* @brief /S25FS512/EnableHWReset
+* @details Enable HW resets to the device
+*/
+struct RPC_registeredProcedure Define_S25FS512_EnableHWReset = { S25FS512_NAME, "EnableHWReset", S25FS512_EnableHWReset };
+/**
+* @brief /S25FS512/SpiWriteRead
+* @details Write and read SPI to the flash device using Quad SPI
+*/
+struct RPC_registeredProcedure Define_S25FS512_SpiWriteRead = { S25FS512_NAME, "SpiWriteRead", S25FS512_SpiWriteRead };
+/**
+* @brief /S25FS512/SpiWriteRead4Wire
+* @details Write and read SPI to the flash device using 4 wire
+*/
+struct RPC_registeredProcedure Define_S25FS512_SpiWriteRead4Wire = { S25FS512_NAME, "SpiWriteRead4Wire", S25FS512_SpiWriteRead4Wire };
+
+#define TESTING_NAME "Testing"
+/**
+* @brief /Testing/Test_S25FS512
+* @details Start a testing sequence for this device, returns PASS and FAIL strings and detailed results of the test
+*/
+struct RPC_registeredProcedure Define_Testing_Test_S25FS512 = { TESTING_NAME, "Test_S25FS512", Test_S25FS512};
+/**
+* @brief /Testing/Test_BMP280
+* @details Start a testing sequence for this device, returns PASS and FAIL strings and detailed results of the test
+*/
+struct RPC_registeredProcedure Define_Testing_Test_BMP280 = { TESTING_NAME, "Test_BMP280", Test_BMP280};
+/**
+* @brief /Testing/Test_LIS2DH
+* @details Start a testing sequence for this device, returns PASS and FAIL strings and detailed results of the test
+*/
+struct RPC_registeredProcedure Define_Testing_Test_LIS2DH = { TESTING_NAME, "Test_LIS2DH", Test_LIS2DH };
+/**
+* @brief /Testing/Test_LSM6DS3
+* @details Start a testing sequence for this device, returns PASS and FAIL strings and detailed results of the test
+*/
+struct RPC_registeredProcedure Define_Testing_Test_LSM6DS3 = { TESTING_NAME, "Test_LSM6DS3", Test_LSM6DS3 };
+/**
+* @brief /Testing/Test_MAX30205_1
+* @details Start a testing sequence for this device, returns PASS and FAIL strings and detailed results of the test
+*/
+struct RPC_registeredProcedure Define_Testing_Test_MAX30205_1 = { TESTING_NAME, "Test_MAX30205_1", Test_MAX30205_1 };
+/**
+* @brief /Testing/Test_MAX30205_2
+* @details Start a testing sequence for this device, returns PASS and FAIL strings and detailed results of the test
+*/
+struct RPC_registeredProcedure Define_Testing_Test_MAX30205_2 = { TESTING_NAME, "Test_MAX30205_2", Test_MAX30205_2 };
+/**
+* @brief /Testing/Test_MAX30101
+* @details Start a testing sequence for this device, returns PASS and FAIL strings and detailed results of the test
+*/
+struct RPC_registeredProcedure Define_Testing_Test_MAX30101 = { TESTING_NAME, "Test_MAX30101", Test_MAX30101 };
+/**
+* @brief /Testing/Test_MAX30001
+* @details Start a testing sequence for this device, returns PASS and FAIL strings and detailed results of the test
+*/
+struct RPC_registeredProcedure Define_Testing_Test_MAX30001 = { TESTING_NAME, "Test_MAX30001", Test_MAX30001 };
+/**
+* @brief /Testing/Test_EM9301
+* @details Start a testing sequence for this device, returns PASS and FAIL strings and detailed results of the test
+*/
+struct RPC_registeredProcedure Define_Testing_Test_EM9301 = { TESTING_NAME, "Test_EM9301", Test_EM9301 };
+/**
+* @brief /Testing/Test_EM9301
+* @details Start a testing sequence for this device, returns PASS and FAIL strings and detailed results of the test
+*/
+//struct RPC_registeredProcedure Define_Testing_Test_SensorReadings = { TESTING_NAME, "Test_SensorReadings", Test_EM9301 };
+
+#define MAX14720_NAME "MAX14720"
+/**
+* @brief /MAX14720/ReadBoostVSet
+* @details Read the BoostVSet value
+* @return Returns the value from the BoostVSet register of the device
+*/
+struct RPC_registeredProcedure Define_MAX14720_ReadBoostVSet = { MAX14720_NAME, "ReadBoostVSet", MAX14720_ReadBoostVSet };
+/**
+* @brief /MAX14720/WriteBoostVSet
+* @details Write the BoostVSet value
+* @param value The binary value to set the BoostVSet register to
+* @return Returns 0x80 on success of the command
+*/
+struct RPC_registeredProcedure Define_MAX14720_WriteBoostVSet = { MAX14720_NAME, "WriteBoostVSet", MAX14720_WriteBoostVSet };
+/**
+* @brief /MAX14720/ReadReg
+* @details Read one of the MAX14720 registers
+* @param address Address of the register to read
+* @return Returns the value from the addressed register from the device
+*/
+struct RPC_registeredProcedure Define_MAX14720_ReadReg = { MAX14720_NAME, "ReadReg", MAX14720_ReadReg };
+/**
+* @brief /MAX14720/WriteReg
+* @details Write one of the MAX14720 registers
+* @param address Address of the register to write
+* @param data Value of the data to write
+* @return Returns 0x80 on success of the command
+*/
+struct RPC_registeredProcedure Define_MAX14720_WriteReg = { MAX14720_NAME, "WriteReg", MAX14720_WriteReg };
+
+#endif /* _RPCDECLARATIONS_H_ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/RpcServer/RpcFifo.cpp Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,253 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+#include "mbed.h"
+#include "RpcFifo.h"
+
+/****************************************************************************/
+void fifo_init(fifo_t *fifo, void *mem, unsigned int length) {
+ // atomic FIFO access
+ __disable_irq();
+
+ fifo->rindex = 0;
+ fifo->windex = 0;
+ fifo->data = mem;
+ fifo->length = length;
+
+ __enable_irq();
+}
+
+/****************************************************************************/
+int fifo_put8(fifo_t *fifo, uint8_t element) {
+ // Check if FIFO is full
+ if ((fifo->windex == (fifo->rindex - 1)) ||
+ ((fifo->rindex == 0) && (fifo->windex == (fifo->length - 1)))) {
+ return -1;
+ }
+
+ // atomic FIFO access
+ __disable_irq();
+
+ // Put data into FIFO
+ ((uint8_t *)(fifo->data))[fifo->windex] = element;
+
+ // Increment pointer
+ fifo->windex++;
+ if (fifo->windex == fifo->length) {
+ fifo->windex = 0;
+ }
+
+ __enable_irq();
+
+ return 0;
+}
+
+/****************************************************************************/
+int fifo_get8(fifo_t *fifo, uint8_t *element) {
+ // Check if FIFO is empty
+ if (fifo->rindex == fifo->windex)
+ return -1;
+
+ // atomic FIFO access
+ __disable_irq();
+
+ // Get data from FIFO
+ *element = ((uint8_t *)(fifo->data))[fifo->rindex];
+
+ // Increment pointer
+ fifo->rindex++;
+ if (fifo->rindex == fifo->length) {
+ fifo->rindex = 0;
+ }
+
+ __enable_irq();
+
+ return 0;
+}
+
+/****************************************************************************/
+int fifo_put16(fifo_t *fifo, uint16_t element) {
+ // Check if FIFO is full
+ if ((fifo->windex == (fifo->rindex - 1)) ||
+ ((fifo->rindex == 0) && (fifo->windex == (fifo->length - 1)))) {
+ return -1;
+ }
+
+ // atomic FIFO access
+ __disable_irq();
+
+ // Put data into FIFO
+ ((uint16_t *)(fifo->data))[fifo->windex] = element;
+
+ // Increment pointer
+ fifo->windex++;
+ if (fifo->windex == fifo->length) {
+ fifo->windex = 0;
+ }
+
+ __enable_irq();
+
+ return 0;
+}
+
+/****************************************************************************/
+int fifo_get16(fifo_t *fifo, uint16_t *element) {
+ // Check if FIFO is empty
+ if (fifo->rindex == fifo->windex)
+ return -1;
+
+ // atomic FIFO access
+ __disable_irq();
+
+ // Get data from FIFO
+ *element = ((uint16_t *)(fifo->data))[fifo->rindex];
+
+ // Increment pointer
+ fifo->rindex++;
+ if (fifo->rindex == fifo->length) {
+ fifo->rindex = 0;
+ }
+
+ __enable_irq();
+
+ return 0;
+}
+
+/****************************************************************************/
+int fifo_put32(fifo_t *fifo, uint32_t element) {
+ // Check if FIFO is full
+ if ((fifo->windex == (fifo->rindex - 1)) ||
+ ((fifo->rindex == 0) && (fifo->windex == (fifo->length - 1)))) {
+ return -1;
+ }
+
+ // atomic FIFO access
+ __disable_irq();
+
+ // Put data into FIFO
+ ((uint32_t *)(fifo->data))[fifo->windex] = element;
+
+ // Increment pointer
+ fifo->windex++;
+ if (fifo->windex == fifo->length) {
+ fifo->windex = 0;
+ }
+
+ __enable_irq();
+
+ return 0;
+}
+
+/****************************************************************************/
+int fifo_get32(fifo_t *fifo, uint32_t *element) {
+ // Check if FIFO is empty
+ if (fifo->rindex == fifo->windex)
+ return -1;
+
+ // atomic FIFO access
+ __disable_irq();
+
+ // Get data from FIFO
+ *element = ((uint32_t *)(fifo->data))[fifo->rindex];
+
+ // Increment pointer
+ fifo->rindex++;
+ if (fifo->rindex == fifo->length) {
+ fifo->rindex = 0;
+ }
+
+ __enable_irq();
+
+ return 0;
+}
+/****************************************************************************/
+void fifo_clear(fifo_t *fifo) {
+ // atomic FIFO access
+ __disable_irq();
+
+ fifo->rindex = 0;
+ fifo->windex = 0;
+
+ __enable_irq();
+}
+
+/****************************************************************************/
+int fifo_empty(fifo_t *fifo) { return (fifo->rindex == fifo->windex); }
+
+/****************************************************************************/
+int fifo_full(fifo_t *fifo) {
+ int retval;
+
+ // atomic FIFO access
+ __disable_irq();
+ retval = ((fifo->windex == (fifo->rindex - 1)) ||
+ ((fifo->rindex == 0) && (fifo->windex == (fifo->length - 1))));
+ __enable_irq();
+
+ return retval;
+}
+
+/****************************************************************************/
+unsigned int fifo_level(fifo_t *fifo) {
+ uint16_t value;
+
+ // atomic FIFO access
+ __disable_irq();
+
+ if (fifo->windex >= fifo->rindex) {
+ value = fifo->windex - fifo->rindex;
+ } else {
+ value = fifo->length - fifo->rindex + fifo->windex;
+ }
+
+ __enable_irq();
+
+ return value;
+}
+
+/****************************************************************************/
+unsigned int fifo_remaining(fifo_t *fifo) {
+ uint16_t value;
+
+ // atomic FIFO access
+ __disable_irq();
+
+ if (fifo->rindex > fifo->windex) {
+ value = fifo->rindex - fifo->windex - 1;
+ } else {
+ value = fifo->length - fifo->windex + fifo->rindex - 1;
+ }
+
+ __enable_irq();
+
+ return value;
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/RpcServer/RpcFifo.h Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,137 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *
+ ********************************************************************************
+ */
+#ifndef _RPCFIFO_H_
+#define _RPCFIFO_H_
+
+#include <stdint.h>
+
+/// Structure used for FIFO management
+typedef struct {
+ unsigned int length; ///< FIFO size (number of elements)
+ void *data; ///< pointer to the FIFO buffer
+ unsigned int rindex; ///< current FIFO read index
+ unsigned int windex; ///< current FIFO write index
+} fifo_t;
+
+/**
+* @param fifo FIFO on which to perform the operation
+* @param mem memory buffer to use for FIFO element storage
+* @param length number of elements that the memory buffer can contain
+* @returns 0 if successful, -1 upon failure
+*/
+void fifo_init(fifo_t *fifo, void *mem, unsigned int length);
+
+/**
+* @brief Adds and 8-bit element to the FIFO
+* @param fifo FIFO on which to perform the operation
+* @param element element to add to the FIFO
+* @returns 0 if successful, -1 upon failure
+*/
+int fifo_put8(fifo_t *fifo, uint8_t element);
+
+/**
+* @brief Gets the next 8-bit element to the FIFO
+* @param fifo FIFO on which to perform the operation
+* @param element pointer to where to store the element from the FIFO
+* @returns 0 if successful, -1 upon failure
+*/
+int fifo_get8(fifo_t *fifo, uint8_t *element);
+
+/**
+* @brief Adds the next 16-bit element to the FIFO
+* @param fifo FIFO on which to perform the operation
+* @param element element to add to the FIFO
+* @returns 0 if successful, -1 upon failure
+*/
+int fifo_put16(fifo_t *fifo, uint16_t element);
+
+/**
+* @brief Gets the next 16-bit element to the FIFO
+* @param fifo FIFO on which to perform the operation
+* @param element pointer to where to store the element from the FIFO
+* @returns 0 if successful, -1 upon failure
+*/
+int fifo_get16(fifo_t *fifo, uint16_t *element);
+
+/**
+* @brief Adds the next 16-bit element to the FIFO
+* @param fifo FIFO on which to perform the operation
+* @param element element to add to the FIFO
+* @returns 0 if successful, -1 upon failure
+*/
+int fifo_put32(fifo_t *fifo, uint32_t element);
+
+/**
+* @brief Gets the next 16-bit element to the FIFO
+* @param fifo FIFO on which to perform the operation
+* @param element pointer to where to store the element from the FIFO
+* @returns 0 if successful, -1 upon failure
+*/
+int fifo_get32(fifo_t *fifo, uint32_t *element);
+
+/**
+* @brief Immediately resets the FIFO to the empty state
+* @param fifo FIFO on which to perform the operation
+*/
+void fifo_clear(fifo_t *fifo);
+
+/**
+* @brief Determines if the FIFO is empty
+* @param fifo FIFO on which to perform the operation
+* @returns #TRUE if FIFO is empty, #FALSE otherwise
+*/
+int fifo_empty(fifo_t *fifo);
+
+/**
+* @brief FIFO status function
+* @param fifo FIFO on which to perform the operation
+* @returns #TRUE if FIFO is full, #FALSE otherwise
+*/
+int fifo_full(fifo_t *fifo);
+
+/**
+* @brief FIFO status function
+* @param fifo FIFO on which to perform the operation
+* @returns the number of elements currently in the FIFO
+*/
+unsigned int fifo_level(fifo_t *fifo);
+
+/**
+* @brief FIFO status function
+* @param fifo FIFO on which to perform the operation
+* @returns the remaining elements that can be added to the FIFO
+*/
+unsigned int fifo_remaining(fifo_t *fifo);
+
+#endif // _RPCFIFO_H_
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/RpcServer/RpcServer.cpp Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,445 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+#include "RpcServer.h"
+#include "StringInOut.h"
+#include "StringHelper.h"
+#include "MAX30001_RPC.h"
+#include "MAX30101_RPC.h"
+#include "LIS2DH_RPC.h"
+#include "Logging_RPC.h"
+#include "Peripherals.h"
+#include "I2C_RPC.h"
+#include "BMP280_RPC.h"
+#include "MAX30205_RPC.h"
+#include "HspLed_RPC.h"
+#include "S25FS512_RPC.h"
+#include "Testing_RPC.h"
+#include "MAX14720_RPC.h"
+#include "RpcDeclarations.h"
+#include "Device_Logging.h"
+
+/// define the version string that is reported with a RPC "ReadVer" command
+#define FW_VERSION_STRING "HSP FW Version 3.0.0 10/14/16"
+
+char args[32][32];
+char results[32][32];
+
+/// define a fifo for incoming USB data
+static fifo_t fifo;
+/// define a buffer for incoming USB data
+static uint8_t fifoBuffer[128];
+/// define stream out fifo
+static fifo_t fifoStreamOut;
+/// allocate a large fifo buffer for streaming out
+static uint32_t streamOutBuffer[0xC000 / 4];
+
+/// define a device log for the BMP280, keeps track of mission and loggin status
+Device_Logging *bmp280_Logging;
+/// define a device log for the MAX30205 (instance 0), keeps track of mission
+/// and loggin status
+Device_Logging *MAX30205_0_Logging;
+/// define a device log for the MAX30205 (instance 1), keeps track of mission
+/// and loggin status
+Device_Logging *MAX30205_1_Logging;
+
+//******************************************************************************
+fifo_t *GetUSBIncomingFifo(void) { return &fifo; }
+
+//******************************************************************************
+fifo_t *GetStreamOutFifo(void) { return &fifoStreamOut; }
+
+//******************************************************************************
+int System_ReadVer(char argStrs[32][32], char replyStrs[32][32]) {
+ strcpy(replyStrs[0], FW_VERSION_STRING);
+ strcpy(replyStrs[1], "\0");
+ return 0;
+}
+
+//******************************************************************************
+int System_ReadBuildTime(char argStrs[32][32], char replyStrs[32][32]) {
+ // strcpy(replyStrs[0],buildTime);
+ // strcpy(replyStrs[1],"\0");
+ return 0;
+}
+
+//******************************************************************************
+int System_SystemCoreClock(char argStrs[32][32], char replyStrs[32][32]) {
+ sprintf(replyStrs[0], "SystemCoreClock = %d", SystemCoreClock);
+ strcpy(replyStrs[1], "\0");
+ return 0;
+}
+
+//******************************************************************************
+int System_GetTimestamp(char argStrs[32][32], char replyStrs[32][32]) {
+ sprintf(replyStrs[0], "GetTimestamp = %d", 0);
+ strcpy(replyStrs[1], "\0");
+ return 0;
+}
+
+static struct RPC_Object RPC_Procedures = {NULL, NULL};
+
+//******************************************************************************
+void RPC_addProcedure(struct RPC_registeredProcedure *procedure) {
+ struct RPC_Object *obj = &RPC_Procedures;
+ if (obj->last != NULL) {
+ obj->last->next = procedure;
+ }
+ if (obj->head == NULL) {
+ obj->head = procedure;
+ }
+ procedure->next = NULL;
+ obj->last = procedure;
+}
+
+//******************************************************************************
+void RPC_init(void) {
+ bmp280_Logging = new Device_Logging();
+ MAX30205_0_Logging = new Device_Logging();
+ MAX30205_1_Logging = new Device_Logging();
+
+ fifo_init(&fifo, fifoBuffer, sizeof(fifoBuffer));
+ fifo_init(&fifoStreamOut, streamOutBuffer,
+ sizeof(streamOutBuffer) / sizeof(uint32_t));
+
+ // I2c
+ RPC_addProcedure(&Define_I2c_WriteRead);
+
+ // MAX30101
+ RPC_addProcedure(&Define_MAX30101_WriteReg);
+ RPC_addProcedure(&Define_MAX30101_ReadReg);
+ RPC_addProcedure(&Define_MAX30101_SpO2mode_Init);
+ RPC_addProcedure(&Define_MAX30101_HRmode_Init);
+ RPC_addProcedure(&Define_MAX30101_Multimode_init);
+ RPC_addProcedure(&Define_MAX30101_SpO2mode_InitStart);
+ RPC_addProcedure(&Define_MAX30101_HRmode_InitStart);
+ RPC_addProcedure(&Define_MAX30101_Multimode_InitStart);
+ RPC_addProcedure(&Define_MAX30101_SpO2mode_stop);
+ RPC_addProcedure(&Define_MAX30101_HRmode_stop);
+ RPC_addProcedure(&Define_MAX30101_Multimode_stop);
+
+ // MAX30001
+ RPC_addProcedure(&Define_MAX30001_WriteReg);
+ RPC_addProcedure(&Define_MAX30001_ReadReg);
+ RPC_addProcedure(&Define_MAX30001_Start);
+ RPC_addProcedure(&Define_MAX30001_Stop);
+ RPC_addProcedure(&Define_MAX30001_Enable_ECG_LeadON);
+ RPC_addProcedure(&Define_MAX30001_Enable_BIOZ_LeadON);
+ RPC_addProcedure(&Define_MAX30001_Read_LeadON);
+ RPC_addProcedure(&Define_MAX30001_StartTest);
+ RPC_addProcedure(&Define_MAX30001_INT_assignment);
+ RPC_addProcedure(&Define_MAX30001_Rbias_FMSTR_Init);
+ RPC_addProcedure(&Define_MAX30001_CAL_InitStart);
+ RPC_addProcedure(&Define_MAX30001_ECG_InitStart);
+ RPC_addProcedure(&Define_MAX30001_ECGFast_Init);
+ RPC_addProcedure(&Define_MAX30001_PACE_InitStart);
+ RPC_addProcedure(&Define_MAX30001_BIOZ_InitStart);
+ RPC_addProcedure(&Define_MAX30001_RtoR_InitStart);
+ RPC_addProcedure(&Define_MAX30001_Stop_ECG);
+ RPC_addProcedure(&Define_MAX30001_Stop_PACE);
+ RPC_addProcedure(&Define_MAX30001_Stop_BIOZ);
+ RPC_addProcedure(&Define_MAX30001_Stop_RtoR);
+ RPC_addProcedure(&Define_MAX30001_Stop_Cal);
+
+ // Logging
+ RPC_addProcedure(&Define_Logging_StartMissionDefine);
+ RPC_addProcedure(&Define_Logging_AppendMissionCmd);
+ RPC_addProcedure(&Define_Logging_EndMissionDefine);
+ RPC_addProcedure(&Define_Logging_WriteMission);
+ RPC_addProcedure(&Define_Logging_ReadMission);
+ RPC_addProcedure(&Define_Logging_EraseMission);
+ RPC_addProcedure(&Define_Logging_EraseWrittenSectors);
+ RPC_addProcedure(&Define_Logging_StartLoggingUsb);
+ RPC_addProcedure(&Define_Logging_StartLoggingFlash);
+ RPC_addProcedure(&Define_Logging_GetLastWrittenPage);
+ RPC_addProcedure(&Define_Logging_Start);
+
+ // LIS2HD
+ RPC_addProcedure(&Define_LIS2DH_InitStart);
+ RPC_addProcedure(&Define_LIS2DH_ReadReg);
+ RPC_addProcedure(&Define_LIS2DH_WriteReg);
+ RPC_addProcedure(&Define_LIS2DH_Stop);
+
+ // BMP280
+ RPC_addProcedure(&Define_BMP280_InitStart);
+
+ // MAX30205 and MAX31725 Alias
+ RPC_addProcedure(&Define_MAX30205_1_InitStart);
+ RPC_addProcedure(&Define_MAX30205_2_InitStart);
+ RPC_addProcedure(&Define_MAX31725_1_InitStart);
+ RPC_addProcedure(&Define_MAX31725_2_InitStart);
+
+ // led
+ RPC_addProcedure(&Define_Led_On);
+ RPC_addProcedure(&Define_Led_Off);
+ RPC_addProcedure(&Define_Led_BlinkHz);
+ RPC_addProcedure(&Define_Led_BlinkPattern);
+
+ // S25FS512
+ RPC_addProcedure(&Define_S25FS512_ReadId);
+ RPC_addProcedure(&Define_S25FS512_ReadPagesBinary);
+ RPC_addProcedure(&Define_S25FS512_Reset);
+ RPC_addProcedure(&Define_S25FS512_EnableHWReset);
+ RPC_addProcedure(&Define_S25FS512_SpiWriteRead);
+ RPC_addProcedure(&Define_S25FS512_SpiWriteRead4Wire);
+
+ // Testing
+ RPC_addProcedure(&Define_Testing_Test_S25FS512);
+ RPC_addProcedure(&Define_Testing_Test_BMP280);
+ RPC_addProcedure(&Define_Testing_Test_LIS2DH);
+ RPC_addProcedure(&Define_Testing_Test_LSM6DS3);
+ RPC_addProcedure(&Define_Testing_Test_MAX30205_1);
+ RPC_addProcedure(&Define_Testing_Test_MAX30205_2);
+ RPC_addProcedure(&Define_Testing_Test_MAX30101);
+ RPC_addProcedure(&Define_Testing_Test_MAX30001);
+ RPC_addProcedure(&Define_Testing_Test_EM9301);
+
+ // System
+ RPC_addProcedure(&Define_System_ReadVer);
+ RPC_addProcedure(&Define_System_ReadBuildTime);
+
+ // MAX14720
+ RPC_addProcedure(&Define_MAX14720_ReadBoostVSet);
+ RPC_addProcedure(&Define_MAX14720_WriteBoostVSet);
+ RPC_addProcedure(&Define_MAX14720_ReadReg);
+ RPC_addProcedure(&Define_MAX14720_WriteReg);
+}
+
+//******************************************************************************
+struct RPC_registeredProcedure *RPC_lookup(char *objectName, char *methodName) {
+ struct RPC_registeredProcedure *ptr;
+ // lookup all registered methods
+ ptr = RPC_Procedures.head;
+ while (ptr != NULL) {
+ if (strcmp(ptr->objectName, objectName) == 0 &&
+ strcmp(ptr->methodName, methodName) == 0) {
+ // we found a match... return with it
+ return ptr;
+ }
+ ptr = ptr->next;
+ }
+ return NULL;
+}
+
+//******************************************************************************
+char *GetToken(char *inStr, char *outStr, int start, char ch) {
+ int i;
+ int index = 0;
+ int length = strlen(inStr);
+ for (i = start; i < length; i++) {
+ if (inStr[i] != ch) {
+ outStr[index++] = inStr[i];
+ } else {
+ break;
+ }
+ }
+ outStr[index++] = 0;
+ return outStr;
+}
+
+//******************************************************************************
+void SendCommandList(char *reply) {
+ struct RPC_registeredProcedure *ptr;
+ reply[0] = 0;
+ ptr = RPC_Procedures.head;
+ while (ptr != NULL) {
+ strcat(reply, "/");
+ strcat(reply, ptr->objectName);
+ strcat(reply, "/");
+ strcat(reply, ptr->methodName);
+ strcat(reply, ",");
+ ptr = ptr->next;
+ }
+ strcat(reply, "\r\n");
+}
+
+//******************************************************************************
+int CheckForDoubleQuote(char *str) {
+ int doubleQuoteFound;
+ // scan through arguments, see if there is a double quote for a string
+ // argument
+ doubleQuoteFound = 0;
+ while (*str != 0) {
+ if (*str == '\"') {
+ doubleQuoteFound = 1;
+ break;
+ }
+ str++;
+ }
+ return doubleQuoteFound;
+}
+
+//******************************************************************************
+void ExtractDoubleQuoteStr(char *src, char *dst) {
+ int start;
+
+ dst[0] = 0;
+ start = 0;
+ while (*src != 0) {
+ // look for start
+ if ((*src == '\"') && (start == 0)) {
+ start = 1;
+ src++;
+ continue;
+ }
+ // look for end
+ if ((*src == '\"') && (start == 1)) {
+ *dst = 0; // terminate the string
+ break;
+ }
+ if (start == 1) {
+ *dst = *src;
+ dst++;
+ }
+ src++;
+ }
+}
+
+//******************************************************************************
+void RPC_call_test(void) {
+ int doubleQuoteFound;
+ char doubleQuoteStr[64];
+ char *request = "/Logging/AppendMissionCmd \"BMP280 InitStart 1\"";
+
+ // scan through arguments, see if there is a double quote for a string
+ // argument
+ doubleQuoteFound = CheckForDoubleQuote(request);
+ if (doubleQuoteFound) {
+ ExtractDoubleQuoteStr(request, doubleQuoteStr);
+ }
+}
+
+//******************************************************************************
+void RPC_call(char *request, char *reply) {
+ const char slash[2] = "/";
+ const char space[2] = " ";
+ char *objectName;
+ char *methodName;
+ char doubleQuoteStr[64];
+ char requestCpy[128];
+ char *token;
+ int argIndex;
+ int resultIndex;
+ int doubleQuoteFound;
+ struct RPC_registeredProcedure *procedurePtr;
+
+ // clear out the reply
+ reply[0] = 0;
+ // copy the request for scanning and extraction later
+ strcpy(requestCpy, request);
+ // check for beginning forward slash
+ if (request[0] != '/') {
+ return;
+ }
+ // check for only a forward slash
+ if (request[0] == '/' && request[1] == 0) {
+ SendCommandList(reply);
+ return;
+ }
+ strcat(request, " ");
+ // get the object name
+ token = strtok(request, slash);
+ // token = GetToken(request, tokenBuffer, 1, '/');
+ objectName = token;
+ if (objectName == NULL)
+ return; // must have an object name
+ // get the method name
+ token = strtok(NULL, space);
+ methodName = token;
+ if (methodName == NULL)
+ return; // must have a method name
+
+ // scan through arguments, see if there is a double quote for a string
+ // argument
+ doubleQuoteFound = CheckForDoubleQuote(requestCpy);
+
+ if (doubleQuoteFound == 0) {
+ // walk through arguments
+ argIndex = 0;
+ token = strtok(NULL, space);
+ while (token != NULL) {
+ // save this arg in array
+ strcpy(args[argIndex++], token);
+ // read next token arg if any
+ token = strtok(NULL, space);
+ }
+ // terminate the end of the string array with an empty string
+ strcpy(args[argIndex], "\0");
+ strcpy(results[0], "\0");
+ } else {
+ // grab out the double quote string
+ ExtractDoubleQuoteStr(requestCpy, doubleQuoteStr);
+ argIndex = 0;
+ // token = strtok(NULL, quote);
+ strcpy(args[argIndex++], doubleQuoteStr);
+ }
+
+ //
+ // alias the MAX30001 and MAX30003 names
+ //
+ if (strcmp(objectName, MAX30003_NAME) == 0) {
+ strcpy(objectName, MAX30001_NAME);
+ }
+
+ procedurePtr = RPC_lookup(objectName, methodName);
+ if (procedurePtr != NULL) {
+ // printf("RPC_call: %s processing\n",requestCpy);
+ procedurePtr->func(args, results);
+ } else {
+ printf("RPC_call: %s not found\n", requestCpy);
+ // printf("Unable to lookup %s %s", objectName, methodName);
+ }
+
+ // loop while (if) there are results to return
+ resultIndex = 0;
+ strcpy(reply, "\0");
+ while (results[resultIndex][0] != '\0') {
+ strcat(reply, results[resultIndex++]);
+ strcat(reply, " ");
+ }
+ strcat(reply, "\r\n");
+}
+
+//******************************************************************************
+void RPC_ProcessCmds(char *cmds) {
+ char cmd[32 * 32];
+ char *ptrCmds;
+ char reply[512];
+ ptrCmds = cmds;
+
+ while (*ptrCmds != 0) {
+ ptrCmds = ParseUntilCRLF(ptrCmds, cmd, sizeof(cmd));
+ if (*cmd != 0) {
+ RPC_call(cmd, reply);
+ }
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/HSP/RpcServer/RpcServer.h Tue Oct 25 15:22:11 2016 +0000 @@ -0,0 +1,66 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ +#ifndef _RPCSERVER_H_ +#define _RPCSERVER_H_ + +#include "mbed.h" +#include "RpcFifo.h" +#include "Device_Logging.h" + +/** +* @brief Reads the Version of the HSP FCache_Writel +*/ +int System_ReadVer(char argStrs[32][32], char replyStrs[32][32]); +/** +* @brief Reads the built time of the RPC FW +*/ +int System_ReadBuildTime(char argStrs[32][32], char replyStrs[32][32]); + +void RPC__init(void); +void RPC__call(char *request, char *reply); +fifo_t *GetUSBIncomingFifo(void); +fifo_t *GetStreamOutFifo(void); +/** +* @brief Batch process RPC commands +*/ +void RPC_ProcessCmds(char *cmds); +/** +* @brief Initialize the RPC server with all of the commands that it supports +*/ +void RPC_init(void); +/** +* @brief Initialize the RPC server with all of the commands that it supports +*/ +void RPC_call(char *request, char *reply); + +#endif // _RPCSERVER_H_
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/RpcServer/Streaming.cpp Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,187 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+#include "RpcServer.h"
+#include "RpcFifo.h"
+#include "Streaming.h"
+#include "Peripherals.h"
+#include "Test_MAX30101.h"
+#include "Test_MAX30001.h"
+#include "MAX30001.h"
+#include "MAX30101.h"
+#include "Peripherals.h"
+
+bool streaming = FALSE;
+bool dataLogging = FALSE;
+
+/**
+* @brief Encodes a 0x55 0xAA signature and a simple checksum to the id byte in
+* the 32 bit field
+* @param id Streaming ID
+*/
+uint32_t StreamIdChecksumCalculate(uint32_t id) {
+ uint32_t sum;
+ uint32_t calculated;
+ sum = 0x55;
+ sum += 0xAA;
+ sum += id;
+ sum &= 0xFF;
+ sum = sum << 8;
+ calculated = 0x55AA0000 + sum + id;
+ return calculated;
+}
+
+/**
+* @brief Creates a packet that will be streamed via USB or saved into flash
+* datalog memory
+* @brief the packet created will be inserted into a fifo to be streamed at a
+* later time
+* @param id Streaming ID
+* @param buffer Pointer to a uint32 array that contains the data to include in
+* the packet
+* @param number Number of elements in the buffer
+*/
+void StreamPacketUint32(uint32_t id, uint32_t *buffer, uint32_t number) {
+ uint32_t checksumId;
+ if (streaming == TRUE || dataLogging == TRUE) {
+ checksumId = StreamIdChecksumCalculate(id);
+ StreamFifoId(checksumId);
+ StreamFifoTimeStamp();
+ StreamFifoLength(number);
+ StreamFifoUint32Array(buffer, number);
+ }
+ if (testing_max30001 == 1) {
+ if (id == MAX30001_DATA_ECG)
+ testing_ecg_flags[TESTING_ECG_FLAG] = 1;
+ if (id == MAX30001_DATA_BIOZ)
+ testing_ecg_flags[TESTING_BIOZ_FLAG] = 1;
+ if (id == MAX30001_DATA_PACE)
+ testing_ecg_flags[TESTING_PACE_FLAG] = 1;
+ if (id == MAX30001_DATA_RTOR)
+ testing_ecg_flags[TESTING_RTOR_FLAG] = 1;
+ }
+ if (testing_max30101 == 1) {
+ if (id == (MAX30101_OXIMETER_DATA + 1))
+ testing_max30101_flags[TESTING_HR_FLAG] = 1;
+ if (id == (MAX30101_OXIMETER_DATA + 2))
+ testing_max30101_flags[TESTING_SPO2_FLAG] = 1;
+ if (id == (MAX30101_OXIMETER_DATA + 3))
+ testing_max30101_flags[TESTING_MULTI_FLAG] = 1;
+ }
+}
+
+/**
+* @brief Insert a buffer into the out going fifo
+* @param buffer Array of uint32 to send to the fifo
+* @param len Length of the array
+*/
+int StreamFifoUint32Array(uint32_t buffer[], uint32_t len) {
+ int status;
+ uint32_t i;
+ for (i = 0; i < len; i++) {
+ status = fifo_put32(GetStreamOutFifo(), buffer[i]);
+ if (status == -1) {
+ printf("FIFO_OF!");
+ fflush(stdout);
+ while (1)
+ ;
+ }
+ }
+ return 0;
+}
+
+/**
+* @brief Insert a timestamp into the out going fifo
+*/
+int StreamFifoTimeStamp(void) {
+ int status;
+ // uint32_t timer = timestamp_GetCurrent(); //RTC_GetVal();
+ uint32_t timer = (uint32_t)Peripherals::timestampTimer()->read_us();
+ status = fifo_put32(GetStreamOutFifo(), timer);
+ if (status == -1) {
+ printf("FIFO_OF!");
+ fflush(stdout);
+ while (1)
+ ;
+ }
+ return 0;
+}
+
+/**
+* @brief Insert a packet id into the out going fifo
+* @param id The uint32 packet id
+*/
+int StreamFifoId(uint32_t id) {
+ int status;
+ status = fifo_put32(GetStreamOutFifo(), id);
+ if (status == -1) {
+ printf("FIFO_OF!");
+ fflush(stdout);
+ while (1)
+ ;
+ }
+ return 0;
+}
+
+/**
+* @brief Insert a length value into the out going fifo
+* @param length A uint32 number representing a length
+*/
+int StreamFifoLength(uint32_t length) {
+ int status;
+ status = fifo_put32(GetStreamOutFifo(), length);
+ if (status == -1) {
+ printf("FIFO_OF!");
+ fflush(stdout);
+ while (1)
+ ;
+ }
+ return 0;
+}
+
+/**
+* @brief Return a value that indicates if the system is streaming data
+* @returns Returns a one or zero value
+*/
+uint8_t IsStreaming(void) { return streaming; }
+
+/**
+* @brief Set a flag to indicate if streaming is enabled
+* @param state A one or zero value
+*/
+void SetStreaming(uint8_t state) { streaming = state; }
+
+/**
+* @brief Set a flag to indicate if datalogging is enabled
+* @param state A one or zero value
+*/
+void SetDataLoggingStream(uint8_t state) { dataLogging = state; }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/HSP/RpcServer/Streaming.h Tue Oct 25 15:22:11 2016 +0000 @@ -0,0 +1,94 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ +#ifndef _STREAMING_H_ +#define _STREAMING_H_ + +#include "mbed.h" + +#define PACKET_LIS2DH 0x20 + +#define PACKET_MAX30205_TEMP_TOP 0x40 +#define PACKET_MAX30205_TEMP_BOTTOM 0x50 +#define PACKET_BMP280_PRESSURE 0x60 +#define PACKET_LSM6DS3_ACCEL 0x70 +#define PACKET_MAX30205_TEMP 0x80 +#define PACKET_NOP 0x90 + +/** +* @brief Creates a packet that will be streamed via USB or saved into flash +* datalog memory +* @brief the packet created will be inserted into a fifo to be streamed at a +* later time +* @param id Streaming ID +* @param buffer Pointer to a uint32 array that contains the data to include in +* the packet +* @param number Number of elements in the buffer +*/ +void StreamPacketUint32(uint32_t id, uint32_t *buffer, uint32_t number); +/** +* @brief Insert a buffer into the out going fifo +* @param buffer Array of uint32 to send to the fifo +* @param len Length of the array +*/ +int StreamFifoUint32Array(uint32_t buffer[], uint32_t len); +/** +* @brief Insert a timestamp into the out going fifo +*/ +int StreamFifoTimeStamp(void); +/** +* @brief Insert a packet id into the out going fifo +* @param id The uint32 packet id +*/ +int StreamFifoId(uint32_t id); +/** +* @brief Return a value that indicates if the system is streaming data +* @returns Returns a one or zero value +*/ +uint8_t IsStreaming(void); +/** +* @brief Set a flag to indicate if streaming is enabled +* @param state A one or zero value +*/ +void SetStreaming(uint8_t state); +/** +* @brief Set a flag to indicate if datalogging is enabled +* @param state A one or zero value +*/ +void SetDataLoggingStream(uint8_t state); +/** +* @brief Insert a length value into the out going fifo +* @param length A uint32 number representing a length +*/ +int StreamFifoLength(uint32_t length); + +#endif // _STREAMING_H_
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/RpcServer/StringHelper.cpp Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,240 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+#include "mbed.h"
+#include "StringHelper.h"
+
+/**
+* @brief Process an array of hex alpha numeric strings representing arguments of
+* type uint8
+* @param args Array of strings to process
+* @param argsUintPtr Pointer of uint8 to save converted arguments
+* @param numberOf Number of strings to convert
+*/
+void ProcessArgs(char args[32][32], uint8_t *argsUintPtr, int numberOf) {
+ int i;
+ int val;
+ for (i = 0; i < numberOf; i++) {
+ sscanf(args[i], "%x", &val);
+ argsUintPtr[i] = (uint8_t)val;
+ }
+}
+
+/**
+* @brief Process an array of hex alpha numeric strings representing arguments of
+* type uint32
+* @param args Array of strings to process
+* @param argsUintPtr Pointer of uint32 to save converted arguments
+* @param numberOf Number of strings to convert
+*/
+void ProcessArgs32(char args[32][32], uint32_t *argsUintPtr, int numberOf) {
+ int i;
+ int val;
+ for (i = 0; i < numberOf; i++) {
+ sscanf(args[i], "%x", &val);
+ argsUintPtr[i] = val;
+ }
+}
+
+/**
+* @brief Process an array of decimal numeric strings representing arguments of
+* type uint32
+* @param args Array of strings to process
+* @param argsUintPtr Pointer of uint32 to save converted arguments
+* @param numberOf Number of strings to convert
+*/
+void ProcessArgs32Dec(char args[32][32], uint32_t *argsUintPtr, int numberOf) {
+ int i;
+ int val;
+ for (i = 0; i < numberOf; i++) {
+ sscanf(args[i], "%d", &val);
+ argsUintPtr[i] = val;
+ }
+}
+
+/**
+* @brief Parse a single string in decimal format to a uint32 number
+* @param str String to process
+* @returns Returns the converted number of type uint32
+*/
+uint32_t ParseAsciiDecU32(char *str) {
+ uint32_t val;
+ sscanf(str, "%d", &val);
+ return val;
+}
+
+/**
+* @brief Parse a single string in hex format to a uint32 number
+* @param str String to process
+* @returns Returns the converted number of type uint32
+*/
+uint32_t ParseAsciiHexU32(char *str) {
+ uint32_t val;
+ sscanf(str, "%x", &val);
+ return val;
+}
+
+/**
+* @brief Process a string that is "embedded" within another string using the /"
+* delimiters
+* @brief Extract the string
+* @param str String to process
+* @returns Returns the string
+*/
+void ProcessString(char args[32][32], uint8_t *str, int numberOf) {
+ int i;
+ int start;
+ uint8_t *ptr;
+ uint8_t *strPtr;
+ ptr = (uint8_t *)args;
+ strPtr = str;
+ start = 0;
+ for (i = 0; i < numberOf; i++) {
+ if ((start == 0) && (*ptr == '/"')) {
+ start = 1;
+ ptr++;
+ continue;
+ }
+ if ((start == 1) && (*ptr == '/"')) {
+ break;
+ }
+ if (start == 1) {
+ *strPtr = *ptr;
+ strPtr++;
+ }
+ ptr++;
+ }
+ // terminate the string
+ *strPtr = 0;
+}
+
+/**
+* @brief Parse an incoming string until a CRLF is encountered, dst will contain
+* the parsed string
+* @param src source string to process
+* @param dst destination string to contain the parsed incoming string
+* @param length length of incoming src string
+* @returns updated pointer in src string
+*/
+char *ParseUntilCRLF(char *src, char *dst, int length) {
+ int i;
+ char *srcPtr;
+
+ srcPtr = src;
+ i = 0;
+ *dst = 0;
+ while ((*srcPtr != 0) && (*srcPtr != 13)) {
+ dst[i] = *srcPtr;
+ i++;
+ if (i >= length)
+ break;
+ srcPtr++;
+ }
+ if (*srcPtr == 13)
+ srcPtr++;
+ if (*srcPtr == 10)
+ srcPtr++;
+ dst[i] = 0; // terminate the string
+ return srcPtr;
+}
+
+/**
+* @brief Parse an incoming string hex value into an 8-bit value
+* @param str string to process
+* @returns 8-bit byte that is parsed from the string
+*/
+uint8_t StringToByte(char str[32]) {
+ int val;
+ uint8_t byt;
+ sscanf(str, "%x", &val);
+ byt = (uint8_t)val;
+ return byt;
+}
+
+/**
+* @brief Parse an incoming string hex value into 32-bit value
+* @param str string to process
+* @returns 32-bit value that is parsed from the string
+*/
+uint32_t StringToInt(char str[32]) {
+ int val;
+ uint32_t byt;
+ sscanf(str, "%x", &val);
+ byt = (uint32_t)val;
+ return byt;
+}
+
+/**
+* @brief Format a binary 8-bit array into a string
+* @param uint8Ptr byte buffer to process
+* @param numberOf number of bytes in the buffer
+* @param reply an array of strings to place the converted array values into
+*/
+void FormatReply(uint8_t *uint8Ptr, int numberOf, char reply[32][32]) {
+ int i;
+ for (i = 0; i < numberOf; i++) {
+ sprintf(reply[i], "%02X", uint8Ptr[i]);
+ }
+ strcpy(reply[i], "\0");
+}
+
+/**
+* @brief Format a binary 32-bit array into a string
+* @param uint32Ptr 32-bit value buffer to process
+* @param numberOf number of values in the buffer
+* @param reply an array of strings to place the converted array values into
+*/
+void FormatReply32(uint32_t *uint32Ptr, int numberOf, char reply[32][32]) {
+ int i;
+ for (i = 0; i < numberOf; i++) {
+ sprintf(reply[i], "%02X", uint32Ptr[i]);
+ }
+ strcpy(reply[i], "\0");
+}
+
+/**
+* @brief Format a binary 8-bit array into a string
+* @param data 8-bit value buffer to process
+* @param length number of values in the buffer
+* @param str output string buffer
+* @return output string
+*/
+char *BytesToHexStr(uint8_t *data, uint32_t length, char *str) {
+ uint32_t i;
+ char tmpStr[8];
+ str[0] = 0;
+ for (i = 0; i < length; i++) {
+ sprintf(tmpStr, "%02X ", data[i]);
+ strcat(str, tmpStr);
+ }
+ return str;
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/HSP/RpcServer/StringHelper.h Tue Oct 25 15:22:11 2016 +0000 @@ -0,0 +1,118 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ +#ifndef _STRINGHELPER_H_ +#define _STRINGHELPER_H_ + +#include "mbed.h" + +/** +* @brief Process an array of hex alpha numeric strings representing arguments of +* type uint8 +* @param args Array of strings to process +* @param argsUintPtr Pointer of uint8 to save converted arguments +* @param numberOf Number of strings to convert +*/ +void ProcessArgs(char args[32][32], uint8_t *argsUintPtr, int numberOf); +/** +* @brief Format a binary 8-bit array into a string +* @param uint8Ptr byte buffer to process +* @param numberOf number of bytes in the buffer +* @param reply an array of strings to place the converted array values into +*/ +void FormatReply(uint8_t *uint8Ptr, int numberOf, char reply[32][32]); +/** +* @brief Process an array of hex alpha numeric strings representing arguments of +* type uint32 +* @param args Array of strings to process +* @param argsUintPtr Pointer of uint32 to save converted arguments +* @param numberOf Number of strings to convert +*/ +void ProcessArgs32(char args[32][32], uint32_t *argsUintPtr, int numberOf); +/** +* @brief Process an array of decimal numeric strings representing arguments of +* type uint32 +* @param args Array of strings to process +* @param argsUintPtr Pointer of uint32 to save converted arguments +* @param numberOf Number of strings to convert +*/ +void ProcessArgs32Dec(char args[32][32], uint32_t *argsUintPtr, int numberOf); +/** +* @brief Format a binary 32-bit array into a string +* @param uint32Ptr 32-bit value buffer to process +* @param numberOf number of values in the buffer +* @param reply an array of strings to place the converted array values into +*/ +void FormatReply32(uint32_t *uint32Ptr, int numberOf, char reply[32][32]); +/** +* @brief Parse an incoming string hex value into an 8-bit value +* @param str string to process +* @returns 8-bit byte that is parsed from the string +*/ +uint8_t StringToByte(char str[32]); +/** +* @brief Parse an incoming string hex value into 32-bit value +* @param str string to process +* @returns 32-bit value that is parsed from the string +*/ +uint32_t StringToInt(char str[32]); +/** +* @brief Parse a single string in decimal format to a uint32 number +* @param str String to process +* @returns Returns the converted number of type uint32 +*/ +uint32_t ParseAsciiDecU32(char *str); +/** +* @brief Parse a single string in hex format to a uint32 number +* @param str String to process +* @returns Returns the converted number of type uint32 +*/ +uint32_t ParseAsciiHexU32(char *str); +/** +* @brief Format a binary 8-bit array into a string +* @param data 8-bit value buffer to process +* @param length number of values in the buffer +* @param str output string buffer +* @return output string +*/ +char *BytesToHexStr(uint8_t *data, uint32_t length, char *str); +/** +* @brief Parse an incoming string until a CRLF is encountered, dst will contain +* the parsed string +* @param src source string to process +* @param dst destination string to contain the parsed incoming string +* @param length length of incoming src string +* @returns updated pointer in src string +*/ +char *ParseUntilCRLF(char *src, char *dst, int length); + +#endif // _STRINGHELPER_H_
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/RpcServer/StringInOut.cpp Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,195 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+#include "mbed.h"
+#include "USBSerial.h"
+#include "RpcFifo.h"
+#include "RpcServer.h"
+#include "StringInOut.h"
+#include "Peripherals.h"
+
+/// a running index that keeps track of where an incoming string has been
+/// buffered to
+static int lineBuffer_index = 0;
+/// a flag that keeps track of the state of accumulating a string
+static int getLine_State = GETLINE_WAITING;
+
+/**
+* @brief Place incoming USB characters into a fifo
+* @param data_IN buffer of characters
+* @param len length of data
+*/
+int fifoIncomingChars(uint8_t data_IN[], unsigned int len) {
+ int i;
+ for (i = 0; i < len; i++) {
+ fifo_put8(GetUSBIncomingFifo(), data_IN[i]);
+ }
+ return 0;
+}
+
+/**
+* @brief Check the USB incoming fifo to see if there is data to be read
+* @return 1 if there is data to be read, 0 if data is not available
+*/
+int isReadReady(void) {
+ if (fifo_empty(GetUSBIncomingFifo()) == 0)
+ return 1;
+ return 0;
+}
+
+/**
+* @brief Clear the incoming USB read fifo
+*/
+void clearOutReadFifo(void) { fifo_clear(GetUSBIncomingFifo()); }
+
+/**
+* @brief Block until a character can be read from the USB
+* @return the character read
+*/
+char getch(void) {
+ uint8_t ch;
+ // block until char is ready
+ while (isReadReady() == 0) {
+ }
+ // read a char from buffer
+ fifo_get8(GetUSBIncomingFifo(), &ch);
+ return ch;
+}
+
+/**
+* @brief Place incoming USB characters into a fifo
+* @param lineBuffer buffer to place the incoming characters
+* @param bufferLength length of buffer
+* @return GETLINE_WAITING if still waiting for a CRLF, GETLINE_DONE
+*/
+int getLine(char *lineBuffer, int bufferLength) {
+ uint8_t ch;
+
+ USBSerial *serial = Peripherals::usbSerial();
+ if (getLine_State == GETLINE_DONE) {
+ getLine_State = GETLINE_WAITING;
+ }
+ if (serial->available() != 0) {
+ ch = serial->_getc();
+ if (ch != 0x0A && ch != 0x0D) {
+ lineBuffer[lineBuffer_index++] = ch;
+ }
+ if (ch == 0x0D) {
+ lineBuffer[lineBuffer_index++] = 0;
+ lineBuffer_index = 0;
+ getLine_State = GETLINE_DONE;
+ }
+ if (lineBuffer_index > bufferLength) {
+ lineBuffer[bufferLength - 1] = 0;
+ getLine_State = GETLINE_DONE;
+ }
+ }
+ return getLine_State;
+}
+
+/**
+* @brief Block until a fixed number of characters has been accumulated from the
+* incoming USB
+* @param lineBuffer buffer to place the incoming characters
+* @param maxLength length of buffer
+*/
+void getStringFixedLength(uint8_t *lineBuffer, int maxLength) {
+ uint8_t ch;
+ int index = 0;
+ // block until maxLength is captured
+ while (1) {
+ ch = getch();
+ lineBuffer[index++] = ch;
+ if (index == maxLength)
+ return;
+ }
+}
+
+/**
+* @brief Output a string out the USB serial port
+* @param str output this str the USB channel
+*/
+int putStr(const char *str) {
+ Peripherals::usbSerial()->printf("%s", str); // fflush(stdout);
+ // uint8_t *ptr;
+ // uint8_t buffer[256];
+ // int index = 0;
+ /* int length;
+ ptr = (uint8_t *)str;
+ length = strlen(str);
+
+ Peripherals::usbSerial()->writeBlock(ptr,length); */
+ return 0;
+}
+
+/**
+* @brief Outut an array of bytes out the USB serial port
+* @param data buffer to output
+* @param length length of buffer
+*/
+int putBytes(uint8_t *data, uint32_t length) {
+ int sendThis = 64;
+ int sent = 0;
+ int thisLeft;
+ uint8_t *ptr = data;
+ if (length < 64)
+ sendThis = length;
+ do {
+ Peripherals::usbSerial()->writeBlock(ptr, sendThis);
+ sent += sendThis;
+ ptr += sendThis;
+ thisLeft = length - sent;
+ sendThis = 64;
+ if (thisLeft < 64)
+ sendThis = thisLeft;
+ } while (sent != length);
+ return 0;
+}
+
+/**
+* @brief Outut 256 byte blocks out the USB serial using writeBlock bulk
+* transfers
+* @param data buffer of blocks to output
+* @param length length of 256-byte blocks
+*/
+int putBytes256Block(uint8_t *data, int numberBlocks) {
+ int i;
+ uint8_t *ptr;
+ ptr = data;
+ const int BLOCK_SIZE = 32;
+ const int FLASH_PAGE_SIZE = 256;
+ for (i = 0; i < numberBlocks * (FLASH_PAGE_SIZE / BLOCK_SIZE); i++) {
+ Peripherals::usbSerial()->writeBlock(ptr, BLOCK_SIZE);
+ ptr += BLOCK_SIZE;
+ }
+ return 0;
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/HSP/RpcServer/StringInOut.h Tue Oct 25 15:22:11 2016 +0000 @@ -0,0 +1,94 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ +#ifndef _STRINGINOUT_H_ +#define _STRINGINOUT_H_ + +#include "mbed.h" +#include "USBSerial.h" + +/// indicates that a string up to a CRLF is being accumulated +#define GETLINE_WAITING 1 +/// indicates that a string is being processes +#define GETLINE_PROCESSING 2 +/// indicates that a CRLF string has been buffered and can be processed +#define GETLINE_DONE 3 + +/** +* @brief Clear the incoming USB read fifo +*/ +void clearOutReadFifo(void); +/** +* @brief Block until a character can be read from the USB +* @return the character read +*/ +char getch(void); +/** +* @brief Place incoming USB characters into a fifo +* @param lineBuffer buffer to place the incoming characters +* @param bufferLength length of buffer +* @return GETLINE_WAITING if still waiting for a CRLF, GETLINE_DONE +*/ +int getLine(char *lineBuffer, int bufferLength); +/** +* @brief Block until a fixed number of characters has been accumulated from the +* incoming USB +* @param lineBuffer buffer to place the incoming characters +* @param maxLength length of buffer +*/ +void getStringFixedLength(uint8_t *lineBuffer, int maxLength); +/** +* @brief Output a string out the USB serial port +* @param str output this str the USB channel +*/ +int putStr(const char *str); +/** +* @brief Place incoming USB characters into a fifo +* @param data_IN buffer of characters +* @param len length of data +*/ +int fifoIncomingChars(uint8_t data_IN[], unsigned int len); +/** +* @brief Outut an array of bytes out the USB serial port +* @param data buffer to output +* @param length length of buffer +*/ +int putBytes(uint8_t *data, uint32_t length); +/** +* @brief Outut 256 byte blocks out the USB serial using writeBlock bulk +* transfers +* @param data buffer of blocks to output +* @param length length of 256-byte blocks +*/ +int putBytes256Block(uint8_t *data, int numberBlocks); + +#endif // _STRINGINOUT_H_
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/HSP/System/Peripherals.cpp Tue Oct 25 15:22:11 2016 +0000 @@ -0,0 +1,50 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ +#include "Peripherals.h" + +I2C *Peripherals::mI2c1 = NULL; +I2C *Peripherals::mI2c2 = NULL; +USBSerial *Peripherals::mUSBSerial = NULL; +MAX30101 *Peripherals::mMAX30101 = NULL; +MAX30001 *Peripherals::mMAX30001 = NULL; +BMP280 *Peripherals::mBMP280 = NULL; +HspLed *Peripherals::mHspLed = NULL; +MAX30205 *Peripherals::mMAX30205_top = NULL; +MAX30205 *Peripherals::mMAX30205_bottom = NULL; +LIS2DH *Peripherals::mLIS2DH = NULL; +Timer *Peripherals::mTimestampTimer = NULL; +S25FS512 *Peripherals::mS25FS512 = NULL; +PushButton *Peripherals::mPushButton = NULL; +BLE *Peripherals::mBLE = NULL; +MAX14720 *Peripherals::mMAX14720 = NULL; +HspBLE *Peripherals::mhspBLE = NULL;
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/System/Peripherals.h Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,126 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+#ifndef _PERIPHERALS_H_
+#define _PERIPHERALS_H_
+
+#include "mbed.h"
+#include "USBSerial.h"
+#include "MAX30101.h"
+#include "HspLed.h"
+#include "MAX30205.h"
+#include "LIS2DH.h"
+#include "MAX30001.h"
+#include "BMP280.h"
+#include "S25FS512.h"
+#include "PushButton.h"
+#include "BLE.h"
+#include "MAX14720.h"
+#include "HspBLE.h"
+
+/**
+* This static class is used as a central locatoin for all devices on the HSP platform
+* it gives (in-effect) a singleton interface for each device so that anywhere in code
+* one can reference on of these devices
+*/
+class Peripherals {
+public:
+ static USBSerial *setUSBSerial(USBSerial * device) { mUSBSerial = device; return device; }
+ static USBSerial *usbSerial(void) { return mUSBSerial; }
+
+ static MAX30101 *max30101(void) { return mMAX30101; }
+ static MAX30101 *setMAX30101(MAX30101 *device) { mMAX30101 = device; return device; }
+
+ static MAX30205 *max30205_top(void) { return mMAX30205_top; }
+ static MAX30205 *setMAX30205_top(MAX30205 *device) { mMAX30205_top = device; return device; }
+
+ static MAX30205 *max30205_bottom(void) { return mMAX30205_bottom; }
+ static MAX30205 *setMAX30205_bottom(MAX30205 *device) { mMAX30205_bottom = device; return device; }
+
+ static HspLed *hspLed(void) { return mHspLed; }
+ static HspLed *setHspLed(HspLed *device) { mHspLed = device; return device; }
+
+ static LIS2DH *lis2dh(void) { return mLIS2DH; }
+ static LIS2DH *setLIS2DH(LIS2DH *device) { mLIS2DH = device; return device; }
+
+ static MAX30001 *max30001(void) { return mMAX30001; }
+ static MAX30001 *setMAX30001(MAX30001 *device) { mMAX30001 = device; return device; }
+
+ static BMP280 *bmp280(void) { return mBMP280; }
+ static BMP280 *setBMP280(BMP280 *device) { mBMP280 = device; return device; }
+
+ static Timer *timestampTimer(void) { return mTimestampTimer; }
+ static Timer *setTimestampTimer(Timer *timer) { mTimestampTimer = timer; return timer; }
+
+ static I2C *i2c1(void) { return mI2c1; }
+ static I2C *setI2c1(I2C *i2cPort) { mI2c1 = i2cPort; return i2cPort; }
+
+ static I2C *i2c2(void) { return mI2c2; }
+ static I2C *setI2c2(I2C *i2cPort) { mI2c2 = i2cPort; return i2cPort; }
+
+ static S25FS512 *s25FS512(void) { return mS25FS512; }
+ static S25FS512 *setS25FS512(S25FS512 *s25FS512) { mS25FS512 = s25FS512; return s25FS512; }
+
+ static PushButton *pushButton(void) { return mPushButton; }
+ static PushButton *setPushButton(PushButton *pushButton) { mPushButton = pushButton; return pushButton; }
+
+ static BLE *ble(void) { return mBLE; }
+ static BLE *setBLE(BLE *_ble) { mBLE = _ble; return _ble; }
+
+ static HspBLE *hspBLE(void) { return mhspBLE; }
+ static HspBLE *setHspBLE(HspBLE *_hspBLE) { mhspBLE = _hspBLE; return _hspBLE; }
+
+ static MAX14720 *max14720(void) { return mMAX14720; }
+ static MAX14720 *setMAX14720(MAX14720 *_MAX14720) { mMAX14720 = _MAX14720; return _MAX14720; }
+
+private:
+ static I2C *mI2c1;
+ static I2C *mI2c2;
+ static USBSerial *mUSBSerial;
+ static MAX30101 *mMAX30101;
+ static MAX30001 *mMAX30001;
+ static BMP280 *mBMP280;
+ static HspLed *mHspLed;
+ static Serial *mSerial;
+ static MAX30205 *mMAX30205_top;
+ static MAX30205 *mMAX30205_bottom;
+ static LIS2DH *mLIS2DH;
+ static Timer *mTimestampTimer;
+ static S25FS512 *mS25FS512;
+ static PushButton *mPushButton;
+ static BLE *mBLE;
+ static MAX14720 *mMAX14720;
+ static HspBLE *mhspBLE;
+};
+
+#endif // _PERIPHERALS_H_
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/System/System.cpp Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,43 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+#include "mbed.h"
+
+//******************************************************************************
+void I2CM_Init_Reset(uint8_t index, int speed) {
+ mxc_i2cm_regs_t *regs = MXC_I2CM_GET_I2CM(index);
+ /* reset module */
+ regs->ctrl = MXC_F_I2CM_CTRL_MSTR_RESET_EN;
+ regs->ctrl = 0;
+ /* enable tx_fifo and rx_fifo */
+ regs->ctrl |= (MXC_F_I2CM_CTRL_TX_FIFO_EN | MXC_F_I2CM_CTRL_RX_FIFO_EN);
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/HSP/System/System.h Tue Oct 25 15:22:11 2016 +0000 @@ -0,0 +1,41 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ +#ifndef _SYSTEM_H_ +#define _SYSTEM_H_ + +/** +* This issues a reset to the I2C Peripheral +*/ +void I2CM_Init_Reset(uint8_t index, int speed); + +#endif // _SYSTEM_H_
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/Test/Test_BMP280.cpp Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,61 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+#include "Test_BMP280.h"
+#include "Test_Utilities.h"
+
+//******************************************************************************
+void test_BMP280(void (*outputString)(const char *)) {
+ char tempStr[32];
+ int pass;
+ uint8_t readId;
+ BMP280 *bmp280;
+ bmp280 = Peripherals::bmp280();
+
+ // display header
+ outputString("Testing BMP280|");
+
+ // read id test
+ outputString("Read ID: ");
+ readId = bmp280->ReadId();
+ if (readId == BMP280_READID)
+ pass = 1;
+ else
+ pass = 0;
+ sprintf(tempStr, " (%02X)|", readId);
+ outputString(tempStr);
+ _printPassFail(pass, 0, outputString);
+
+ // final results
+ outputString("Result: ");
+ _printPassFail(pass, 0, outputString);
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/HSP/Test/Test_BMP280.h Tue Oct 25 15:22:11 2016 +0000 @@ -0,0 +1,46 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ +#ifndef _TEST_BMP280_H_ +#define _TEST_BMP280_H_ + +#include "mbed.h" +#include "BMP280.h" +#include "Peripherals.h" + +/** +* @brief Selftest the BMP280 and output the results as strings using the pointer function +* @param outputString Pointer to the function used to output the test results +*/ +void test_BMP280(void (*outputString)(const char *)); + +#endif / _TEST_BMP280_H_ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/Test/Test_LIS2DH.cpp Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,64 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+#include "Test_LIS2DH.h"
+#include "Test_Utilities.h"
+
+//******************************************************************************
+void test_LIS2DH(void (*outputString)(const char *)) {
+ char tempStr[32];
+ int totalPass = 1;
+ int pass;
+ uint8_t readId;
+ LIS2DH *lis2dh;
+ lis2dh = Peripherals::lis2dh();
+
+ // display header
+ outputString("Testing LIS2DH|");
+
+ // read id test @ 400kHz
+ outputString("Read ID @ 400kHz: ");
+ readId = lis2dh->readId();
+ if (readId == LIS2DH_READID)
+ pass = 1;
+ else
+ pass = 0;
+ _printPassFail(pass, 0, outputString);
+ totalPass &= pass;
+ sprintf(tempStr, " (%02X)|", readId);
+ outputString(tempStr);
+ // end test at 100kHz
+
+ // final results
+ outputString("Result: ");
+ _printPassFail(totalPass, 0, outputString);
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/HSP/Test/Test_LIS2DH.h Tue Oct 25 15:22:11 2016 +0000 @@ -0,0 +1,46 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ +#ifndef _TEST_LIS2DH_H_ +#define _TEST_LIS2DH_H_ + +#include "mbed.h" +#include "LIS2DH.h" +#include "Peripherals.h" + +/** +* @brief Selftest the LIS2DH and output the results as strings using the pointer function +* @param outputString Pointer to the function used to output the test results +*/ +void test_LIS2DH(void (*outputString)(const char *)); + +#endif /* _TEST_LIS2DH_H_ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/Test/Test_MAX30001.cpp Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,169 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+#include "Test_MAX30001.h"
+#include "Test_Utilities.h"
+
+uint32_t testing_max30001 = 0;
+uint32_t testing_ecg_flags[4];
+
+//******************************************************************************
+void test_MAX30001(void (*outputString)(const char *)) {
+ int totalPass = 1;
+ int pass;
+ uint32_t foundEcg = 0;
+ uint32_t foundBioz = 0;
+ uint32_t foundPace = 0;
+ uint32_t foundRtoR = 0;
+ uint32_t id;
+ char str2[128];
+ int partVersion; // 0 = 30004
+ // 1 = 30001
+ // 2 = 30002
+ // 3 = 30003
+ Timer timer;
+ MAX30001 *max30001;
+ max30001 = Peripherals::max30001();
+
+ // read the id
+ max30001->max30001_reg_read(MAX30001::INFO, &id);
+ // read id twice because it needs to be read twice
+ max30001->max30001_reg_read(MAX30001::INFO, &id);
+ partVersion = id >> 12;
+ partVersion = partVersion & 0x3;
+
+ // display header
+ if (partVersion == 0)
+ outputString("Testing MAX30004|");
+ if (partVersion == 1) {
+ outputString("Testing MAX30001|");
+ outputString("Testing ECG, RtoR, BioZ, PACE|");
+ }
+ if (partVersion == 2)
+ outputString("Testing MAX30002|");
+ if (partVersion == 3) {
+ outputString("Testing MAX30003|");
+ outputString("Only Testing ECG and RtoR|");
+ }
+ sprintf(str2, "Device ID = 0x%06X|", id);
+ outputString(str2);
+
+ // clear testing flags
+ testing_ecg_flags[TESTING_ECG_FLAG] = 0;
+ testing_ecg_flags[TESTING_BIOZ_FLAG] = 0;
+ testing_ecg_flags[TESTING_PACE_FLAG] = 0;
+ testing_ecg_flags[TESTING_RTOR_FLAG] = 0;
+
+ // start streams
+ testing_max30001 = 1;
+ if (partVersion == 1)
+ outputString("Start Streaming ECG, RtoR, PACE, BIOZ, CAL enabled, "
+ "verifying streams...|");
+ if (partVersion == 3)
+ outputString(
+ "Start Streaming ECG, RtoR, CAL enabled, verifying streams...|");
+ // max30001_CAL_InitStart(0b1, 0b1, 0b1, 0b011, 0x7FF, 0b0);
+ max30001->max30001_CAL_InitStart(0b1, 0b1, 0b1, 0b011, 0x7FF, 0b0);
+ max30001->max30001_ECG_InitStart(0b1, 0b1, 0b1, 0b0, 0b10, 0b11, 0x1F, 0b00,
+ 0b00, 0b0, 0b01);
+ if (partVersion == 1)
+ max30001->max30001_PACE_InitStart(0b1, 0b0, 0b0, 0b1, 0x0, 0b0, 0b00, 0b0,
+ 0b0);
+ if (partVersion == 1)
+ max30001->max30001_BIOZ_InitStart(0b1, 0b1, 0b1, 0b10, 0b11, 0b00, 7, 0b0,
+ 0b010, 0b0, 0b10, 0b00, 0b00, 2, 0b0,
+ 0b111, 0b0000);
+ max30001->max30001_RtoR_InitStart(0b1, 0b0011, 0b1111, 0b00, 0b0011, 0b000001,
+ 0b00, 0b000, 0b01);
+ max30001->max30001_Rbias_FMSTR_Init(0b01, 0b10, 0b1, 0b1, 0b00);
+ max30001->max30001_synch();
+
+ // look for each stream
+ timer.start();
+ while (1) {
+ if ((foundEcg == 0) && (testing_ecg_flags[TESTING_ECG_FLAG] == 1)) {
+ foundEcg = 1;
+ outputString("ECG Stream: PASS|");
+ }
+ if ((foundBioz == 0) && (testing_ecg_flags[TESTING_BIOZ_FLAG] == 1)) {
+ foundBioz = 1;
+ outputString("Bioz Stream: PASS|");
+ }
+ if ((foundPace == 0) && (testing_ecg_flags[TESTING_PACE_FLAG] == 1)) {
+ foundPace = 1;
+ outputString("PACE Stream: PASS|");
+ }
+ if ((foundRtoR == 0) && (testing_ecg_flags[TESTING_RTOR_FLAG] == 1)) {
+ foundRtoR = 1;
+ outputString("RtoR Stream: PASS|");
+ }
+ if ((foundEcg == 1) && (foundBioz == 1) && (foundPace == 1) &&
+ (foundRtoR == 1) && (partVersion == 1)) {
+ break;
+ }
+ if ((foundEcg == 1) && (foundRtoR == 1) && (partVersion == 3)) {
+ break;
+ }
+ if (timer.read() >= TESTING_MAX30001_TIMEOUT_SECONDS) {
+ break;
+ }
+ }
+ timer.stop();
+ if (foundEcg == 0) {
+ outputString("ECG Stream: FAIL|");
+ totalPass &= pass;
+ }
+ if ((foundBioz == 0) && (partVersion == 1)) {
+ outputString("Bioz Stream: FAIL|");
+ totalPass &= pass;
+ }
+ if ((foundPace == 0) && (partVersion == 1)) {
+ outputString("PACE Stream: FAIL|");
+ totalPass &= pass;
+ }
+ if (foundRtoR == 0) {
+ outputString("RtoR Stream: FAIL|");
+ totalPass &= pass;
+ }
+
+ // stop all streams
+ max30001->max30001_Stop_ECG();
+ if (partVersion == 1)
+ max30001->max30001_Stop_PACE();
+ if (partVersion == 1)
+ max30001->max30001_Stop_BIOZ();
+ max30001->max30001_Stop_RtoR();
+ testing_max30001 = 0;
+ // final results
+ outputString("Result: ");
+ _printPassFail(totalPass, 0, outputString);
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/HSP/Test/Test_MAX30001.h Tue Oct 25 15:22:11 2016 +0000 @@ -0,0 +1,56 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ +#ifndef _TEST_MAX30001_H_ +#define _TEST_MAX30001_H_ + +#include "mbed.h" +#include "MAX30001.h" +#include "Peripherals.h" + +#define TESTING_ECG_FLAG 0 +#define TESTING_BIOZ_FLAG 1 +#define TESTING_PACE_FLAG 2 +#define TESTING_RTOR_FLAG 3 + +#define TESTING_MAX30001_TIMEOUT_SECONDS 10 + +extern uint32_t testing_max30001; +extern uint32_t testing_ecg_flags[4]; + +/** +* @brief Selftest the MAX30001 and output the results as strings using the pointer function +* @param outputString Pointer to the function used to output the test results +*/ +void test_MAX30001(void (*outputString)(const char *)); + +#endif /* _TEST_MAX30101_H_ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/Test/Test_MAX30101.cpp Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,143 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+#include "Test_MAX30101.h"
+#include "Test_Utilities.h"
+
+uint32_t testing_max30101 = 0;
+uint32_t testing_max30101_flags[4];
+
+//******************************************************************************
+void test_MAX30101(void (*outputString)(const char *)) {
+ Timer timer;
+ int totalPass = 1;
+ int pass;
+ uint32_t foundHR = 0;
+ uint32_t foundSPO2 = 0;
+ uint32_t foundMULTI = 0;
+ MAX30101 *max30101;
+
+ max30101 = Peripherals::max30101();
+
+ // display header
+ outputString("Testing MAX30101|");
+
+ // clear testing flags
+ testing_max30101_flags[TESTING_HR_FLAG] = 0;
+ testing_max30101_flags[TESTING_SPO2_FLAG] = 0;
+ testing_max30101_flags[TESTING_MULTI_FLAG] = 0;
+ testing_max30101 = 1;
+
+ //
+ // start stream (HR)
+ //
+ outputString("Start HR Streaming...|");
+ max30101->HRmode_init(0x0, 0x00, 0x01, 0x03,
+ 0x33); // This is the HR mode only (IR LED only)
+ // look for (HR) streaming
+ timer.start();
+ while (1) {
+ if ((foundHR == 0) && (testing_max30101_flags[TESTING_HR_FLAG] == 1)) {
+ foundHR = 1;
+ outputString("HR Stream: PASS|");
+ break;
+ }
+ if (timer.read() >= TESTING_MAX30101_TIMEOUT_SECONDS) {
+ break;
+ }
+ }
+ if (foundHR == 0) {
+ outputString("HR Stream: FAIL|");
+ totalPass &= pass;
+ }
+ // stop stream
+ max30101->HRmode_stop();
+
+ //
+ // start stream (SPO2)
+ //
+ outputString("Start SPO2 Streaming...|");
+ max30101->SpO2mode_init(
+ 0xF, 0x00, 0x01, 0x03, 0x33,
+ 0x33); // This is the SpO2 mode only (Red and IR LED only)
+ // look for (SPO2) stream
+ timer.reset();
+ while (1) {
+ if ((foundSPO2 == 0) && (testing_max30101_flags[TESTING_SPO2_FLAG] == 1)) {
+ foundSPO2 = 1;
+ outputString("SPO2 Stream: PASS|");
+ break;
+ }
+ if (timer.read() >= TESTING_MAX30101_TIMEOUT_SECONDS) {
+ break;
+ }
+ }
+ if (foundSPO2 == 0) {
+ outputString("SPO2 Stream: FAIL|");
+ totalPass &= pass;
+ }
+ // stop stream
+ max30101->SpO2mode_stop();
+
+ //
+ // start stream (MULTI)
+ //
+ outputString("Start Multi Streaming...|");
+ max30101->Multimode_init(0x00, 0x00, 0x01, 0x03, 0x33, 0x33, 0x33, 0x01, 0x02,
+ 0x03, 0x00); // Up to 4 LED can be turned on over
+ // look for (SPO2) stream
+ timer.reset();
+ while (1) {
+ if ((foundMULTI == 0) &&
+ (testing_max30101_flags[TESTING_MULTI_FLAG] == 1)) {
+ foundMULTI = 1;
+ outputString("Multi Stream: PASS|");
+ break;
+ }
+ if (timer.read() >= TESTING_MAX30101_TIMEOUT_SECONDS) {
+ break;
+ }
+ }
+ if (foundMULTI == 0) {
+ outputString("Multi Stream: FAIL|");
+ totalPass &= pass;
+ }
+ // stop stream
+ max30101->Multimode_stop();
+
+ testing_max30101 = 0;
+
+ timer.stop();
+ // final results
+ outputString("Result: ");
+ _printPassFail(totalPass, 0, outputString);
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/HSP/Test/Test_MAX30101.h Tue Oct 25 15:22:11 2016 +0000 @@ -0,0 +1,55 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ +#ifndef _TEST_MAX30101_H_ +#define _TEST_MAX30101_H_ + +#include "mbed.h" +#include "MAX30101.h" +#include "Peripherals.h" + +#define TESTING_HR_FLAG 0 +#define TESTING_SPO2_FLAG 1 +#define TESTING_MULTI_FLAG 2 + +#define TESTING_MAX30101_TIMEOUT_SECONDS 2 + +extern uint32_t testing_max30101; +extern uint32_t testing_max30101_flags[4]; + +/** +* @brief Selftest the MAX30101 and output the results as strings using the pointer function +* @param outputString Pointer to the function used to output the test results +*/ +void test_MAX30101(void (*outputString)(const char *)); + +#endif /* _TEST_MAX30101_H_ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/Test/Test_MAX30205.cpp Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,58 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+#include "Test_MAX30205.h"
+#include "Test_Utilities.h"
+#include "MAX30205.h"
+#include "Peripherals.h"
+
+//******************************************************************************
+void test_MAX30205(MAX30205 *MAX30205, void (*outputString)(const char *)) {
+ uint16_t value;
+ char tempStr[32];
+ int pass;
+
+ outputString("Write Reg_THYST to 0x1234 @ 400kHz: ");
+ // i2cSetSpeed(MAX30205_I2CM_INSTANCE, I2CM_SPEED_100kHz);
+ MAX30205->reg_THYST_Write(0x1234);
+ outputString("Read Reg_THYST @ 400kHz: ");
+ // i2cSetSpeed(MAX30205_I2CM_INSTANCE, I2CM_SPEED_100kHz);
+ MAX30205->reg_THYST_Read(&value);
+ if (value == 0x1234)
+ pass = 1;
+ else
+ pass = 0;
+ //*totalPass &= *pass;
+ sprintf(tempStr, " (%04X)|", value);
+ outputString(tempStr);
+ _printPassFail(pass, 0, outputString);
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/HSP/Test/Test_MAX30205.h Tue Oct 25 15:22:11 2016 +0000 @@ -0,0 +1,45 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ +#ifndef _TEST_MAX30205_H_ +#define _TEST_MAX30205_H_ + +#include "mbed.h" +#include "MAX30205.h" + +/** +* @brief Selftest the MAX30101 and output the results as strings using the pointer function +* @param outputString Pointer to the function used to output the test results +*/ +void test_MAX30205(MAX30205 *MAX30205, void (*outputString)(const char *)); + +#endif /* _TEST_MAX30205_H_ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/Test/Test_S25FS512.cpp Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,111 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+#include "Test_S25FS512.h"
+#include "Test_Utilities.h"
+
+//******************************************************************************
+void test_S25FS512(void (*outputString)(const char *)) {
+ char tempStr[32];
+ uint8_t page[264];
+ int totalPass = 1;
+ int pass;
+ int status;
+ int i;
+ uint8_t data[128];
+ S25FS512 *s25FS512;
+
+ s25FS512 = Peripherals::s25FS512();
+
+ // display header
+ outputString("Testing S25FS512|");
+
+ // read id test
+ s25FS512->readIdentification(data, sizeof(data));
+ s25FS512->readIdentification(data, sizeof(data));
+ if ((data[1] == 0x01) && (data[2] == 0x02) && (data[3] == 0x19) &&
+ (data[4] == 0x4D)) {
+ sprintf(tempStr, "Read ID: Pass ");
+ outputString(tempStr);
+ } else {
+ sprintf(tempStr, "Read ID: Fail ");
+ outputString(tempStr);
+ totalPass = 0;
+ }
+ sprintf(tempStr, "(%02X%02X%02X%02X)|", data[1], data[2], data[3], data[4]);
+ outputString(tempStr);
+
+ if (totalPass == 1) {
+ // format sector 0
+ outputString("Formatting Sector 0, ");
+ s25FS512->sectorErase_Helper(0);
+
+ // verify format sector 0
+ outputString("Verifying Format of Sector 0: ");
+ s25FS512->readPages_Helper(0, 0, page, 0);
+ pass = s25FS512->isPageEmpty(page);
+ _printPassFail(pass, 1, outputString);
+ totalPass &= pass;
+
+ // fill page with pattern
+ for (i = 0; i < 256; i++) {
+ page[i] = i;
+ }
+ // write to page 0
+ outputString("Writing Page 0 to pattern, ");
+ s25FS512->writePage_Helper(0, page, 0);
+ // clear pattern in memory
+ for (i = 0; i < 256; i++) {
+ page[i] = 0x00;
+ }
+ // read back page and verify
+ outputString("Read Page Verify: ");
+ s25FS512->readPages_Helper(0, 0, page, 0);
+ // compare memory for pattern
+ pass = 1;
+ for (i = 0; i < 256; i++) {
+ if (page[i] != i)
+ pass = 0;
+ }
+ _printPassFail(pass, 1, outputString);
+ totalPass &= pass;
+
+ // format sector 0 to clean up after tests
+ s25FS512->sectorErase_Helper(0);
+ } else {
+ outputString("Read Id Failed, Skipping rest of test|");
+ }
+
+ // final results
+ outputString("Result: ");
+ _printPassFail(totalPass, 0, outputString);
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/HSP/Test/Test_S25FS512.h Tue Oct 25 15:22:11 2016 +0000 @@ -0,0 +1,46 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ +#ifndef _TEST_S25FS512_H_ +#define _TEST_S25FS512_H_ + +#include "mbed.h" +#include "S25FS512.h" +#include "Peripherals.h" + +/** +* @brief Selftest the S25FS512 and output the results as strings using the pointer function +* @param outputString Pointer to the function used to output the test results +*/ +void test_S25FS512(void (*outputString)(const char *)); + +#endif /* _TEST_S25FS512_H_ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/Test/Test_Utilities.cpp Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,45 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+#include "Test_Utilities.h"
+
+//******************************************************************************
+void _printPassFail(int status, int newLine, void (*outputString)(char const *)) {
+ if (status == 1) {
+ outputString("PASS");
+ } else {
+ outputString("FAIL");
+ }
+ if (newLine == 1) {
+ outputString("|");
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/HSP/Test/Test_Utilities.h Tue Oct 25 15:22:11 2016 +0000 @@ -0,0 +1,46 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ +#ifndef _TEST_UTILITIES_H_ +#define _TEST_UTILITIES_H_ + +#include "mbed.h" + +/** +* Function that will output a pass/fail formated string based on the incoming status value +* @param status Value that indicated pass or fail status +* @param newLine Should this call output a new line +* @param outputString Pointer to a function that will do the actual outputting of the string +*/ +void _printPassFail(int status, int newLine, void (*outputString)(const char *)); + +#endif /* _TEST_UTILITIES_H_ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/Test/Testing_RPC.cpp Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,130 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+#include <stdint.h>
+#include "StringHelper.h"
+#include "MAX30205.h"
+#include "Test_BMP280.h"
+#include "Test_LIS2DH.h"
+#include "Test_MAX30001.h"
+#include "Test_MAX30101.h"
+#include "Test_MAX30205.h"
+#include "Test_S25FS512.h"
+#include "StringInOut.h"
+
+void outputTestResultString(const char *resultStr);
+
+//******************************************************************************
+int Test_S25FS512(char argStrs[32][32], char replyStrs[32][32]) {
+ uint32_t reply[1];
+ test_S25FS512(outputTestResultString);
+ reply[0] = 0x80;
+ FormatReply32(reply, sizeof(reply) / sizeof(uint32_t), replyStrs);
+ return 0;
+}
+
+//******************************************************************************
+int Test_BMP280(char argStrs[32][32], char replyStrs[32][32]) {
+ uint32_t reply[1];
+ test_BMP280(outputTestResultString);
+ reply[0] = 0x80;
+ FormatReply32(reply, sizeof(reply) / sizeof(uint32_t), replyStrs);
+ return 0;
+}
+
+//******************************************************************************
+int Test_LIS2DH(char argStrs[32][32], char replyStrs[32][32]) {
+ uint32_t reply[1];
+ test_LIS2DH(outputTestResultString);
+ reply[0] = 0x80;
+ FormatReply32(reply, sizeof(reply) / sizeof(uint32_t), replyStrs);
+ return 0;
+}
+
+//******************************************************************************
+int Test_LSM6DS3(char argStrs[32][32], char replyStrs[32][32]) {
+ uint32_t reply[1];
+ reply[0] = 0x80;
+ FormatReply32(reply, sizeof(reply) / sizeof(uint32_t), replyStrs);
+ return 0;
+}
+
+//******************************************************************************
+int Test_MAX30205_1(char argStrs[32][32], char replyStrs[32][32]) {
+ uint32_t reply[1];
+ MAX30205 *max30205;
+ max30205 = Peripherals::max30205_top();
+ test_MAX30205(max30205, outputTestResultString);
+ reply[0] = 0x80;
+ FormatReply32(reply, sizeof(reply) / sizeof(uint32_t), replyStrs);
+ return 0;
+}
+
+//******************************************************************************
+int Test_MAX30205_2(char argStrs[32][32], char replyStrs[32][32]) {
+ uint32_t reply[1];
+ MAX30205 *max30205;
+ max30205 = Peripherals::max30205_bottom();
+ test_MAX30205(max30205, outputTestResultString);
+ reply[0] = 0x80;
+ FormatReply32(reply, sizeof(reply) / sizeof(uint32_t), replyStrs);
+ return 0;
+}
+
+//******************************************************************************
+int Test_MAX30101(char argStrs[32][32], char replyStrs[32][32]) {
+ uint32_t reply[1];
+ test_MAX30101(outputTestResultString);
+ reply[0] = 0x80;
+ FormatReply32(reply, sizeof(reply) / sizeof(uint32_t), replyStrs);
+ return 0;
+}
+
+//******************************************************************************
+int Test_MAX30001(char argStrs[32][32], char replyStrs[32][32]) {
+ uint32_t reply[1];
+ test_MAX30001(outputTestResultString);
+ reply[0] = 0x80;
+ FormatReply32(reply, sizeof(reply) / sizeof(uint32_t), replyStrs);
+ return 0;
+}
+
+//******************************************************************************
+int Test_EM9301(char argStrs[32][32], char replyStrs[32][32]) {
+ uint32_t reply[1];
+ reply[0] = 0x80;
+ FormatReply32(reply, sizeof(reply) / sizeof(uint32_t), replyStrs);
+ return 0;
+}
+
+//******************************************************************************
+void outputTestResultString(const char *resultStr) { putStr(resultStr); }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/HSP/Test/Testing_RPC.h Tue Oct 25 15:22:11 2016 +0000 @@ -0,0 +1,73 @@ +/******************************************************************************* + * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ +#ifndef _TESTING_RPC_H_ +#define _TESTING_RPC_H_ + +/** +* RPC executed routine that will perform platform self testing for the S25FS512 +*/ +int Test_S25FS512(char argStrs[32][32], char replyStrs[32][32]); +/** +* RPC executed routine that will perform platform self testing for the BMP280 +*/ +int Test_BMP280(char argStrs[32][32], char replyStrs[32][32]); +/** +* RPC executed routine that will perform platform self testing for the LIS2DH +*/ +int Test_LIS2DH(char argStrs[32][32], char replyStrs[32][32]); +/** +* RPC executed routine that will perform platform self testing for the LSM6DS3 +*/ +int Test_LSM6DS3(char argStrs[32][32], char replyStrs[32][32]); +/** +* RPC executed routine that will perform platform self testing for the MAX30205 +*/ +int Test_MAX30205_1(char argStrs[32][32], char replyStrs[32][32]); +/** +* RPC executed routine that will perform platform self testing for the MAX30205 +*/ +int Test_MAX30205_2(char argStrs[32][32], char replyStrs[32][32]); +/** +* RPC executed routine that will perform platform self testing for the MAX30101 +*/ +int Test_MAX30101(char argStrs[32][32], char replyStrs[32][32]); +/** +* RPC executed routine that will perform platform self testing for the MAX30001 +*/ +int Test_MAX30001(char argStrs[32][32], char replyStrs[32][32]); +/** +* RPC executed routine that will perform platform self testing for the EM9301 +*/ +int Test_EM9301(char argStrs[32][32], char replyStrs[32][32]); + +#endif /* _TESTING_RPC_H_ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/main.cpp Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,266 @@
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+#include "mbed.h"
+#include "MAX14720.h"
+#include "MAX30101.h"
+#include "MAX30205.h"
+#include "LIS2DH.h"
+#include "USBSerial.h"
+#include "RpcServer.h"
+#include "StringInOut.h"
+#include "Peripherals.h"
+#include "BMP280.h"
+#include "MAX30001.h"
+#include "DataLoggingService.h"
+#include "MAX30101_helper.h"
+#include "S25FS512.h"
+#include "QuadSpiInterface.h"
+#include "PushButton.h"
+#include "BLE.h"
+#include "HspBLE.h"
+#include "USBSerial.h"
+#include "Streaming.h"
+
+/// define the HVOUT Boost Voltage default for the MAX14720 PMIC
+#define HVOUT_VOLTAGE 4500 // set to 4500 mV
+
+/// define all I2C addresses
+#define MAX30205_I2C_SLAVE_ADDR_TOP (0x92)
+#define MAX30205_I2C_SLAVE_ADDR_BOTTOM (0x90)
+#define MAX14720_I2C_SLAVE_ADDR (0x54)
+#define BMP280_I2C_SLAVE_ADDR (0xEC)
+#define MAX30101_I2C_SLAVE_ADDR (0xAE)
+#define LIS2DH_I2C_SLAVE_ADDR (0x32)
+
+///
+/// wire Interfaces
+///
+/// Define with Maxim VID and a Maxim assigned PID, set to version 0x0001 and non-blocking
+USBSerial usbSerial(0x0b6a, 0x0100, 0x0001, false);
+/// I2C Master 1
+I2C i2c1(I2C1_SDA, I2C1_SCL); // used by MAX30205 (1), MAX30205 (2), BMP280
+/// I2C Master 2
+I2C i2c2(I2C2_SDA, I2C2_SCL); // used by MAX14720, MAX30101, LIS2DH
+/// SPI Master 0 with SPI0_SS for use with MAX30001
+SPI spi(SPI0_MOSI, SPI0_MISO, SPI0_SCK, SPI0_SS); // used by MAX30001
+/// SPI Master 1
+QuadSpiInterface quadSpiInterface(SPI1_MOSI, SPI1_MISO, SPI1_SCK,
+ SPI1_SS); // used by S25FS512
+
+///
+/// Devices
+///
+/// Pressure Sensor
+BMP280 bmp280(&i2c1, BMP280_I2C_SLAVE_ADDR);
+/// Top Local Temperature Sensor
+MAX30205 MAX30205_top(&i2c1, MAX30205_I2C_SLAVE_ADDR_TOP);
+/// Bottom Local Temperature Sensor
+MAX30205 MAX30205_bottom(&i2c1, MAX30205_I2C_SLAVE_ADDR_BOTTOM);
+/// Accelerometer
+LIS2DH lis2dh(&i2c2, LIS2DH_I2C_SLAVE_ADDR);
+InterruptIn lis2dh_Interrupt(P4_7);
+/// PMIC
+MAX14720 max14720(&i2c2, MAX14720_I2C_SLAVE_ADDR);
+/// Optical Oximeter
+MAX30101 max30101(&i2c2, MAX30101_I2C_SLAVE_ADDR);
+InterruptIn max30101_Interrupt(P4_0);
+/// External Flash
+S25FS512 s25fs512(&quadSpiInterface);
+/// ECG device
+MAX30001 max30001(&spi);
+InterruptIn max30001_InterruptB(P3_6);
+InterruptIn max30001_Interrupt2B(P4_5);
+/// PWM used as fclk for the MAX30001
+PwmOut pwmout(P1_7);
+/// HSP platform LED
+HspLed hspLed(LED_RED);
+/// Packet TimeStamp Timer, set for 1uS
+Timer timestampTimer;
+/// HSP Platform push button
+PushButton pushButton(SW1);
+
+/// BLE instance
+static BLE ble;
+
+/// HSP BluetoothLE specific functions
+HspBLE hspBLE(&ble);
+
+int main() {
+ // hold results for returning funtcoins
+ int result;
+ // local input state of the RPC
+ int inputState;
+ // RPC request buffer
+ char request[128];
+ // RPC reply buffer
+ char reply[128];
+
+ // display start banner
+ printf("Maxim Integrated mbed hSensor 3.0.0 10/14/16\n");
+ fflush(stdout);
+
+ // initialize HVOUT on the MAX14720 PMIC
+ printf("Init MAX14720...\n");
+ fflush(stdout);
+ result = max14720.init();
+ if (result == MAX14720_ERROR)
+ printf("Error initializing MAX14720");
+ max14720.boostEn = MAX14720::BOOST_ENABLED;
+ max14720.boostSetVoltage(HVOUT_VOLTAGE);
+
+ // turn on red led
+ printf("Init HSPLED...\n");
+ fflush(stdout);
+ hspLed.on();
+
+ // set NVIC priorities for GPIO to prevent priority inversion
+ printf("Init NVIC Priorities...\n");
+ fflush(stdout);
+ NVIC_SetPriority(GPIO_P0_IRQn, 5);
+ NVIC_SetPriority(GPIO_P1_IRQn, 5);
+ NVIC_SetPriority(GPIO_P2_IRQn, 5);
+ NVIC_SetPriority(GPIO_P3_IRQn, 5);
+ NVIC_SetPriority(GPIO_P4_IRQn, 5);
+ NVIC_SetPriority(GPIO_P5_IRQn, 5);
+ NVIC_SetPriority(GPIO_P6_IRQn, 5);
+ // used by the MAX30001
+ NVIC_SetPriority(SPI1_IRQn, 0);
+
+ // Be able to statically reference these devices anywhere in the application
+ Peripherals::setS25FS512(&s25fs512);
+ Peripherals::setMAX30205_top(&MAX30205_top);
+ Peripherals::setMAX30205_bottom(&MAX30205_bottom);
+ Peripherals::setBMP280(&bmp280);
+ Peripherals::setLIS2DH(&lis2dh);
+ Peripherals::setUSBSerial(&usbSerial);
+ Peripherals::setTimestampTimer(×tampTimer);
+ Peripherals::setHspLed(&hspLed);
+ Peripherals::setMAX30101(&max30101);
+ Peripherals::setI2c1(&i2c1);
+ Peripherals::setI2c2(&i2c2);
+ Peripherals::setPushButton(&pushButton);
+ Peripherals::setBLE(&ble);
+ Peripherals::setMAX14720(&max14720);
+ Peripherals::setMAX30001(&max30001);
+ Peripherals::setHspBLE(&hspBLE);
+
+ // init the S25FS256 external flash device
+ printf("Init S25FS512...\n");
+ fflush(stdout);
+ s25fs512.init();
+
+ // init the BMP280
+ printf("Init BMP280...\n");
+ fflush(stdout);
+ bmp280.init(BMP280::OVERSAMPLING_X2_P, BMP280::OVERSAMPLING_X1_T,
+ BMP280::FILT_OFF, BMP280::NORMAL_MODE, BMP280::T_62_5);
+
+ // Initialize BLE base layer
+ printf("Init HSPBLE...\n");
+ fflush(stdout);
+ hspBLE.init();
+
+ // start blinking led1
+ printf("Init HSPLED Blink...\n");
+ fflush(stdout);
+ hspLed.blink(1000);
+
+ // MAX30101 initialize interrupt
+ printf("Init MAX30101 callbacks, interrupt...\n");
+ fflush(stdout);
+ max30101.onInterrupt(&MAX30101_OnInterrupt);
+ max30101.onDataAvailable(&StreamPacketUint32);
+ max30101_Interrupt.fall(&MAX30101MidIntHandler);
+
+ //
+ // MAX30001
+ //
+ printf("Init MAX30001 callbacks, interrupts...\n");
+ fflush(stdout);
+ max30001_InterruptB.disable_irq();
+ max30001_Interrupt2B.disable_irq();
+ max30001_InterruptB.mode(PullUp);
+ max30001_InterruptB.fall(&MAX30001Mid_IntB_Handler);
+ max30001_Interrupt2B.mode(PullUp);
+ max30001_Interrupt2B.fall(&MAX30001Mid_Int2B_Handler);
+ max30001_InterruptB.enable_irq();
+ max30001_Interrupt2B.enable_irq();
+ MAX30001_AllowInterrupts(1);
+ // Configuring the FCLK for the ECG, set to 32.768KHZ
+ printf("Init MAX30001 PWM...\n");
+ fflush(stdout);
+ pwmout.period_us(31);
+ pwmout.write(0.5); // 0-1 is 0-100%, 0.5 = 50% duty cycle.
+ max30001.max30001_sw_rst(); // Do a software reset of the MAX30001
+ max30001.max30001_INT_assignment(MAX30001::MAX30001_INT_B, MAX30001::MAX30001_NO_INT, MAX30001::MAX30001_NO_INT, // en_enint_loc, en_eovf_loc, en_fstint_loc,
+ MAX30001::MAX30001_INT_2B, MAX30001::MAX30001_INT_2B, MAX30001::MAX30001_NO_INT, // en_dcloffint_loc, en_bint_loc, en_bovf_loc,
+ MAX30001::MAX30001_INT_2B, MAX30001::MAX30001_INT_2B, MAX30001::MAX30001_NO_INT, // en_bover_loc, en_bundr_loc, en_bcgmon_loc,
+ MAX30001::MAX30001_INT_B, MAX30001::MAX30001_NO_INT, MAX30001::MAX30001_NO_INT, // en_pint_loc, en_povf_loc, en_pedge_loc,
+ MAX30001::MAX30001_INT_2B, MAX30001::MAX30001_INT_B, MAX30001::MAX30001_NO_INT, // en_lonint_loc, en_rrint_loc, en_samp_loc,
+ MAX30001::MAX30001_INT_ODNR, MAX30001::MAX30001_INT_ODNR); // intb_Type, int2b_Type)
+ max30001.onDataAvailable(&StreamPacketUint32);
+
+ // initialize the LIS2DH accelerometer and interrupts
+ printf("Init LIS2DH interrupt...\n");
+ fflush(stdout);
+ lis2dh.init();
+ lis2dh_Interrupt.fall(&LIS2DHIntHandler);
+ lis2dh_Interrupt.mode(PullUp);
+ // initialize the RPC server
+ printf("Init RPC Server...\n");
+ fflush(stdout);
+ RPC_init();
+ // initialize the logging service
+ printf("Init LoggingService...\n");
+ fflush(stdout);
+ LoggingService_Init();
+
+ // start main loop
+ printf("Start main loop...\n");
+ fflush(stdout);
+ while (1) {
+ // get a RPC string if one is available
+ inputState = getLine(request, sizeof(request));
+ // if a string has been captured, process string
+ if (inputState == GETLINE_DONE) {
+ // process the RPC string
+ RPC_call(request, reply);
+ // output the reply
+ putStr(reply);
+ }
+ // process any logging or streaming requests
+ LoggingService_ServiceRoutine();
+ // allow for ble processing
+ ble.waitForEvent();
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/USBDevice.lib Tue Oct 25 15:22:11 2016 +0000 @@ -0,0 +1,1 @@ +http://developer.mbed.org/teams/MaximIntegrated/code/USBDevice/#6e1433359654
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mbed-os.lib Tue Oct 25 15:22:11 2016 +0000 @@ -0,0 +1,1 @@ +https://github.com/ARMmbed/mbed-os/#e435a07d9252f133ea3d9f6c95dfb176f32ab9b6