[参考译文] MSP430FR2155：ERROR：[E0300]以下符号未定义：

admin

Other Parts Discussed in Thread: BQ34Z100, BQ34Z100-R2, MSP430FR2155, MSPMATHLIB

请注意，本文内容源自机器翻译，可能存在语法或其它翻译错误，仅供参考。如需获取准确内容，请参阅链接中的英语原文或自行翻译。

https://e2e.ti.com/support/microcontrollers/msp-low-power-microcontrollers-group/msp430/f/msp-low-power-microcontroller-forum/1349616/msp430fr2155-error-e0300-the-following-symbols-are-undefined

器件型号：MSP430FR2155
主题中讨论的其他器件：BQ34Z100-R2、BQ34Z100 、 MSPMATHLIB

您好、TI 专家！

我使用 MSP430FR2155和 BQ34Z100-R2来检索数据。我有一个可以读写数据的代码。

但是,当我尝试构建它时,我得到这个错误: [E0300]以下符号未定义：

您能帮我解决这个问题吗？

提前感谢！

3 个月前

0 admin 3 个月前

TI__Guru**** 1135610 points

请注意，本文内容源自机器翻译，可能存在语法或其它翻译错误，仅供参考。如需获取准确内容，请参阅链接中的英语原文或自行翻译。

这意味着您未正确链接。哪些符号未定义？

0 admin 3 个月前

TI__Guru**** 1135610 points

请注意，本文内容源自机器翻译，可能存在语法或其它翻译错误，仅供参考。如需获取准确内容，请参阅链接中的英语原文或自行翻译。

感谢您的回复。不过、我做了一些更改并修复了此器件

现在我有另一组错误。我会在下面附上代码和错误的屏幕截图

main.c

#include <stdio.h>
#include <inttypes.h>
#include <msp430.h>
#include <driverlib.h>
#include <gpio.h>
#include "drivers.h"
#include "BQ34Z100.h"

void i2c_init();
void GPIO_Init();
void GPIO_configPins();


int main(void)
{
	WDTCTL = WDTPW | WDTHOLD;   // stop watchdog timer

	i2c_init();
	GPIO_Init();
	    BQ34Z100 bq;

	    uint16_t status = BQ34Z100_1_getStatus(&bq);
	    printf("Status: %d\n", status);


	return 0;
}


void i2c_init()
{
    UCB1CTLW0 |=  UCSWRST;       // SWRST SET

    UCB1CTLW0 |= UCSSEL_3;       //CHOOSE SMCLK
    UCB1BRW = 400;                //CHOOSE PRESCALER VALUEwhere SMCLK =16MHz, 16000000/400 = 40000

    UCB1CTLW0 |= UCMODE_3;      // CHOOSE I2C MODE
    UCB1CTLW0 |= UCMST;         //CHOOSE MASTER MODE
    UCB1CTLW0 |= UCTR;          //CHOOSE TRANSMITTER MODE
    UCB1I2CSA |= 0xAA;          //set slave address

    UCB1CTLW0 |= UCSYNC;        //enable synchronous mode

    P4SEL1 &= ~BIT7;
    P4SEL0 |= BIT7;             //SET P4.7 AS SCL

    P4SEL1 &= ~BIT6;
    P4SEL0 |= BIT6;             //SET P4.6 AS SDA

    PM5CTL0 &= ~LOCKLPM5;

    UCB0CTLW0 &= ~UCSWRST;      //CLEAR SWRST



    UCB0IE |= UCTXIE0;
    __enable_interrupt();
}


void GPIO_Init()
{
    P1OUT = 0x00; P2OUT = 0x00;
    P3OUT = 0x00; P4OUT = 0x00;
    P5OUT = 0x00;

    P1DIR |= 0xFF; P2DIR |= 0xFF;
    P3DIR |= 0xFF; P4DIR |= 0xFF;
    P5DIR |= 0xFF;

    GPIO_configPins();
}


void GPIO_configPins()
{
    P1DIR &= ~BIT6;
    P1REN |= BIT6;


    P2DIR &= ~BIT0 & ~BIT2;
    P2REN |= BIT0 | BIT2;


    P5DIR &= ~BIT0;
    P5REN |= ~BIT0;

}

源码：

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <inttypes.h>
#include <stdbool.h>
#include <math.h>
#include "driverlib.h"
#include "BQ34Z100.h"
#include "drv_i2c.h"

uint8_t currFlashPage;
uint8_t currFlashBlockIndex;
uint8_t flashbytes[32];

void delay(int DELAY)

{
   short i;
   for (i = 0; i < DELAY; i++) {}
}

float BQ34Z100_1_xemicsToFloat(uint32_t xemics);

typedef struct {
    int hz;
    uint8_t addr = 0xAA;
} I2C;

typedef struct {
    I2C i2c;
} BQ34Z100_1;

BQ34Z100* BQ34Z100_create() {
    BQ34Z100* bq34z100 = (BQ34Z100*)malloc(sizeof(BQ34Z100));

    // Check if memory allocation was successful
    if (bq34z100 == NULL) {
        // Handle memory allocation failure
        return NULL; // Return NULL to indicate failure
    }

    // Initialize the structure members if necessary
    // You can add initialization code here if needed

    return bq34z100; // Return a pointer to the newly allocated structure
}

// Function to destroy an instance of BQ34Z100
void BQ34Z100_destroy(BQ34Z100* bq34z100) {
    // Check if the pointer is not NULL
    if (bq34z100 != NULL) {
        // Free the memory allocated for the BQ34Z100 structure
        free(bq34z100);
    }
    // Note: If there are other cleanup tasks, such as releasing resources held by
    // members of the structure, you can perform them here before freeing the memory.
}


