MAX32630 FTHR is not recognized

Aryan_Jain · July 26, 2021, 7:19am

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;

}

Topic		Replies	Views
MAX32630FTHR and BLE? Hello world!	26	2322	September 14, 2020
MAX32630FTHR BLE error Mbed OS	14	980	March 14, 2022
How to send data over BLE on MAX32665/32666 Mbed OS maxim-integrated , ble	0	232	September 25, 2023
Debugging Issues on MAX32630FTHR with MBED-OS 5 Mbed OS mbed_os , ble	0	173	February 20, 2024
MAX32666FTHR target Boards maxim-integrated	6	851	August 1, 2021

MAX32630 FTHR is not recognized

Related topics