Arm Mbed OS support forum

MAX32630 FTHR is not recognized

I am trying to plot ECG graph on android mobile phone using BLE. I have used MAX30003 Ic and MAX32630 FTHR. i have used BLE example of heart rate given by Mbed OS platform. I am getting error " MAX32630fthr is not recognized, even i have connect MAX32630 with my PC. The written code is below:

/*******************************************************************************

  • Copyright (C) 2017 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
#include <events/mbed_events.h>
#include “mbed.h”
#include “max32630fthr.h”
#include “MAX30003.h”
#include “ble/BLE.h”
#include “ble/Gap.h”
#include “ble/services/HeartRateService.h”
#include “ble/services/BatteryService.h”
#include “ble/services/DeviceInformationService.h”
#include “pretty_printer.h”
MAX32630FTHR pegasus(MAX32630FTHR::VIO_3V3);

const static char DEVICE_NAME[] = “Heartrate”;

static events::EventQueue event_queue(/* event count */ 16 * EVENTS_EVENT_SIZE);

class HeartrateDemo : ble::Gap::EventHandler {
public:
HeartrateDemo(BLE &ble, events::EventQueue &event_queue) :
_ble(ble),
_event_queue(event_queue),
_led1(LED1, 1),
_connected(false),
_hr_uuid(GattService::UUID_HEART_RATE_SERVICE),
_hr_counter(100),
_hr_service(ble, _hr_counter, HeartRateService::LOCATION_FINGER),
_adv_data_builder(_adv_buffer) { }

void start() {
    _ble.gap().setEventHandler(this);

    _ble.init(this, &HeartrateDemo::on_init_complete);

    _event_queue.call_every(500, this, &HeartrateDemo::blink);
    _event_queue.call_every(1000, this, &HeartrateDemo::update_sensor_value);

    _event_queue.dispatch_forever();
}

private:
/** Callback triggered when the ble initialization process has finished */
void on_init_complete(BLE::InitializationCompleteCallbackContext *params) {
if (params->error != BLE_ERROR_NONE) {
printf(“Ble initialization failed.”);
return;
}

    print_mac_address();

    start_advertising();
}

void start_advertising() {
    /* Create advertising parameters and payload */

    ble::AdvertisingParameters adv_parameters(
        ble::advertising_type_t::CONNECTABLE_UNDIRECTED,
        ble::adv_interval_t(ble::millisecond_t(1000))
    );

    _adv_data_builder.setFlags();
    _adv_data_builder.setAppearance(ble::adv_data_appearance_t::GENERIC_HEART_RATE_SENSOR);
    _adv_data_builder.setLocalServiceList(mbed::make_Span(&_hr_uuid, 1));
    _adv_data_builder.setName(DEVICE_NAME);

    /* Setup advertising */

    ble_error_t error = _ble.gap().setAdvertisingParameters(
        ble::LEGACY_ADVERTISING_HANDLE,
        adv_parameters
    );

    if (error) {
        printf("_ble.gap().setAdvertisingParameters() failed\r\n");
        return;
    }

    error = _ble.gap().setAdvertisingPayload(
        ble::LEGACY_ADVERTISING_HANDLE,
        _adv_data_builder.getAdvertisingData()
    );

    if (error) {
        printf("_ble.gap().setAdvertisingPayload() failed\r\n");
        return;
    }

    /* Start advertising */

    error = _ble.gap().startAdvertising(ble::LEGACY_ADVERTISING_HANDLE);

    if (error) {
        printf("_ble.gap().startAdvertising() failed\r\n");
        return;
    }
}

void update_sensor_value() {
    if (_connected) {
        // Do blocking calls or whatever is necessary for sensor polling.
        // In our case, we simply update the HRM measurement.
        _hr_counter++;

        //  100 <= HRM bps <=175
        if (_hr_counter == 175) {
            _hr_counter = 100;
        }

        _hr_service.updateHeartRate(_hr_counter);
    }
}

void blink(void) {
    _led1 = !_led1;
}

private:
/* Event handler */

void onDisconnectionComplete(const ble::DisconnectionCompleteEvent&) {
    _ble.gap().startAdvertising(ble::LEGACY_ADVERTISING_HANDLE);
    _connected = false;
}

virtual void onConnectionComplete(const ble::ConnectionCompleteEvent &event) {
    if (event.getStatus() == BLE_ERROR_NONE) {
        _connected = true;
    }
}

private:
BLE &_ble;
events::EventQueue &_event_queue;
DigitalOut _led1;

bool _connected;

UUID _hr_uuid;

uint8_t _hr_counter;
HeartRateService _hr_service;

uint8_t _adv_buffer[ble::LEGACY_ADVERTISING_MAX_SIZE];
ble::AdvertisingDataBuilder _adv_data_builder;

};

/** Schedule processing of events from the BLE middleware in the event queue. */
void schedule_ble_events(BLE::OnEventsToProcessCallbackContext *context) {
event_queue.call(Callback<void()>(&context->ble, &BLE::processEvents));
}