void BQ34Z100_1_write(BQ34Z100_1* bq, Command command, const uint8_t cmd)
{
    unsigned int sentbyte = 0;
    uint8_t cmd8 = (uint8_t)command;
    int writeResult = I2CSendBytes(bq->i2c.addr, &cmd8, 2, &sentbyte);
    if(writeResult != 0) {
        printf("A write error has occurred when transmitting address.\r\n");
    }
}

uint32_t BQ34Z100_1_read(BQ34Z100_1* bq, Command command, const uint8_t length) {
    uint32_t val = 0;
    int i;
    for (i = 0; i < length; i++)
    {
        uint8_t cmdByte = (uint8_t)command + i;
        int writeResult = I2CSendByte(bq->i2c.addr, cmdByte);
        if(writeResult != 0) {
            printf("A write error has occurred when transmitting address.\r\n");
        }
        unsigned char readByte;
        unsigned int count = 0;
        int readResult = I2CReadBytes(bq->i2c.addr, &readByte, 1, &count);
        if(readResult != 0) {
            printf("A read error has occurred when reading data.\r\n");
        }
        val |= ((uint32_t)readByte << (8 * i));
    }
    return val;
}

void BQ34Z100_1_sendControlCommand(BQ34Z100_1* bq, Control_2 control) {
    uint16_t controlBytes = (uint16_t)control;
    BQ34Z100_1_write(bq, Control, controlBytes & 0xFF);
   // BQ34Z100_1_write(bq, Command2 (controlBytes >> 8) & 0xFF);
}

uint16_t BQ34Z100_1_readControlCommand(BQ34Z100_1* bq, Control_2 control) {
    BQ34Z100_1_sendControlCommand(bq, control);
    return BQ34Z100_1_read(bq, Control , 2);
}

void BQ34Z100_1_write2(BQ34Z100_1* bq, Command command, const uint8_t cmd1, const uint8_t cmd2) {
    uint8_t command8 = (uint8_t)command;
    unsigned int sentbyte = 0;
    int writeResult = I2CSendBytes(bq->i2c.addr, &command8, 3, &sentbyte);
    if(writeResult != 0) {
        printf("A write error has occurred when transmitting address.\r\n");
    }
}

void BQ34Z100_1_enableCal(BQ34Z100_1* bq) {
    BQ34Z100_1_sendControlCommand(bq, CAL_ENABLE);
}

void BQ34Z100_1_enterCal(BQ34Z100_1* bq) {
    BQ34Z100_1_sendControlCommand(bq, ENTER_CAL);
}

void BQ34Z100_1_exitCal(BQ34Z100_1* bq) {
    BQ34Z100_1_sendControlCommand(bq, EXIT_CAL);
}

void BQ34Z100_1_ITEnable(BQ34Z100_1* bq) {
    BQ34Z100_1_sendControlCommand(bq, IT_ENABLE);

}

uint16_t getATTE(BQ34Z100_1* bq)
{
    return(BQ34Z100_1_read(bq, AverageTimeToEmpty , 2));
}

uint16_t getATTF(BQ34Z100_1* bq)
{
    return(BQ34Z100_1_read(bq, AverageTimeToFull , 2));
}

uint8_t getVoltScale(BQ34Z100_1* bq)
{
    return(BQ34Z100_1_read(bq, VoltScale , 1));
}

uint8_t getCurrScale(BQ34Z100_1* bq)
{
    return(BQ34Z100_1_read(bq, CurrScale , 1));
}

uint8_t getEnergyScale(BQ34Z100_1* bq)
{
    return(BQ34Z100_1_read(bq, EnergyScale , 1));
}

uint16_t getAvailableEnergy(BQ34Z100_1* bq)
{
    return(BQ34Z100_1_read(bq, AvailableEnergy , 2));
}

uint16_t getAvgPower(BQ34Z100_1* bq)
{
    return(BQ34Z100_1_read(bq, AveragePower , 2));
}

uint16_t getChargeVoltage(BQ34Z100_1* bq)
{
    return(BQ34Z100_1_read(bq, ChargeVoltage , 2));
}

uint16_t getChargeCurrent(BQ34Z100_1* bq)
{
    return(BQ34Z100_1_read(bq, ChargeCurrent , 2));
}

uint16_t getGridNumber(BQ34Z100_1* bq)
{
    return(BQ34Z100_1_read(bq, GridNumber , 2));
}

uint8_t BQ34Z100_1_getFull(BQ34Z100_1* bq)
{
    return(BQ34Z100_1_read(bq, FullChargeCapacity, 1));
}

uint8_t getLearnedStatus(BQ34Z100_1* bq)
{
    return(BQ34Z100_1_read(bq, LearnedStatus , 1));
}

uint8_t getDoDatEOC(BQ34Z100_1* bq)
{
    return(BQ34Z100_1_read(bq, DoDatEOC , 1));
}

uint8_t getQstart(BQ34Z100_1* bq)
{
    return(BQ34Z100_1_read(bq, QStart , 1));
}

uint16_t getTrueRC(BQ34Z100_1* bq)
{
    return(BQ34Z100_1_read(bq, TrueRC , 2));
}

uint16_t getTrueFCC(BQ34Z100_1* bq)
{
    return(BQ34Z100_1_read(bq, TrueFCC , 2));
}

