Arduino.ru

Если у метода не предусмотрено, то никак. Только писать свой метод

В общем так, выкладывайте Ваш код и прямую ссылку на библиотеку. Без этого разговор ни о чём.

Да, но все варианты которые нашел в интернете не подошли. вечно на что то ругалось.

Пример:

bool WatchPower::setBulkChargingVoltage() {

}

Я к тому, что Вы же автор этой функции. Объявите ее с нужными аргументами, в чем проблема-то?

Можно пример?

1. Как передавать?

2. Как правильно вписать в функцию аргументы?

Повторяю второй раз для альтернативно-одарённых (больше не повторять не буду, ибо сочту, что "медицина бессильна")

Я Вас не оскорблял. Я пред. сообщения видел, только домой пришел. Просто выше человеку ответил. Быстро решу дом. дела и все оформлю.

Я Вас тоже.

#include <WatchPower.h>

// Attach Serial1 to WatchPower
WatchPower watchPower(Serial2);

int value = 1;

void setup(){
    Serial.begin(9600);
}

void loop(){
    /* Refresh the stats */
    watchPower.refreshData();

    /* Print stats from the inverter to the serial console */
    Serial.print("Grid Volt: ");
    Serial.println(watchPower.gridVoltage.str);

    Serial.print("Grid Freq: ");
    Serial.println(watchPower.gridFreq.str);

    // Выполнение
    // Сюда передать переменную value
    watchPower.setBulkChargingVoltage();

    delay(2*1000);
}

WatchPower.cpp

/* WatchPower library by Hassan Nadeem
*/

#include "WatchPower.h"

WatchPower::WatchPower(HardwareSerial &_refSer){
    refSer = &_refSer;

    /* Communication format for OptiSolar
    * Baud Rate: 2400
    * Start Bit: 1
    * Data Bit: 8
    * Parity Bit: No
    * Stop Bit: 1 */
    refSer->begin( 2400 );

    delay(100); /* Wait for serial port init */

    refreshDeviceConstants();
    refreshSettings();
}

WatchPower::WatchPower(HardwareSerial &_refSer, bool _conditioningEnabled) : WatchPower(_refSer){
    conditioningEnabled = _conditioningEnabled;
}

WatchPower::~WatchPower(){
    refSer->end();
}

/* CRC-CCITT (XModem)
* Source: http://web.mit.edu/6.115/www/amulet/xmodem.htm */
uint16_t WatchPower::calculateCRC(const char *ptr, int count){
    int  crc;
    char i;
    crc = 0;
    while (--count >= 0){
        crc = crc ^ (int) *ptr++ << 8;
        i = 8;
        do{
            if (crc & 0x8000){
                crc = crc << 1 ^ 0x1021;
            }else{
                crc = crc << 1;
            }
        }while(--i);
    }
    return (crc);
}

void WatchPower::appendCRC(char *str){
    uint16_t len = strlen(str);

    uint16_t crc = calculateCRC(str, len);

    str[len++] = CRC_HIGH_BYTE( crc );
    str[len++] = CRC_LOW_BYTE( crc );
    str[len++] = 0;
}


bool WatchPower::validateCRC(char *str, uint16_t len){
    if(len < 3) return false;

    uint16_t crc = calculateCRC(str, len-2);

    return CRC_HIGH_BYTE(crc) == str[len-2] && CRC_LOW_BYTE(crc) == str[len-1];
}

bool WatchPower::isACK(const char *str){
    /* If found, skip the start byte */
    if(str[0] == '(') str++;

    return strstr(str, "ACK") == str;
}

bool WatchPower::isNACK(const char *str){
    return !isACK(str);
}


void WatchPower::clearSerialBuffer(){
    while( refSer->available() ) refSer->read();
}

uint16_t WatchPower::readLine(char *buffer, uint16_t length){
    if(length < 1) return 0;

    uint16_t bytesRead = refSer->readBytesUntil('\r', buffer, length - 1);
    buffer[bytesRead] = 0;

    return bytesRead;
}

