Jerry Bradshaw
/
mbed-os-test
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.
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