uint16_t getStateTime(BQ34Z100_1* bq)
{
    return(BQ34Z100_1_read(bq, StateTime , 2));
}

uint16_t getDOD0(BQ34Z100_1* bq)
{
    return(BQ34Z100_1_read(bq, DOD0 , 2));
}

uint16_t getQmaxPassedQ(BQ34Z100_1* bq)
{
    return(BQ34Z100_1_read(bq, QMaxPassedQ , 2));
}

uint16_t getQmaxDOD0(BQ34Z100_1* bq)
{
    return(BQ34Z100_1_read(bq, QmaxDOD0 , 2));
}

uint16_t getQmaxTime(BQ34Z100_1* bq)
{
    return(BQ34Z100_1_read(bq, QmaxTime , 2));
}

uint16_t getAvgCurrent(BQ34Z100_1* bq)
{
    return(BQ34Z100_1_read(bq, AverageCurrent, 2));
}

uint16_t getCC(BQ34Z100_1* bq)
{
    return(BQ34Z100_1_read(bq, CycleCount, 2));
}

uint16_t BQ34Z100_1_getStatus(BQ34Z100_1* bq) {
    return BQ34Z100_1_readControlCommand(bq, CONTROL_STATUS);
}

uint16_t BQ34Z100_1_getChemID(BQ34Z100_1* bq) {
    return BQ34Z100_1_readControlCommand(bq, CHEM_ID);
}

uint16_t BQ34Z100_1_getStateOfHealth(BQ34Z100_1* bq) {
    return BQ34Z100_1_read(bq, StateOfHealth, 2);
}

uint8_t BQ34Z100_1_getSOC(BQ34Z100_1* bq) {
    return BQ34Z100_1_read(bq, StateOfCharge, 1);
}

uint16_t BQ34Z100_1_getError(BQ34Z100_1* bq) {
    return BQ34Z100_1_read(bq, MaxError, 1);
}

uint16_t BQ34Z100_1_getRemaining(BQ34Z100_1* bq) {
    return BQ34Z100_1_read(bq, RemainingCapacity, 2);
}

uint16_t BQ34Z100_1_getVoltage(BQ34Z100_1* bq) {
    return BQ34Z100_1_read(bq, Voltage, 2);
}

int16_t BQ34Z100_1_getCurrent(BQ34Z100_1* bq) {
    int16_t result = BQ34Z100_1_read(bq, Current, 2);
    if (result < 0) result = -result;
    return result;
}

double BQ34Z100_1_getTemperature(BQ34Z100_1* bq) {
    return (BQ34Z100_1_read(bq, Temperature, 2) / 10.0) - 273.15;
}

//

double BQ34Z100_1_getIntTemperature(BQ34Z100_1* bq) {
    return (BQ34Z100_1_read(bq, InternalTemperature, 2) / 10.0) - 273.15;
}


int BQ34Z100_1_getSerial(BQ34Z100_1* bq) {
    return BQ34Z100_1_read(bq,SerialNumber, 2);
}

void BQ34Z100_1_reset(BQ34Z100_1* bq) {
    BQ34Z100_1_sendControlCommand(bq, RESET);
    delay(175);
}

void BQ34Z100_1_unseal(BQ34Z100_1* bq) {
    BQ34Z100_1_sendControlCommand(bq, UNSEAL_KEY1);
    BQ34Z100_1_sendControlCommand(bq, UNSEAL_KEY2);
}

void BQ34Z100_1_seal(BQ34Z100_1* bq) {
    BQ34Z100_1_sendControlCommand(bq, SEALED);
}

void BQ34Z100_1_changePage(BQ34Z100_1* bq, char subclass, uint16_t offset) {
    delay(10);
    BQ34Z100_1_write(bq, BlockDataControl, 0x00);
    delay(10);
    BQ34Z100_1_write(bq, DataFlashClass, subclass);
    delay(10);
    currFlashPage = subclass;
    delay(10);
    currFlashBlockIndex = (uint8_t)(offset / 32);
    BQ34Z100_1_write(bq, DataFlashBlock, currFlashBlockIndex);
    delay(20);
}

uint8_t BQ34Z100_1_calcChecksum()
{
    uint8_t chkSum = 0;
    int i;
    for (i = 0; i < 32; i++)
    {
        chkSum += flashbytes[i];
    }
    chkSum = 255 - chkSum;
    return chkSum;
}

void BQ34Z100_1_updateChecksum(BQ34Z100_1* bq)
{
    uint8_t newChecksum = BQ34Z100_1_calcChecksum();
    BQ34Z100_1_write(bq, BlockDataCheckSum, newChecksum);
    printf("Writing new checksum for page %d" PRIu8 " block %d" PRIu8 ": 0x%d" PRIx8 "\r\n" , currFlashPage, currFlashBlockIndex, newChecksum);
    delay(50);
}

void BQ34Z100_1_readFlash(BQ34Z100_1* bq) {
    unsigned char command = (char)BlockData;
//    int writeResult = write(bq->i2c.hz, &command, 1);
    int writeResult = I2CSendByte(bq->i2c.addr, command);
    if(writeResult != 0) {
        printf("A write error has occurred when transmitting address.\r\n");
    }
    uint16_t count = 0;
    uint8_t flash32;
    int readResult = I2CReadBytes(bq->i2c.addr, &flash32, 32, &count);
    flash32 = flashbytes[31];
    if(readResult != 0) {
        printf("A read error has occurred when reading data.\r\n");
    }
    uint8_t expectedChecksum = BQ34Z100_1_read(bq, BlockDataCheckSum, 1);
    if(expectedChecksum != BQ34Z100_1_calcChecksum()) {
        printf("ERROR: Checksum of flash memory block does not match.  I2C read was likely corrupted.");
    }
    printf("Page %d" PRIu8 " block %d" PRIu8 " contents:", currFlashPage, currFlashBlockIndex);
    size_t byteIndex;
    for(byteIndex = 0 ; byteIndex < 32 ; ++byteIndex)
    {
        printf(" %d" PRIx8, flashbytes[byteIndex]);
    }
    printf("\r\n");
    printf("Checksum: 0x%d" PRIx8 "\r\n", expectedChecksum);
    delay(10);
}