void WatchPower::sendLine(const char *str){
    refSer->print(str);
    refSer->print('\r');
}

bool WatchPower::querySolar(const char *query, char *buffer, uint16_t bufferLen){
    clearSerialBuffer();
    sendLine(query);
    uint16_t bytesRead = readLine(buffer, bufferLen);
    return validateCRC(buffer, bytesRead);
}

void WatchPower::conditionData(){
    if(conditioningEnabled == false) return;

    if(isOnGrid()){
        /* Battery discharge current should be zero on Grid */
        strcpy( batteryDischargeCurrent.str, "00000" );
        batteryDischargeCurrent.flt = 0;
    }

    if(!isSolarAvailable()){
        strcpy( batteryVoltageSCC.str, "00.00" );
        batteryVoltageSCC.flt = 0;
    }

    /* Interver does not report battery charging current on grid charging */
    if(isGridCharging()){
        strcpy( batteryCurrent.str, "NaN" );
        batteryCurrent.flt = 0.0/0.0; /* NaN */
    }
}

void WatchPower::parseQPIGS(const char *buffer){
    buffer++; /* Skip start byte '(' */

    #define copyAndAdvance(dest, src, size) strncpyTerminated(dest, src, size); buffer += size+1
    copyAndAdvance(gridVoltage.str,             buffer, 5);
    copyAndAdvance(gridFreq.str,                buffer, 4);
    copyAndAdvance(outputVoltage.str,           buffer, 5);
    copyAndAdvance(outputFreq.str,              buffer, 4);
    copyAndAdvance(outputPowerApparent.str,     buffer, 4);
    copyAndAdvance(outputPowerActive.str,       buffer, 4);
    copyAndAdvance(loadPercent.str,             buffer, 3);
    copyAndAdvance(busVoltage.str,              buffer, 3);
    copyAndAdvance(batteryVoltage.str,          buffer, 5);
    copyAndAdvance(batteryCurrent.str,          buffer, 2);
    copyAndAdvance(batteryCapacity.str,         buffer, 3);
    copyAndAdvance(temperature.str,             buffer, 4);
    copyAndAdvance(solarCurrent.str,            buffer, 4);
    copyAndAdvance(solarVoltage.str,            buffer, 5);
    copyAndAdvance(batteryVoltageSCC.str,       buffer, 5);
    copyAndAdvance(batteryDischargeCurrent.str, buffer, 5);
    copyAndAdvance(status.str,                  buffer, 8);
    #undef copyAndAdvance

    /* Parse floats */
    gridVoltage.flt             = atof(gridVoltage.str);
    gridFreq.flt                = atof(gridFreq.str);
    outputVoltage.flt           = atof(outputVoltage.str);
    outputFreq.flt              = atof(outputFreq.str);
    outputPowerApparent.flt     = atof(outputPowerApparent.str);
    outputPowerActive.flt       = atof(outputPowerActive.str);
    loadPercent.flt             = atof(loadPercent.str);
    busVoltage.flt              = atof(busVoltage.str);
    batteryVoltage.flt          = atof(batteryVoltage.str);
    batteryCurrent.flt          = atof(batteryCurrent.str);
    batteryCapacity.flt         = atof(batteryCapacity.str);
    temperature.flt             = atof(temperature.str);
    solarCurrent.flt            = atof(solarCurrent.str);
    solarVoltage.flt            = atof(solarVoltage.str);
    batteryVoltageSCC.flt       = atof(batteryVoltageSCC.str);
    batteryDischargeCurrent.flt = atof(batteryDischargeCurrent.str);

    /* Parse status */
    status.status.byte = 0;
    for(int i=0; i<8; i++){
        status.status.byte |= (status.str[7-i] - '0')<<i;
    }
}

void WatchPower::parseQMOD(const char *buffer){
    buffer++; /* Skip start byte '(' */

    mode = buffer[0];
}

void WatchPower::parseWarnings(const char *buffer){
    buffer++; /* Skip start byte '(' */

    strncpyTerminated(warning.str, buffer, 32);

    /* Parse warnings */
    warning.warning.word = 0;
    for(int i=0; i<32; i++){
        warning.warning.word |= (warning.str[31-i] - '0')<<i;
    }
}

