没有匹配的函数无法调用未解析的重载函数类型

Question

First I'm a newbie to C++ so my question might be already answered somewhere but I couldn't find a straightforward answer to it. I'm creating a simple library for my hardware. I'm using a Scheduler library which is working fine on Arduino IDE ( here is the example), but when I compile the code with my own IDE (Atom+PlatformIO) this error comes up:

lib\SRF08\SRF08.cpp:43:30: error: no matching function for call to 'SchedulerClass::startLoop(<unresolved overloaded functi
on type>)'

I removed some of the codes but if you need the rest I can put it.

SRF08.h

#ifndef SRF08_h
#define SRF08_h

#include "Arduino.h"

class SRF08
{
public:
    //main constructor
    SRF08(uint8_t address=address_1);
    // init the sensor
    void begin(void);

    //change sensor address from oldAddress to newAddress
    void changeAddress(uint16_t oldAddress, uint16_t newAddress);
    // scan for a single sensor address
    int8_t scanner(void);
    // scan for multiple sensors and return the table of addresses
    struct table_value scan_all(void);
    uint16_t output_value;
    void read(void);
private:
    // the main I2C address of Sensor
    uint16_t _address;
    //read sansor value base on centimiter
};
#endif

SRF08.cpp

#include "Wire.h"
#include "SRF08.h"
// Include Scheduler since we want to manage multiple tasks.
#include "Scheduler.h"

SRF08::SRF08(uint8_t address)
{
    //main constructor, address is the sensor address if u dont know it try scanner first
    //address must be an integer number between 1 to 9
    if (address == 1) _address = address_1;
     else _address = address_1;

}

void SRF08::begin(){
    //initilize I2C
    Wire.begin();
    output_value = 0;
    Scheduler.startLoop(SRF08::read);  //here is my error
}



void SRF08::read(){
    int reading = 0;
    // step 1: instruct sensor to read echoes
    Wire.beginTransmission(_address); // transmit to device #112 (0x70)
    // the address specified in the datasheet is 224 (0xE0)
    // but i2c adressing uses the high 7 bits so it's 112
    Wire.write(byte(0x00));      // sets register pointer to the command register (0x00)
    Wire.write(byte(0x51));      // command sensor to measure in "inches" (0x50)
    // use 0x51 for centimeters
    // use 0x52 for ping microseconds
    Wire.endTransmission();      // stop transmitting

    // step 2: wait for readings to happen
    delay(70);                   // datasheet suggests at least 65 milliseconds

    // step 3: instruct sensor to return a particular echo reading
    Wire.beginTransmission(_address); // transmit to device #112
    Wire.write(byte(0x02));      // sets register pointer to echo #1 register (0x02)
    Wire.endTransmission();      // stop transmitting

    // step 4: request reading from sensor
    Wire.requestFrom(_address, 2);    // request 2 bytes from slave device #112

    // step 5: receive reading from sensor
    if (2 <= Wire.available()) { // if two bytes were received
        reading = Wire.read();  // receive high byte (overwrites previous reading)
        reading = reading << 8;    // shift high byte to be high 8 bits
        reading |= Wire.read(); // receive low byte as lower 8 bits
        output_value = reading;   // print the reading
    }
    //yield();
}

Scheduler.h

#ifndef _SCHEDULER_H_
#define _SCHEDULER_H_

#include <Arduino.h>

extern "C" {
    typedef void (*SchedulerTask)(void);
    typedef void (*SchedulerParametricTask)(void *);
}

class SchedulerClass {
public:
    SchedulerClass();
    static void startLoop(SchedulerTask task, uint32_t stackSize = 1024);
    static void start(SchedulerTask task, uint32_t stackSize = 1024);
    static void start(SchedulerParametricTask task, void *data, uint32_t stackSize = 1024);

    static void yield() { ::yield(); };
};

extern SchedulerClass Scheduler;

#endif

Scheduler.cpp

#include "Scheduler.h"