void BQ34Z100_1_writeFlash(BQ34Z100_1* bq, uint8_t index, uint32_t value, int len) {
    if (index > 31) index = index % 32;
    if (len == 1) {
        flashbytes[index] = value;
        BQ34Z100_1_write(bq, (Command)(BlockData + index), (unsigned char)value);
        printf("Flash[%d] <- 0x%d" PRIx8 "\n", index, flashbytes[index]);
    } else if (len > 1)
    {
        int i;
        for (i = 0; i < len - 1; i++)
        {
            flashbytes[index + i] = value >> 8 * ((len - 1) - i);
            printf("Flash[%d] <- 0x%d" PRIx8 "\n", index + i, flashbytes[index + i]);
            BQ34Z100_1_write(bq, (Command)(BlockData + index + i), flashbytes[index + i]);
        }
        flashbytes[index + len - 1] = value & 0xFF;
        printf("Flash[%d] <- 0x%d" PRIx8 "\n", index + (len - 1), flashbytes[index + len - 1]);
        BQ34Z100_1_write(bq, (Command)(BlockData + index + len - 1), value & 0xFF);
    }
}

uint8_t* BQ34Z100_1_getFlashBytes(BQ34Z100_1* bq) {
    return flashbytes;
}

void BQ34Z100_1_changePage48(BQ34Z100_1* bq) {
    BQ34Z100_1_changePage(bq, 48, 0);
    BQ34Z100_1_readFlash(bq);
    BQ34Z100_1_writeFlash(bq, 11, DESIGNCAP, 2);
    BQ34Z100_1_writeFlash(bq, 13, DESIGNENERGY, 2);
    BQ34Z100_1_updateChecksum(bq);
    delay(300);
}

void BQ34Z100_1_changePage64(BQ34Z100_1* bq) {
    BQ34Z100_1_changePage(bq, 64, 0);
    BQ34Z100_1_readFlash(bq);
    uint8_t packConfig_high = flashbytes[0];
    uint8_t packConfig_low = flashbytes[1];
    if (VOLTSEL) {
        packConfig_high |= 0x08;
    }
    packConfig_high |= 0x40;
    packConfig_low &= ~(1);
    packConfig_low |= USE_EXTERNAL_THERMISTOR;
    BQ34Z100_1_writeFlash(bq, 0, packConfig_high, 1);
    BQ34Z100_1_writeFlash(bq, 1, packConfig_low, 1);
    uint8_t packConfigB = flashbytes[2];
    packConfigB &= ~1;
    BQ34Z100_1_writeFlash(bq, 2, packConfigB, 1);
    BQ34Z100_1_writeFlash(bq, 4, LEDCONFIG, 1);
    BQ34Z100_1_writeFlash(bq, 7, 0x04, 1);
    BQ34Z100_1_updateChecksum(bq);
    delay(300);
}

void BQ34Z100_1_changePage80(BQ34Z100_1* bq) {
    BQ34Z100_1_changePage(bq, 80, 0);
    BQ34Z100_1_readFlash(bq);
    BQ34Z100_1_writeFlash(bq, 0, LOADSELECT, 1);
    BQ34Z100_1_writeFlash(bq, 1, LOADMODE, 1);
    BQ34Z100_1_writeFlash(bq, 10, 10, 2);
    BQ34Z100_1_updateChecksum(bq);
    delay(300);
    BQ34Z100_1_changePage(bq, 80, 53);
    BQ34Z100_1_readFlash(bq);
    BQ34Z100_1_writeFlash(bq, 53, ZEROCHARGEVOLT, 2);
    BQ34Z100_1_updateChecksum(bq);
    delay(300);
}

void BQ34Z100_1_changePage82(BQ34Z100_1* bq) {
    BQ34Z100_1_changePage(bq, 82, 0);
    BQ34Z100_1_readFlash(bq);
    BQ34Z100_1_writeFlash(bq, 0, QMAX0, 2);
    BQ34Z100_1_updateChecksum(bq);
    delay(300);
}