bool WatchPower::refreshData(){
    bool error = false;
    char inputBuffer[256];

    error |= querySolar(CMD_MODE_INQUIRY, inputBuffer, sizeof(inputBuffer));
    parseQMOD(inputBuffer);
    // Particle.publish("_QMOD", inputBuffer);

    error |= querySolar(CMD_GENERAL_STATUS, inputBuffer, sizeof(inputBuffer));
    parseQPIGS(inputBuffer);
    // Particle.publish("_QPIGS", inputBuffer);

    error |= querySolar(CMD_WARNING_STATUS, inputBuffer, sizeof(inputBuffer));
    parseWarnings(inputBuffer);
    // Particle.publish("Warn", inputBuffer);

    if(conditioningEnabled){
        conditionData();
    }

    return error;
}

bool WatchPower::refreshDeviceConstants(){
    bool error = false;
    char inputBuffer[256];

    error |= querySolar(CMD_SERIAL_INQUIRY, inputBuffer, sizeof(inputBuffer));
    parseSerialNumber(inputBuffer);

    error |= querySolar(CMD_FIRMWARE_PRIM_VER_INQUIRY, inputBuffer, sizeof(inputBuffer));
    parseFirmwareVerPrimary(inputBuffer);

    error |= querySolar(CMD_FIRMWARE_SEC_VER_INQUIRY, inputBuffer, sizeof(inputBuffer));
    parseFirmwareVerSecondary(inputBuffer);

    return error;
}

bool WatchPower::refreshSettings(){
    bool error = false;
    char inputBuffer[256];

    error |= querySolar(CMD_FLAG_INQUIRY, inputBuffer, sizeof(inputBuffer));
    parseFlags(inputBuffer);

    error |= querySolar(CMD_RATING_INQUIRY, inputBuffer, sizeof(inputBuffer));
    parseRating(inputBuffer);

    return error;
}

bool WatchPower::isCharging(){
    return status.status.bits.chargingStatus;
}

bool WatchPower::isSolarCharging(){
    return status.status.bits.sccChargingStatus;
}

bool WatchPower::isGridCharging(){
    return status.status.bits.acChargingStatus;
}

bool WatchPower::isOnBattery(){
    return mode == 'B';
}

bool WatchPower::isOnGrid(){
    return !isOnBattery();
}

bool WatchPower::isGridAvailable(){
    const float MAX_VOLTAGE = 300;
    const float MIN_VOLTAGE = 100;
    const float MAX_FREQUENCY = 70;
    const float MIN_FREQUENCY = 40;

    return (gridVoltage.flt > MIN_VOLTAGE) &&
           (gridVoltage.flt < MAX_VOLTAGE) &&
           (gridFreq.flt > MIN_FREQUENCY) &&
           (gridFreq.flt < MAX_FREQUENCY);
}

bool WatchPower::isSolarAvailable(){
    const float MIN_VOLTAGE = 10;

    return (solarVoltage.flt > MIN_VOLTAGE);
}


bool WatchPower::setOutputSourcePriority(OutputSourcePriorities prio){
    char command[50];
    char inputBuffer[25];

    /* Make Command */
    sprintf(command, "POP%02u", prio);
    appendCRC(command);

    int error = querySolar(command, inputBuffer, sizeof(inputBuffer));

    return (error == false && isACK(inputBuffer));
}

bool WatchPower::setChargePriority(ChargePriorities prio){
    char command[50];
    char inputBuffer[25];

    /* Make Command */
    sprintf(command, "PCP%02u", prio);
    appendCRC(command);

    int error = querySolar(command, inputBuffer, sizeof(inputBuffer));

    return (error == false && isACK(inputBuffer));
}

bool WatchPower::setBatteryRechargeVoltage(BatteryRechargeVoltages voltage){
    char command[50];
    char inputBuffer[25];

    /* Make Command */
    sprintf(command, "PBCV%s", BatteryRechargeVoltages2Str[(int)voltage]);
    appendCRC(command);

    int error = querySolar(command, inputBuffer, sizeof(inputBuffer));

    return (error == false && isACK(inputBuffer));
}