extern "C" {

#define NUM_REGS 10 // r4-r11, sp, pc

typedef struct CoopTask {
    uint32_t regs[NUM_REGS];
    void* stackPtr;
    struct CoopTask* next;
    struct CoopTask* prev;
} CoopTask;

static CoopTask *cur = 0;
...
void yield(void) {
    coopDoYield(cur);
}

}; // extern "C"

SchedulerClass::SchedulerClass() {
    coopInit();
}

static void startLoopHelper(void *taskData) {
    SchedulerTask task = reinterpret_cast<SchedulerTask>(taskData);
    while (true)
        task();
}

void SchedulerClass::startLoop(SchedulerTask task, uint32_t stackSize) {
    coopSpawn(startLoopHelper, reinterpret_cast<void *>(task), stackSize);
}

static void startTaskHelper(void *taskData) {
    SchedulerTask task = reinterpret_cast<SchedulerTask>(taskData);
    task();
}

void SchedulerClass::start(SchedulerTask task, uint32_t stackSize) {
    coopSpawn(startTaskHelper, reinterpret_cast<void *>(task), stackSize);
}

void SchedulerClass::start(SchedulerParametricTask task, void *taskData, uint32_t stackSize) {
    coopSpawn(task, taskData, stackSize);
}

SchedulerClass Scheduler;

Answer 1

Thanks to @Someprogrammerdude to help. I needed to declare the read function as static.

SRF08.h

#ifndef SRF08_h
#define SRF08_h

#include "Arduino.h"

class SRF08
{
public:
    //main constructor
    SRF08(uint8_t address=address_1);
    // init the sensor
    void begin(void);

    //change sensor address from oldAddress to newAddress
    void changeAddress(uint16_t oldAddress, uint16_t newAddress);
    // scan for a single sensor address
    int8_t scanner(void);
    // scan for multiple sensors and return the table of addresses
    struct table_value scan_all(void);
    static uint16_t output_value;
    static void read(void);
    static uint16_t static_address;

private:
    // the main I2C address of Sensor
    uint16_t _address;
    //read sansor value base on centimiter
};
#endif

SRF08.cpp

#include "Wire.h"
#include "SRF08.h"
// Include Scheduler since we want to manage multiple tasks.
#include "Scheduler.h"

//initilize static members

uint16_t SRF08::output_value;
uint16_t SRF08::static_address;

SRF08::SRF08(uint8_t address)
{
    //main constructor, address is the sensor address if u dont know it try scanner first
    //address must be an integer number between 1 to 9
    if (address == 1) _address = address_1;
    else _address = address_1;
    static_address = _address;
    //begin();
}

void SRF08::begin(){
    //initilize I2C
    Wire.begin();
    output_value = 0;
    Scheduler.startLoop(read);  //here is my error
}


void SRF08::read(){
    int reading = 0;
    // step 1: instruct sensor to read echoes
    Wire.beginTransmission(static_address); // transmit to device #112 (0x70)
    // the address specified in the datasheet is 224 (0xE0)
    // but i2c adressing uses the high 7 bits so it's 112
    Wire.write(byte(0x00));      // sets register pointer to the command register (0x00)
    Wire.write(byte(0x51));      // command sensor to measure in "inches" (0x50)
    // use 0x51 for centimeters
    // use 0x52 for ping microseconds
    Wire.endTransmission();      // stop transmitting

    // step 2: wait for readings to happen
    delay(70);                   // datasheet suggests at least 65 milliseconds

    // step 3: instruct sensor to return a particular echo reading
    Wire.beginTransmission(static_address); // transmit to device #112
    Wire.write(byte(0x02));      // sets register pointer to echo #1 register (0x02)
    Wire.endTransmission();      // stop transmitting

    // step 4: request reading from sensor
    Wire.requestFrom(static_address, 2);    // request 2 bytes from slave device #112

    // step 5: receive reading from sensor
    if (2 <= Wire.available()) { // if two bytes were received
        reading = Wire.read();  // receive high byte (overwrites previous reading)
        reading = reading << 8;    // shift high byte to be high 8 bits
        reading |= Wire.read(); // receive low byte as lower 8 bits
        output_value = reading;   // print the reading
        //output_value = reading;
    }
    yield();
}