uint16_t BQ34Z100_1_calibrateVoltage(BQ34Z100_1* bq, uint16_t currentVoltage) {
    BQ34Z100_1_changePage(bq, 104, 0);
    BQ34Z100_1_readFlash(bq);
    uint16_t flashVoltage = (uint16_t)(flashbytes[14] << 8);
    flashVoltage |= (uint16_t)(flashbytes[15]);
    float readVoltage = (float)BQ34Z100_1_getVoltage(bq);
    float newSetting = ((float)(currentVoltage) / readVoltage) * (float)(flashVoltage);
    uint16_t writeSetting;
    if (newSetting > 65535.0f) writeSetting = 65535;
    else if (newSetting < 0.0f) writeSetting = 0;
    else writeSetting = (uint16_t)(newSetting);
    BQ34Z100_1_writeFlash(bq, 14, writeSetting, 2);
    BQ34Z100_1_updateChecksum(bq);
    delay(10);
    BQ34Z100_1_changePage(bq, 68, 0);
    BQ34Z100_1_readFlash(bq);
    int16_t oldUpdateOK = 0;
    oldUpdateOK |= (uint16_t)(flashbytes[0] << 8);
    oldUpdateOK |= flashbytes[1];
    int16_t newUpdateOK = (int16_t)(round(FLASH_UPDATE_OK_VOLT * CELLCOUNT * (5000.0f / writeSetting)));
    printf("Changing Flash Update OK Voltage from %d" PRIi16 " to %d" PRIi16 "\r\n", oldUpdateOK, newUpdateOK);
    BQ34Z100_1_writeFlash(bq, 0, newUpdateOK, 2);
    BQ34Z100_1_updateChecksum(bq);
    printf("Register (voltage divider): %d\r\n", flashVoltage);
    printf("New Ratio: %f\r\n", ((float)(currentVoltage) / readVoltage));
    printf("READ VOLTAGE (mv): %f\r\n", readVoltage);
    return (uint16_t)newSetting;
}

void BQ34Z100_1_resetVoltageDivider(BQ34Z100_1* bq) {
    BQ34Z100_1_changePage(bq, 104, 0);
    BQ34Z100_1_readFlash(bq);
    BQ34Z100_1_writeFlash(bq, 14, RESETVOLTAGE, 2);
    BQ34Z100_1_updateChecksum(bq);
    delay(300);
}

uint32_t BQ34Z100_1_floatToXemics(float value) {
    int iByte1, iByte2, iByte3, iByte4, iExp;
    bool bNegative = false;
    float fMantissa;

    if (value == 0) value = 0.00001F;
    if (value < 0) {
        bNegative = true;
        value = -value;
    }

    iExp = (int)((log(value) / log(2)) + 1);

    iByte1 = iExp + 128;

    fMantissa = value / (pow(2, iExp));

    fMantissa = fMantissa / (pow(2, -24));

    iByte2 = (int)(fMantissa / (pow(2, 16)));
    iByte3 = (int)((fMantissa - (iByte2 * (pow(2, 16)))) / (pow(2, 8)));
    iByte4 = (int)(fMantissa - (iByte2 * (pow(2, 16))) - (iByte3 * (pow(2, 8))));

    if (bNegative == false) {
        iByte2 = iByte2 & 0x7F;
    }
    return (uint32_t)((uint32_t)iByte1 << 24 | (uint32_t)iByte2 << 16 | (uint32_t)iByte3 << 8 | (uint32_t)iByte4);
}

void BQ34Z100_1_calibrateShunt(BQ34Z100_1* bq, int16_t calCurrent) {
    if (calCurrent < 0) calCurrent = -calCurrent;
    int16_t currentReading = BQ34Z100_1_getCurrent(bq);
    if (currentReading < 0) currentReading = -currentReading;
    BQ34Z100_1_changePage(bq, 104, 0);
    BQ34Z100_1_readFlash(bq);
    delay(30);
    uint32_t currentGainDF = ((uint32_t)flashbytes[0]) << 24 | ((uint32_t)flashbytes[1]) << 16 | ((uint32_t)flashbytes[2]) << 8 | (uint32_t)flashbytes[3];
    float currentGainResistance = (4.768f / BQ34Z100_1_xemicsToFloat(currentGainDF));
    uint32_t currentDeltaDF = ((uint32_t)flashbytes[4]) << 24 | ((uint32_t)flashbytes[5]) << 16 | ((uint32_t)flashbytes[6]) << 8 | (uint32_t)flashbytes[7];
    float currentDeltaResistance = (5677445 / BQ34Z100_1_xemicsToFloat(currentGainDF));
    float newGain = (((float)currentReading) / ((float)calCurrent)) * currentGainResistance;
    uint32_t newGainDF = BQ34Z100_1_floatToXemics(4.768 / newGain);
    float DeltaDF = BQ34Z100_1_floatToXemics(5677445 / newGain);
    printf("currentGainDF = 0x%" PRIx32 ", currentGainResistance = %f, currentDeltaDF = %" PRIx32 ", currentDeltaResistance = %f, newGain = %f, newGainDF = 0x%" PRIx32 "\n",
           currentGainDF, currentGainResistance, currentDeltaDF, currentDeltaResistance, newGain, newGainDF);
    BQ34Z100_1_writeFlash(bq, 0, newGainDF, 4);
    BQ34Z100_1_writeFlash(bq, 4, DeltaDF, 4);
    BQ34Z100_1_updateChecksum(bq);
    delay(300);
}

void BQ34Z100_1_setSenseResistor(BQ34Z100_1* bq) {
    BQ34Z100_1_changePage(bq, 104, 0);
    BQ34Z100_1_readFlash(bq);
    delay(30);
    uint32_t GainDF = BQ34Z100_1_floatToXemics(4.768 / SENSE_RES);
    uint32_t DeltaDF = BQ34Z100_1_floatToXemics(5677445 / SENSE_RES);
    BQ34Z100_1_writeFlash(bq, 0, GainDF, 4);
    BQ34Z100_1_writeFlash(bq, 4, DeltaDF, 4);
    printf("newGain = %f, GainDF = 0x%" PRIx32 "\n",
           SENSE_RES, GainDF);
    BQ34Z100_1_updateChecksum(bq);
    delay(300);
}

uint16_t BQ34Z100_1_readDeviceType(BQ34Z100_1* bq) {
    return BQ34Z100_1_readControlCommand(bq, DEVICE_TYPE);
}