bool WatchPower::setBatteryReDischargeVoltage(BatteryReDischargeVoltages voltage){
    char command[50];
    char inputBuffer[25];

    /* Make Command */
    sprintf(command, "PBCV%s", BatteryReDischargeVoltages2Str[(int)voltage]);
    appendCRC(command);

    int error = querySolar(command, inputBuffer, sizeof(inputBuffer));

    return (error == false && isACK(inputBuffer));
}

bool WatchPower::setBatteryType(BatteryTypes batteryType){
    char command[50];
    char inputBuffer[25];

    /* Make Command */
    sprintf(command, "PBT%02u", batteryType);
    appendCRC(command);

    int error = querySolar(command, inputBuffer, sizeof(inputBuffer));

    return (error == false && isACK(inputBuffer));
}

bool WatchPower::setBulkChargingVoltage(){
    // Сюда передать переменную
    Serial.print("123");
}

void WatchPower::parseSerialNumber(const char *buffer){
    strncpyTerminated(serialNumer, buffer+1,14);
}

void WatchPower::parseFirmwareVerPrimary(const char *buffer){
    strncpyTerminated(firmwareVerPrimary, buffer+7,8);
}

void WatchPower::parseFirmwareVerSecondary(const char *buffer){
    strncpyTerminated(firmwareVerSecondary, buffer+8,8);
}


void WatchPower::parseFlags(const char *buffer){
    bool isEnabled = true;
    buffer++; /* Skip start byte '(' */

    #define CASE_MAKER(val,field) \
    case val:                     \
        field = isEnabled;        \
        break                     \

    for(int i=0; i<11; i++){
        switch(buffer[i]){
        case 'E':
            isEnabled = true;
            break;
        case 'D':
            isEnabled = false;
            break;
            CASE_MAKER('a', flags.buzzer);
            CASE_MAKER('b', flags.overLoadBypass);
            CASE_MAKER('j', flags.powerSaving);
            CASE_MAKER('k', flags.lcdTimeout);
            CASE_MAKER('u', flags.overloadRestart);
            CASE_MAKER('v', flags.overTemperatureRestart);
            CASE_MAKER('x', flags.backlight);
            CASE_MAKER('y', flags.alarm);
            CASE_MAKER('z', flags.faultCodeRecord);
        }
    }

    #undef CASE_MAKER
}

void WatchPower::parseRating(const char *buffer){
    DBG(buffer);
}

WatchPower.h

#pragma once

/* WatchPower library by Hassan Nadeem
*/

#include "Arduino.h"
//#include "Particle.h"
#include <stdint.h>

#define CRC_HIGH_BYTE( crc )   ((crc) >> 8) & 0xFF
#define CRC_LOW_BYTE( crc )    (crc) & 0xFF

#define DBG(str)                                       \
    do{                                                \
        delay(1000);  /* To avoid rate limit */        \
        Serial.print(str);                             \
    }while(0)

#define strncpyTerminated(destination, source, num)   \
    do{                                               \
        strncpy(destination, source, num);            \
        destination[num] = 0;                         \
    }while(0)

class WatchPower{
public:
    /* All enums are position sensitive */
    enum class OutputSourcePriorities{UtilityFirst, SolarFirst, SBU};
    enum class ChargePriorities{UtilityFirst, SolarFirst, SolarAndUtility, SolarOnly};
    enum class BatteryTypes{AGM, Flooded, User};
    enum class GridRange{Appliance, UPS};
    enum class BatteryRechargeVoltages{V22, V22_5, V23, V23_5, V24, V24_5, V25, V25_5};
    static constexpr char *BatteryRechargeVoltages2Str[] = {
        "22", "22.5", "23", "23.5", "24", "24.5", "25", "25.5"
    };
    enum class BatteryReDischargeVoltages{Full, V25, V25_5, V26, V26_5, V27, V27_5, V28, V28_5, V29};
    static constexpr char *BatteryReDischargeVoltages2Str[] = {
        "00.0", "25", "25.5", "26", "26.5", "27", "27.5", "28", "28.5", "29"
    };
    enum class OututFrequencies{HZ50, HZ60};
    static constexpr char *OututFrequencies2Str[] = {
        "50", "60"
    };

