нет соответствующей функции для вызова неразрешенного типа перегруженной функции

Во-первых, я новичок в C ++, поэтому на мой вопрос уже можно было где-то ответить, но я не смог найти прямой ответ на него.
Я создаю простую библиотеку для моего оборудования. Я использую библиотеку планировщика, которая отлично работает на Arduino IDE (Вот это пример), но когда я компилирую код с помощью собственной IDE (Atom + PlatformIO), появляется эта ошибка:

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

Я удалил некоторые коды, но если вам нужно остальное, я могу поставить его.

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;