uint16_t BQ34Z100_1_readFWVersion(BQ34Z100_1* bq) {
    return BQ34Z100_1_readControlCommand(bq, FW_VERSION);
}

uint16_t BQ34Z100_1_readHWVersion(BQ34Z100_1* bq) {
    return BQ34Z100_1_readControlCommand(bq, HW_VERSION);
}


float BQ34Z100_1_xemicsToFloat(uint32_t xemics) {
    bool bIsPositive = false;
    float fExponent, fResult;
    uint8_t vMSByte = (uint8_t)(xemics >> 24);
    uint8_t vMidHiByte = (uint8_t)(xemics >> 16);
    uint8_t vMidLoByte = (uint8_t)(xemics >> 8);
    uint8_t vLSByte = (uint8_t)xemics;

    if ((vMidHiByte & 128) == 0) {
        bIsPositive = true;
    }

    fExponent = pow(2, (vMSByte - 128));

    vMidHiByte = (uint8_t)(vMidHiByte | 128);

    fResult = (vMidHiByte) * 65536;

    fResult = fResult + (vMidLoByte * 256);

    fResult = fResult + vLSByte;

    fResult = fResult * pow(2, -24);

    fResult = fResult * fExponent;

    if (bIsPositive)
        return fResult;
    else
        return -fResult;
}
uint8_t BQ34Z100_1_getUpdateStatus(BQ34Z100_1* bq)
{
    BQ34Z100_1_changePage(bq, 82, 0);
    BQ34Z100_1_readFlash(bq);
    return flashbytes[4];
}

uint16_t BQ34Z100_1_getFlags(BQ34Z100_1* bq)
{
    uint16_t flags = BQ34Z100_1_read(bq, Flags, 2);
    //Flags_1 result = {flags, flagsB};
    return (flags);
}

uint16_t BQ34Z100_1_getFlagsB(BQ34Z100_1* bq)
{
    uint16_t flagsB = BQ34Z100_1_read(bq, FlagsB, 2);
    return(flagsB);
}

头文件：

#ifndef BQ34Z100_H
#define BQ34Z100_H

#include <stdint.h>
#include <stdlib.h>

typedef enum {
    Control = 0x0,
    StateOfCharge = 0x2,
    MaxError = 0x3,
    RemainingCapacity = 0x4,
    FullChargeCapacity = 0x6,
    Voltage = 0x8,
    AverageCurrent = 0xA,
    Temperature = 0xC,
    Flags = 0xE,
    Current = 0x10,
    FlagsB = 0x12,
    AverageTimeToEmpty = 0x18,
    AverageTimeToFull = 0x1A,
    PassedCharge = 0x1C,
    DoD0Time = 0x1E,
    VoltScale = 0x20,
    CurrScale = 0x21,
    EnergyScale = 0x22,
    AvailableEnergy = 0x24,
    AveragePower = 0x26,
    SerialNumber = 0x28,
    InternalTemperature = 0x2A,
    CycleCount = 0x2C,
    StateOfHealth = 0x2E,
    ChargeVoltage = 0x30,
    ChargeCurrent = 0x32,
    DataFlashClass = 0x3E,
    DataFlashBlock = 0x3F,
    BlockData = 0x40,
    BlockDataCheckSum = 0x60,
    BlockDataControl = 0x61,
    GridNumber = 0x62,
    LearnedStatus = 0x63,
    DoDatEOC = 0x64,
    QStart = 0x66,
    TrueRC = 0x68,
    TrueFCC = 0x6A,
    StateTime = 0x6C,
    QMaxPassedQ = 0x6E,
    QmaxDOD0 = 0x72,
    QmaxTime = 0x74,
    DOD0 = 0x70,

} Command;

typedef enum {
    CONTROL_STATUS = 0x0,
    DEVICE_TYPE = 0x1,
    FW_VERSION = 0x02,
    HW_VERSION = 0x03,
    RESET_DATA = 0x5,
    PREV_MACWRITE = 0x7,
    CHEM_ID = 0x8,
    BOARD_OFFSET = 0x9,
    CC_OFFSET = 0xA,
    CC_OFFSET_SAVE = 0xB,
    DF_VERSION = 0xC,
    SET_FULLSLEEP = 0x10,
    STATIC_CHEM_CHECKSUM = 0x17,
    SEALED = 0x20,
    IT_ENABLE = 0x21,
    CAL_ENABLE = 0x2D,
    RESET = 0x41,
    EXIT_CAL = 0x80,
    ENTER_CAL = 0x81,
    OFFSET_CAL = 0x82,
    UNSEAL_KEY1 = 0x0414,
    UNSEAL_KEY2 = 0x3672
} Control_2;


// Define BQ34Z100 structure
typedef struct {
#define GAUGE_ADDRESS 0xAA

#define DESIGNCAP 1400
#define DESIGNENERGY 5180
#define CELLCOUNT 0x04
#define LEDCONFIG 0x4b
#define VOLTSEL 1
#define ZEROCHARGEVOLT 3375
#define FLASH_UPDATE_OK_VOLT 2800
#define QMAX0 1400


#define VOLTAGEGAIN 17818
#define LOADSELECT 0x01
#define LOADMODE 0x00

#define RESETVOLTAGE 22200 

#define SENSE_RES 15.0f 

#define USE_EXTERNAL_THERMISTOR 0 
                                    // Other member variables...
} BQ34Z100;

// Function to create a new instance of BQ34Z100
// Function prototypes