    struct floatEntry{
        char str[10];
        float flt;
    };

    struct statusEntry{
        char str[8+1]; /* 8 bits */
        union{
            uint8_t byte;
            struct{
                bool acChargingStatus:1;
                bool sccChargingStatus:1;
                bool chargingStatus:1;
                bool reserved_b3:1;
                bool loadStatus:1;
                bool sscVersion:1;
                bool configStatus:1;
                bool reserved_b7:1;
            } bits;
        } status;
    };

    struct flagEntry{
        bool buzzer;
        bool overLoadBypass;
        bool powerSaving;
        bool lcdTimeout;
        bool overloadRestart;
        bool overTemperatureRestart;
        bool backlight;
        bool alarm;
        bool faultCodeRecord;
    };

    struct warningEntry{
        char str[32+1]; /* 32 bits */
        union{
            uint32_t word;
            struct{
                bool reserved_a0:1;
                bool inverterFault:1;
                bool busOver:1;
                bool busUnder:1;
                bool busSoftFail:1;
                bool lineFail:1;
                bool opvShort:1;
                bool inverterVoltageTooLow:1;
                bool interverVoltageTooHigh:1;
                bool overTemperature:1;
                bool fanLocked:1;
                bool batteryVoltageHigh:1;
                bool batteryLowAlarm:1;
                bool reserved_a13:1;
                bool batteryUnderShutdown:1;
                bool reserved_a15:1;
                bool overLoad:1;
                bool eepromFault:1;
                bool inverterOverCurrent:1;
                bool inverterSoftFail:1;
                bool selfTestFail:1;
                bool opdcVoltageOver:1;
                bool batteryOpen:1;
                bool currentSensorFail:1;
                bool batteryShort:1;
                bool powerLimit:1;
                bool pvVoltageHigh:1;
                bool mpptOverloadFault:1;
                bool mpptOverloadWarning:1;
                bool batteryTooLowToCharge:1;
                bool reserved_a30:1;
                bool reserved_a31:1;
            } bits;
        } warning;
    };

    struct ratingEntry{
        floatEntry batteryRechargeVoltage;
        BatteryTypes batteryType;
        floatEntry maxACChargingCurrent;
        floatEntry maxChargingCurrent;
        OutputSourcePriorities outputSourcePriority;
        ChargePriorities chargePriority;
    };

private:
    /* Device general status parameters inquiry */
    static constexpr char *CMD_GENERAL_STATUS = "QPIGS\xB7\xA9";
    /* Device Mode inquiry */
    static constexpr char *CMD_MODE_INQUIRY = "QMOD\x49\xC1";
    /* Device Warning Status inquiry */
    static constexpr char *CMD_WARNING_STATUS = "QPIWS\xB4\xDA";
    /* The device serial number inquiry */
    static constexpr char *CMD_SERIAL_INQUIRY = "QID\xD6\xEA";
    /* Main CPU Firmware version inquiry */
    static constexpr char *CMD_FIRMWARE_PRIM_VER_INQUIRY = "QVFW\x62\x99";
    /* Another CPU Firmware version inquiry  */
    static constexpr char *CMD_FIRMWARE_SEC_VER_INQUIRY = "QVFW2\xC3\xF5";
    /* Device Rating Information inquiry */
    static constexpr char *CMD_RATING_INQUIRY = "QPIRI\xF8\x54";
    /* Device flag status inquiry */
    static constexpr char *CMD_FLAG_INQUIRY = "QFLAG\x98\x74";


    HardwareSerial* refSer;
    bool conditioningEnabled = false;