int main()
{
BLE &ble = BLE::Instance();
ble.onEventsToProcess(schedule_ble_events);

HeartrateDemo demo(ble, event_queue);
demo.start();



// Constants
const int EINT_STATUS_MASK =  1 << 23;
const int FIFO_OVF_MASK =  0x7;
const int FIFO_VALID_SAMPLE_MASK =  0x0;
const int FIFO_FAST_SAMPLE_MASK =  0x1;
const int ETAG_BITS_MASK = 0x7;

// Ports and serial connections
Serial pc(USBTX, USBRX);            // Use USB debug probe for serial link
pc.baud(115200);                    // Baud rate = 115200

DigitalOut rLed(LED1, LED_OFF);      // Debug LEDs

InterruptIn ecgFIFO_int(P5_4);          // Config P5_4 as int. in for the
ecgFIFO_int.fall(&ecgFIFO_callback);    // ecg FIFO almost full interrupt

SPI spiBus(SPI2_MOSI, SPI2_MISO, SPI2_SCK);     // SPI bus, P5_1 = MOSI, 
                                                // P5_2 = MISO, P5_0 = SCK

MAX30003 ecgAFE(spiBus, P5_3);          // New MAX30003 on spiBus, CS = P5_3 
ecg_config(ecgAFE);                    // Config ECG 
 

ecgAFE.writeRegister( MAX30003::SYNCH , 0);

uint32_t ecgFIFO, readECGSamples, idx, ETAG[32], status;
int16_t ecgSample[32];

while(1) {
    
    // Read back ECG samples from the FIFO 
    if( ecgFIFOIntFlag ) {
        
        ecgFIFOIntFlag = 0; 
        status = ecgAFE.readRegister( MAX30003::STATUS );      // Read the STATUS register
         
        // Check if EINT interrupt asserted
        if ( ( status & EINT_STATUS_MASK ) == EINT_STATUS_MASK ) {     
        
            readECGSamples = 0;                        // Reset sample counter
            
            do {
                ecgFIFO = ecgAFE.readRegister( MAX30003::ECG_FIFO );       // Read FIFO
                ecgSample[readECGSamples] = ecgFIFO >> 8;                  // Isolate voltage data
                ETAG[readECGSamples] = ( ecgFIFO >> 3 ) & ETAG_BITS_MASK;  // Isolate ETAG
                readECGSamples++;                                          // Increment sample counter
            
            // Check that sample is not last sample in FIFO                                              
            } while ( ETAG[readECGSamples-1] == FIFO_VALID_SAMPLE_MASK || 
                      ETAG[readECGSamples-1] == FIFO_FAST_SAMPLE_MASK ); 
            
            // Check if FIFO has overflowed
            if( ETAG[readECGSamples - 1] == FIFO_OVF_MASK ){                  
                ecgAFE.writeRegister( MAX30003::FIFO_RST , 0); // Reset FIFO
                rLed = 1;//notifies the user that an over flow occured
            }
            
            // Print results 
            for( idx = 0; idx < readECGSamples; idx++ ) {
                pc.printf("%6d\r\n", ecgSample[idx]);           
            } 
                           
        }
    }
}

}

void ecg_config(MAX30003& ecgAFE) {

// Reset ECG to clear registers
ecgAFE.writeRegister( MAX30003::SW_RST , 0);

// General config register setting
MAX30003::GeneralConfiguration_u CNFG_GEN_r;
CNFG_GEN_r.bits.en_ecg = 1;     // Enable ECG channel
CNFG_GEN_r.bits.rbiasn = 1;     // Enable resistive bias on negative input
CNFG_GEN_r.bits.rbiasp = 1;     // Enable resistive bias on positive input
CNFG_GEN_r.bits.en_rbias = 1;   // Enable resistive bias
CNFG_GEN_r.bits.imag = 2;       // Current magnitude = 10nA
CNFG_GEN_r.bits.en_dcloff = 1;  // Enable DC lead-off detection   
ecgAFE.writeRegister( MAX30003::CNFG_GEN , CNFG_GEN_r.all);
    

// ECG Config register setting
MAX30003::ECGConfiguration_u CNFG_ECG_r;
CNFG_ECG_r.bits.dlpf = 1;       // Digital LPF cutoff = 40Hz
CNFG_ECG_r.bits.dhpf = 1;       // Digital HPF cutoff = 0.5Hz
CNFG_ECG_r.bits.gain = 3;       // ECG gain = 160V/V
CNFG_ECG_r.bits.rate = 2;       // Sample rate = 128 sps
ecgAFE.writeRegister( MAX30003::CNFG_ECG , CNFG_ECG_r.all);
  

//R-to-R configuration
MAX30003::RtoR1Configuration_u CNFG_RTOR_r;
CNFG_RTOR_r.bits.en_rtor = 1;           // Enable R-to-R detection
ecgAFE.writeRegister( MAX30003::CNFG_RTOR1 , CNFG_RTOR_r.all);
   
    
//Manage interrupts register setting
MAX30003::ManageInterrupts_u MNG_INT_r;
MNG_INT_r.bits.efit = 0b00011;          // Assert EINT w/ 4 unread samples
MNG_INT_r.bits.clr_rrint = 0b01;        // Clear R-to-R on RTOR reg. read back
ecgAFE.writeRegister( MAX30003::MNGR_INT , MNG_INT_r.all);


//Enable interrupts register setting
MAX30003::EnableInterrupts_u EN_INT_r;
EN_INT_r.all = 0;
EN_INT_r.bits.en_eint = 1;              // Enable EINT interrupt
EN_INT_r.bits.en_rrint = 0;             // Disable R-to-R interrupt
EN_INT_r.bits.intb_type = 3;            // Open-drain NMOS with internal pullup
ecgAFE.writeRegister( MAX30003::EN_INT , EN_INT_r.all);
   
   
//Dyanmic modes config
MAX30003::ManageDynamicModes_u MNG_DYN_r;
MNG_DYN_r.bits.fast = 0;                // Fast recovery mode disabled
ecgAFE.writeRegister( MAX30003::MNGR_DYN , MNG_DYN_r.all);

// MUX Config
MAX30003::MuxConfiguration_u CNFG_MUX_r;
CNFG_MUX_r.bits.openn = 0;          // Connect ECGN to AFE channel
CNFG_MUX_r.bits.openp = 0;          // Connect ECGP to AFE channel
ecgAFE.writeRegister( MAX30003::CNFG_EMUX , CNFG_MUX_r.all);
   
return 0;

}