//BQ34Z100* BQ34Z100_create();
//void BQ34Z100_destroy(BQ34Z100* bq34z100);


uint32_t BQ34Z100_1_read(BQ34Z100* bq, Command command, const uint8_t length);
void BQ34Z100_1_write(BQ34Z100* bq, Command command, const uint8_t cmd);
void BQ34Z100_1_sendControlCommand(BQ34Z100* bq, Control_2 control);
uint16_t BQ34Z100_1_readControlCommand(BQ34Z100* bq, Control_2 control);
void BQ34Z100_write2(BQ34Z100* bq, Command command, const uint8_t cmd1, const uint8_t cmd2);

void BQ34Z100_1_enableCal(BQ34Z100* bq);
void BQ34Z100_1_enterCal(BQ34Z100* bq);
void BQ34Z100_1_exitCal(BQ34Z100* bq);
void BQ34Z100_1_ITEnable(BQ34Z100* bq);


uint16_t getATTE(BQ34Z100* bq);
uint16_t getATTF(BQ34Z100* bq);
uint8_t getVoltScale(BQ34Z100* bq);
uint8_t getCurrScale(BQ34Z100* bq);
uint8_t getEnergyScale(BQ34Z100* bq);
uint16_t getAvailableEnergy(BQ34Z100* bq);
uint16_t getAvgPower(BQ34Z100* bq);
uint16_t getChargeVoltage(BQ34Z100* bq);
uint16_t getChargeCurrent(BQ34Z100* bq);
uint16_t getGridNumber(BQ34Z100* bq);
uint8_t BQ34Z100_1_getFull(BQ34Z100* bq);
uint8_t getLearnedStatus(BQ34Z100* bq);
uint8_t getDoDatEOC(BQ34Z100* bq);
uint8_t getQstart(BQ34Z100* bq);
uint16_t getTrueRC(BQ34Z100* bq);
uint16_t getTrueFCC(BQ34Z100* bq);
uint16_t getStateTime(BQ34Z100* bq);
uint16_t getDOD0(BQ34Z100* bq);
uint16_t getQmaxPassedQ(BQ34Z100* bq);
uint16_t getQmaxDOD0(BQ34Z100* bq);
uint16_t getQmaxTime(BQ34Z100* bq);
uint16_t getAvgCurrent(BQ34Z100* bq);
uint16_t getCC(BQ34Z100* bq);
uint16_t BQ34Z100_1_getStatus(BQ34Z100* bq);
uint16_t BQ34Z100_1_getChemID(BQ34Z100* bq);
uint16_t BQ34Z100_1_getStateOfHealth(BQ34Z100* bq);
uint8_t BQ34Z100_1_getSOC(BQ34Z100* bq);
uint16_t BQ34Z100_1_getError(BQ34Z100* bq);
uint16_t BQ34Z100_1_getRemaining(BQ34Z100* bq);
uint16_t BQ34Z100_1_getVoltage(BQ34Z100* bq);
int16_t BQ34Z100_1_getCurrent(BQ34Z100* bq);
double BQ34Z100_1_getTemperature(BQ34Z100* bq);
double BQ34Z100_1_getIntTemperature(BQ34Z100*bq);
int BQ34Z100_1_getSerial(BQ34Z100* bq);
void BQ34Z100_1_reset(BQ34Z100* bq);
void BQ34Z100_1_unseal(BQ34Z100* bq);
void BQ34Z100_1_seal(BQ34Z100* bq);
void BQ34Z100_1_changePage(BQ34Z100* bq, char subclass, uint16_t offset);
uint8_t BQ34Z100_1_calcChecksum();
void BQ34Z100_1_updateChecksum(BQ34Z100* bq);
void BQ34Z100_1_readFlash(BQ34Z100* bq);
void BQ34Z100_1_writeFlash(BQ34Z100* bq, uint8_t index, uint32_t value, int len);
uint8_t* BQ34Z100_1_getFlashBytes(BQ34Z100* bq);
void BQ34Z100_1_changePage48(BQ34Z100* bq);
void BQ34Z100_1_changePage64(BQ34Z100* bq);
void BQ34Z100_1_changePage80(BQ34Z100* bq);
void BQ34Z100_1_changePage82(BQ34Z100* bq);
uint16_t BQ34Z100_1_calibrateVoltage(BQ34Z100* bq, uint16_t currentVoltage);
void BQ34Z100_1_resetVoltageDivider(BQ34Z100* bq);
uint32_t BQ34Z100_1_floatToXemics(float value);
void BQ34Z100_1_calibrateShunt(BQ34Z100* bq, int16_t calCurrent);
void BQ34Z100_1_setSenseResistor(BQ34Z100* bq);
uint16_t BQ34Z100_1_readDeviceType(BQ34Z100* bq);
uint16_t BQ34Z100_1_readFWVersion(BQ34Z100* bq);
uint16_t BQ34Z100_1_readHWVersion(BQ34Z100* bq);
float BQ34Z100_1_xemicsToFloat(uint32_t xemics);
uint8_t BQ34Z100_1_getUpdateStatus(BQ34Z100* bq);
uint16_t BQ34Z100_1_getFlags(BQ34Z100* bq);
uint16_t BQ34Z100_1_getFlagsB(BQ34Z100* bq);



#endif

错误：

控制台：

****项目 bq34z100r2的配置调试构建****

"C：\\ti\\ccs1220\\ccs\\utils\\bin\\gmake"-k -j 8 all -O