    uint16_t calculateCRC(const char *ptr, int count);
    void appendCRC(char *str);
    bool validateCRC(char *str, uint16_t len);
    void clearSerialBuffer();
    uint16_t readLine(char *buffer, uint16_t length);
    void sendLine(const char *str);
    bool querySolar(const char *query, char *buffer, uint16_t bufferLen);
    bool isACK(const char *str);
    bool isNACK(const char *str);
    /* --- Parsing Functions --- */
    void parseQPIGS(const char *buffer);
    void parseQMOD(const char *buffer);
    void parseWarnings(const char *buffer);
    void parseSerialNumber(const char *buffer);
    void parseFirmwareVerPrimary(const char *buffer);
    void parseFirmwareVerSecondary(const char *buffer);
    void parseRating(const char *buffer);
    void parseFlags(const char *buffer);
    /*--------------------------------*/
    void conditionData();


public:
    char serialNumer[15];
    char firmwareVerPrimary[9];
    char firmwareVerSecondary[9];

    flagEntry flags;

    /* QMODE */
    char mode;
    /* QPIGS */
    floatEntry gridVoltage;
    floatEntry gridFreq;
    floatEntry outputVoltage;
    floatEntry outputFreq;
    floatEntry outputPowerApparent;
    floatEntry outputPowerActive;
    floatEntry loadPercent;
    floatEntry busVoltage;
    floatEntry batteryVoltage;
    floatEntry batteryCurrent;
    floatEntry batteryCapacity;
    floatEntry temperature;
    floatEntry solarCurrent;
    floatEntry solarVoltage;
    floatEntry batteryVoltageSCC;
    floatEntry batteryDischargeCurrent;
    statusEntry status;
    warningEntry warning;

    /* Constructor and Destructor */
    WatchPower(HardwareSerial &_refSer);
    WatchPower(HardwareSerial &_refSer, bool _conditioningEnabled);
    ~WatchPower();

    /* Get parameters */
    bool refreshData();
    bool refreshDeviceConstants();
    bool refreshSettings();

    /*  */
    bool isOnBattery();
    bool isOnGrid();
    bool isCharging();
    bool isSolarCharging();
    bool isGridCharging();
    bool isGridAvailable();
    bool isSolarAvailable();

    /* Set parameters */
    bool setOutputSourcePriority(OutputSourcePriorities prio);
    bool setBatteryType(BatteryTypes batteryType);
    bool setChargePriority(ChargePriorities prio);
    bool setBatteryRechargeVoltage(BatteryRechargeVoltages voltage);
    bool setBatteryReDischargeVoltage(BatteryReDischargeVoltages voltage);
    bool setBulkChargingVoltage();

};

библиотеку тоже сюда выложите, пожалуйста

В текстовом виде или как? Не совсем понял.

Все, что необходимо для понимания проблемы, должно быть выложено здесь. По внешним ссылкам никто ходить не будет.

И - да, текст выкладывать только в виде текста.

какую функцию вы добавили? parseRating() ?

и какая ошибка7

В файле WatchPower.h

Добавил:

bool setBulkChargingVoltage();

Далее в файле WatchPower.cpp

Добавил

bool WatchPower::setBulkChargingVoltage(){
    // Сюда передать переменную
    Serial.print("123");
}

у вас в этом коде куча методов с параметрами - возьмите любой и сделайте по аналогии.

Тот же parseRating() например

bool setBulkChargingVoltage();

bool WatchPower::setBulkChargingVoltage(){
    // Сюда передать переменную
    Serial.print("123");
}

Так Вы ж её добавили без аргументов. А хотите передавать параметры. Какие? Добавьте их к описанию функции-то!

Первый вариант, который попробовал по аналогии.

watchPower.setBulkChargingVoltage(&value);

bool WatchPower::setBulkChargingVoltage(int *value){
    // Сюда передать переменную
    Serial.print("123");
}

Ошибка:

no matching function for call to 'WatchPower::setBulkChargingVoltage(int*)'

Второй вариант:

watchPower.setBulkChargingVoltage(value);

bool WatchPower::setBulkChargingVoltage(int &value){
    // Сюда передать переменную
    Serial.print("123");
}

Ошибка:

no matching function for call to 'WatchPower::setBulkChargingVoltage(int&)

Пробовал, делать как в библиотеке, но не компилируется.

Бред какой-то. Почему разные описания? Почему в объявлении (value), а в определении (int &value)? Компилятор же вам почти по русски пишет о несоответствии

Для это я задал вопрос, потому как не понимаю как именно правильно задать аргументы.

Для понимания - https://www.google.ru/search?newwindow=1&sxsrf=ALeKk014a_us5j-eqCGHhGPuu2PxT7ZYKQ%3A1608911018122&ei=qgjmX6WKB-KIrwSx2Ij4CA&q=c%2B%2B+аргументы+функции&oq=c+++аргументы+функции&gs_lcp=CgZwc3ktYWIQARgAMgcIIxCwAxAnMgcIABBHELADMgcIABBHELADMgcIABBHELADMgcIABBHELADMgcIABBHELADMgcIABBHELADMgcIABBHELADMgcIABBHELADUABYAGDfTWgBcAJ4AIABAIgBAJIBAJgBAKoBB2d3cy13aXrIAQnAAQE&sclient=psy-ab

Вот пошло, спасибо большое, именно то что искал. Я перелопатил кучу но не мог понять как правильно сформулировать запрос. Вы дали именно, то что нужно.

Итоговый код:

Вызов
watchPower.setBulkChargingVoltage(value);

Файл WatchPower.cpp
bool WatchPower::setBulkChargingVoltage(int value){
    // Сюда передать переменную
    Serial.print(value);
}

Файл WatchPower.h
bool setBulkChargingVoltage(int value);

Можно я глупый вопрос задам (уж простите мужчину во второй стадии зрелости :) ).

Вопрос: Если есть класс (какой-то, к примеру, exemple1) и у него есть метод - void exemple1::exMethod1(void) (простите за ошибки возможные, читайте суть). Я ведь могу породить от этого класса свой, например, exemple2, а уже в нем переопределить функцию exMethod1, к примеру, так: void exemple1::exMethod1(byte cols)? Библиотека с классом распространяется с исходником, ничего мешать не должно? Или есть подводные камни? Или тут идут ограничения о том какой именно метод (private, public и т.п.)?

Если не будете обзываться и троллить - огромное спасибо за ответы.

Да. Цель-то в чем?

ЗЫ. Книжка про ООП  - Вам в помощь.

Ну это полный оффтоп.

Цель - понять. Почему-то b707 в его вопросе о функции родительского класса не применил такую "фишку" (что-то его тему найти не могу, чтобы ссылку дать), если так можно реализовать в ардуино-проектах? Если можно было в принципе - почему тогда не применил? Наверное ответ не просто "Да".

b707, Вы то точно поняли о чем вопрос. Дополните, если прочтете.

Прочитал :)

Но что-то тоже не очень понимаю, о чем речь.

С полгода назад я спрашивал, можно ли заставить метод дочернего класса ВСЕГДА вызываться вместо родительсткого, не обьявляя последний виртуальным... это?

Вы путаете длинное с тёплым. 

"Переопределить" - это определить в дочернем классе метод с такой же сигнатурой (т.е. с такими же именем,  типами параметров и возвращаемым значением).

Вы же хотите сделать функцию с другим набором параметров - это называется "перегрузить имя". Это можно делать всегда, хоть в дочернем классе, хоть в том же самом - нет проблем.

Единственное ограничение, чтобы эти функции синтаксически отличались одна от другой. Например, если одна функция без параметров, как у Вас, а другая с параметрами, то нельзя давать всем параметрам значения по умолчанию, иначе при вызове с пустыми скобками компилятор не поймёт кого именно Вы хотите вызвать.

Евгений Петрович, над Вашим "троллингом" я не могу даже думать обижаться, очень уж он добрый и с хорошими разъяснениями. Спасибо!

Ой, да - это. "Тут помню, там не помню...". Простите, был не прав. Почему-то вчера подумал, что наследованием можно было решить проблему, а вот и нет. А отталкивался от вопроса ТС... :(