建立目标："bq34z100r2.out"
调用：MSP430链接器
"c：/ti/ccs1220/ccs/tools/compiler/ti-cgt-msp430_21.6.1.LTS/bin/cl430 /ti/ccs1220/ccs/ccs_base/msp430/include /ti/ccs1220/ccs/tools/compiler/ti-cgt-msp430_21.6.1.LTS/lib -vmspx --data_model=restricted --near_data=none --use_hw_mpy=F5 --advice：power="all"--advice：hw_config="all"--define=__MSP430FR2155__/ti/ccs1220/ccs/ccs_base/msp430/lib/FR2xx /ti/ccs1220/ccs/tools/compiler/ti-cgt-msp430_21.6.1.LTS/include

警告#10229-D：输出段".data"指加载符号"_nop"、因此无法压缩；压缩"lzss"被忽略

第一个引用的未定义
文件中的符号
---------------- ----------------
备注#10371-D：(ULP 1.1)检测到未使用低功耗模式状态更改指令
BQ34Z100_1_getStatus (BQ34Z100 *)./main.obj
备注#10372-D：(ULP 4.1)在此项目中检测到未初始化的端口6。建议初始化所有未使用的端口以消除未使用引脚上的浪费电流消耗。
备注#10372-D：(ULP 4.1)在此项目中检测到未初始化的端口 A。建议初始化所有未使用的端口以消除未使用引脚上的浪费电流消耗。
备注#10372-D：(ULP 4.1)在此项目中检测到未初始化的端口 B。建议初始化所有未使用的端口以消除未使用引脚上的浪费电流消耗。
备注#10372-D：(ULP 4.1)在此项目中检测到未初始化的端口 C。建议初始化所有未使用的端口以消除未使用引脚上的浪费电流消耗。
备注#10422-D：(ULP 6.2)检测到具有可用32位硬件乘法器的器件的使用、同时不使用 MSPMATHLIB 库(libmath.a)。建议使用 MSPMATHLIB 库(libmath.a)以提高性能。

>>编译失败
Makefile：137：目标"bq34z100r2.out"的配方失败

错误#10234-D：未解析的符号仍存在
错误#10010：链接期间遇到错误；未生成"bq34z100r2.out"
gmake[1]：***[bq34z100r2.out]错误1
Makefile：133：目标"全部"的食谱失败
gmake：***[全部]错误2

****构建完成****

请帮我解决这些问题。

提前感谢！

0 admin 3 个月前

TI__Guru**** 1135610 points

请注意，本文内容源自机器翻译，可能存在语法或其它翻译错误，仅供参考。如需获取准确内容，请参阅链接中的英语原文或自行翻译。

头文件显示 BQ34Z100_1_getStatus ()需要"BQ34Z100 *"、但定义显示它需要"BQ34Z100_1 *"、其中后者是源文件的私有信息。

我想知道在某个地方是否存在不匹配的源代码。

编译 BQ34Z100.c 时、您是否从编译器收到任何消息？

0 admin 3 个月前

TI__Guru**** 1135610 points

请注意，本文内容源自机器翻译，可能存在语法或其它翻译错误，仅供参考。如需获取准确内容，请参阅链接中的英语原文或自行翻译。

编译 BQ34Z100.c 时、您是否从编译器收到任何消息？

这些是我在编译 BQ34Z100.c 时收到的消息

0 admin 3 个月前

TI__Guru**** 1135610 points

请注意，本文内容源自机器翻译，可能存在语法或其它翻译错误，仅供参考。如需获取准确内容，请参阅链接中的英语原文或自行翻译。

我想源文件名为 BQ34Z100.cpp、它允许您编译一组(第二组)函数、这些函数的名称与标头中的相同、但签名不同。但由于它们需要 BQ34Z100_1结构、您无法调用它们、因为 BQ34Z100_1结构在.cpp 文件外部是不可见的。

我仍然不确定我是否知道这应该如何组合在一起。对如何使用此代码有什么建议吗？我只能找到基于 Arduino 的库。

0 admin 3 个月前

TI__Guru**** 1135610 points

请注意，本文内容源自机器翻译，可能存在语法或其它翻译错误，仅供参考。如需获取准确内容，请参阅链接中的英语原文或自行翻译。

我的原始文件是.cpp 文件、稍后我将其转换为.c 文件。使用与.cpp 文件中的参数相同的参数创建另一个结构体是否可以正常工作？

或者有没有其他建议我如何解决这个问题？

0 admin 3 个月前

TI__Guru**** 1135610 points

请注意，本文内容源自机器翻译，可能存在语法或其它翻译错误，仅供参考。如需获取准确内容，请参阅链接中的英语原文或自行翻译。

一种方法是将 BQ34Z100_1结构声明(以及 I2C 结构)移动到头文件中，这样它是可见的，并且具有主要用途。

您还必须更改所有函数原型[您可以从 BQ34Z100_1_getStatus ()作为实验开始]、以匹配.cpp 文件中的函数原型。

也可以改用其他方法、将所有内容更改为使用 BQ34Z100结构、但这可能需要键入更多内容。

0 admin 3 个月前

TI__Guru**** 1135610 points

请注意，本文内容源自机器翻译，可能存在语法或其它翻译错误，仅供参考。如需获取准确内容，请参阅链接中的英语原文或自行翻译。

感谢您的建议。它现在正在工作。

我将在几天内对其进行测试、如果出现任何问题、我们会及时回复您。

再次感谢您！

MSP 低功耗微控制器（参考译文帖）

MSP 低功耗微控制器（参考译文帖）(Read Only)

[参考译文] MSP430FR2155：ERROR：[E0300]以下符号未定义：