CCS/MSP430i2040: EMDC I2C communication with EVM430-i2040S

Hi Anuradha,

For related questions about this topic, please reply to this thread. Over the past few days, I've merged several new threads from you into this thread because it's related to the same topic. In the future, please click the "Reply" button in this thread to reply here. If you post a new thread each day about the same topic, I would assume that our community members would be less likely to chime in since they know you'll move on to another thread the next day. While we appreciate that you're using E2E, please keep these guidelines in mind.

Anuradha Bulakh said:

In above thread,

byte command_frame[] = {0x55, 0xAA, 0x06, 0x04, 0x01, 0x01, 0x01, 0x07, 0x00};  this string is used to get response from MSP430i2040 EVM using I2C protocol.

Can you please explain how this string formed?

You can find more information about the EMDC protocol in the Communication Protocol Spec section of the EMDC Technology Guide (v1.30). To give you a quick overview:

• 0x55 = Sync byte
• 0xAA = Blank byte
• 0x06 = Length byte
• 0x04 = ID byte
• 0x01 = Command byte
• 0x01 = Read/write byte
• 0x01 = Payload byte
• 0x07 = Checksum LSB
• 0x00 = Checksum MSB

Regards,

James

Hi Anuradha,

Anuradha Bulakh said:

As I have worked on I2C protocol its very simple like,

I'm glad to hear that.

Anuradha Bulakh said:

We have already used MSP430 Metering solution on UART with some modification in protocol as per application.

And eager to use same on I2C for another application. Since protocol is not documented properly we are finding difficulties (I know EMDC generated code mainly for UART, as you are motivating user to modify code for I2C ,protocol should be explained in details).

Our goal with EMDC was to remove the complexity behind users developing metering code. It was not to support all communication protocols, but to allow users without metering experience to focus more on configuring and adapting the communication protocol. I agree that this may be challenging, but I assure you that it's much easier than developing the metering code. More importantly, we hear and appreciate your feedback with our tools. I2C communication does seem to be requested often for EMDC, so we've added that as a potential feature in an upcoming release.

Anuradha Bulakh said:

Please send me protocol string to read Vrms including START, SLAVE Address, R/W, Packet, STOP  (which I have already asked in my last reply).

After performing the changes to the code as described in the thread linked above, I was able to capture the following communication with my logic analyzer. I used an Ardvark I2C tool as the I2C host.

Under the Analyzer settings in the logic analyzer GUI, I had to change the address display to "7-bit, address bits only" for the slave address to be shown correctly. As you can see, the slave address (0x0A) with Write bit set is sent first as we've discussed earlier. Then, the sync byte (0x55). Then, the blank byte (0xAA). Then, the length byte (0x07) - remember the length is the size of payload bytes + 2-byte checksum. Then, the EMDC ID byte (0x04). Then, our command byte (0x80). Then, two bytes (0x00, 0x00) as the payload. The last two bytes (0x84, 0x00) are the checksum. This is the command from the host.

Now, the response from the slave is defined by my function in 'emDCCommandHandlers.c'.

void CommandHandler_transmitVRMS(Packet_t *packet,
                                 uint8_t phaseID,
                                 uint8_t *vrms)
{
    packet->length = 8;
    packet->payload[0] = COMMAND_HANDLER_EM_GUI_ID_BYTE;
    packet->payload[1] = COMMAND_HANDLER_VRMS_ID;
    packet->payload[2] = COMMAND_HANDLER_WRITE_CMD;
    packet->payload[3] = phaseID;
    packet->payload[4] = vrms[0];
    packet->payload[5] = vrms[1];
    packet->payload[6] = vrms[2];
    packet->payload[7] = vrms[3];

    Comm_writePacket(packet);
}

Here's the communication from the slave to host. First, the slave address (0x0A) is sent with Read bit set. Next, the length byte (0x0A) is sent. Then, the EMDC GUI ID byte (0x04). Then, the Command byte (0x80). Then, the write command (0x01). Then, the phase ID (0x01) which is important for polyphase systems. Then, the four payload bytes (0x00, 0x00, 0x00, 0x00) for VRMS which are zero because my board is not connected to AC. The last two bytes are the checksum bytes (0x86, 0x00). As you can see, this matches my function for this Command byte in my code. Feel free to modify this function since it's just an example for how to receive VRMS values. This can also be applied to all the other supported results.

Here are my other example functions for the other results.

void CommandHandler_transmitIRMS(Packet_t *packet,
                                 uint8_t phaseID,
                                 uint8_t *irms)
{
    packet->length = 8;
    packet->payload[0] = COMMAND_HANDLER_EM_GUI_ID_BYTE;
    packet->payload[1] = COMMAND_HANDLER_IRMS_ID;
    packet->payload[2] = COMMAND_HANDLER_WRITE_CMD;
    packet->payload[3] = phaseID;
    packet->payload[4] = irms[0];
    packet->payload[5] = irms[1];
    packet->payload[6] = irms[2];
    packet->payload[7] = irms[3];

    Comm_writePacket(packet);
}

void CommandHandler_transmitVPeak(Packet_t *packet,
                                 uint8_t phaseID,
                                 uint8_t *vPeak)
{
    packet->length = 8;
    packet->payload[0] = COMMAND_HANDLER_EM_GUI_ID_BYTE;
    packet->payload[1] = COMMAND_HANDLER_VPEAK_ID;
    packet->payload[2] = COMMAND_HANDLER_WRITE_CMD;
    packet->payload[3] = phaseID;
    packet->payload[4] = vPeak[0];
    packet->payload[5] = vPeak[1];
    packet->payload[6] = vPeak[2];
    packet->payload[7] = vPeak[3];

    Comm_writePacket(packet);
}

void CommandHandler_transmitIPeak(Packet_t *packet,
                                 uint8_t phaseID,
                                 uint8_t *iPeak)
{
    packet->length = 8;
    packet->payload[0] = COMMAND_HANDLER_EM_GUI_ID_BYTE;
    packet->payload[1] = COMMAND_HANDLER_IPEAK_ID;
    packet->payload[2] = COMMAND_HANDLER_WRITE_CMD;
    packet->payload[3] = phaseID;
    packet->payload[4] = iPeak[0];
    packet->payload[5] = iPeak[1];
    packet->payload[6] = iPeak[2];
    packet->payload[7] = iPeak[3];

    Comm_writePacket(packet);
}

void CommandHandler_transmitPowerFactor(Packet_t *packet,
                                        uint8_t phaseID,
                                        uint8_t *pFactor)
{
    packet->length = 8;
    packet->payload[0] = COMMAND_HANDLER_EM_GUI_ID_BYTE;
    packet->payload[1] = COMMAND_HANDLER_POWER_FACTOR_ID;
    packet->payload[2] = COMMAND_HANDLER_WRITE_CMD;
    packet->payload[3] = phaseID;
    packet->payload[4] = pFactor[0];
    packet->payload[5] = pFactor[1];
    packet->payload[6] = pFactor[2];
    packet->payload[7] = pFactor[3];

    Comm_writePacket(packet);
}

void CommandHandler_transmitFrequency(Packet_t *packet,
                                      uint8_t phaseID,
                                      uint8_t *frequency)
{
    packet->length = 6;
    packet->payload[0] = COMMAND_HANDLER_EM_GUI_ID_BYTE;
    packet->payload[1] = COMMAND_HANDLER_FREQUENCY_ID;
    packet->payload[2] = COMMAND_HANDLER_WRITE_CMD;
    packet->payload[3] = phaseID;
    packet->payload[4] = frequency[0];
    packet->payload[5] = frequency[1];

    Comm_writePacket(packet);
}

void CommandHandler_transmitActivePower(Packet_t *packet,
                                        uint8_t phaseID,
                                        uint8_t *actPower)
{
    packet->length = 12;
    packet->payload[0] = COMMAND_HANDLER_EM_GUI_ID_BYTE;
    packet->payload[1] = COMMAND_HANDLER_ACTIVE_POWER_ID;
    packet->payload[2] = COMMAND_HANDLER_WRITE_CMD;
    packet->payload[3] = phaseID;
    packet->payload[4] = actPower[0];
    packet->payload[5] = actPower[1];
    packet->payload[6] = actPower[2];
    packet->payload[7] = actPower[3];
    packet->payload[8] = actPower[4];
    packet->payload[9] = actPower[5];
    packet->payload[10] = actPower[6];
    packet->payload[11] = actPower[7];

    Comm_writePacket(packet);
}

void CommandHandler_transmitReactivePower(Packet_t *packet,
                                         uint8_t phaseID,
                                         uint8_t *reactPower)
{
    packet->length = 12;
    packet->payload[0] = COMMAND_HANDLER_EM_GUI_ID_BYTE;
    packet->payload[1] = COMMAND_HANDLER_REACTIVE_POWER_ID;
    packet->payload[2] = COMMAND_HANDLER_WRITE_CMD;
    packet->payload[3] = phaseID;
    packet->payload[4] = reactPower[0];
    packet->payload[5] = reactPower[1];
    packet->payload[6] = reactPower[2];
    packet->payload[7] = reactPower[3];
    packet->payload[8] = reactPower[4];
    packet->payload[9] = reactPower[5];
    packet->payload[10] = reactPower[6];
    packet->payload[11] = reactPower[7];

    Comm_writePacket(packet);
}

void CommandHandler_transmitApparentPower(Packet_t *packet,
                                          uint8_t phaseID,
                                          uint8_t *appPower)
{
    packet->length = 12;
    packet->payload[0] = COMMAND_HANDLER_EM_GUI_ID_BYTE;
    packet->payload[1] = COMMAND_HANDLER_APPARENT_POWER_ID;
    packet->payload[2] = COMMAND_HANDLER_WRITE_CMD;
    packet->payload[3] = phaseID;
    packet->payload[4] = appPower[0];
    packet->payload[5] = appPower[1];
    packet->payload[6] = appPower[2];
    packet->payload[7] = appPower[3];
    packet->payload[8] = appPower[4];
    packet->payload[9] = appPower[5];
    packet->payload[10] = appPower[6];
    packet->payload[11] = appPower[7];

    Comm_writePacket(packet);
}

void CommandHandler_transmitActiveEnergy(Packet_t *packet,
                                         uint8_t phaseID,
                                         uint8_t *actEnergy)
{
    packet->length = 12;
    packet->payload[0] = COMMAND_HANDLER_EM_GUI_ID_BYTE;
    packet->payload[1] = COMMAND_HANDLER_ACTIVE_ENERGY_ID;
    packet->payload[2] = COMMAND_HANDLER_WRITE_CMD;
    packet->payload[3] = phaseID;
    packet->payload[4] = actEnergy[0];
    packet->payload[5] = actEnergy[1];
    packet->payload[6] = actEnergy[2];
    packet->payload[7] = actEnergy[3];
    packet->payload[8] = actEnergy[4];
    packet->payload[9] = actEnergy[5];
    packet->payload[10] = actEnergy[6];
    packet->payload[11] = actEnergy[7];

    Comm_writePacket(packet);
}

void CommandHandler_transmitReactiveEnergy(Packet_t *packet,
                                          uint8_t phaseID,
                                          uint8_t *reactEnergy)
{
    packet->length = 12;
    packet->payload[0] = COMMAND_HANDLER_EM_GUI_ID_BYTE;
    packet->payload[1] = COMMAND_HANDLER_REACTIVE_ENERGY_ID;
    packet->payload[2] = COMMAND_HANDLER_WRITE_CMD;
    packet->payload[3] = phaseID;
    packet->payload[4] = reactEnergy[0];
    packet->payload[5] = reactEnergy[1];
    packet->payload[6] = reactEnergy[2];
    packet->payload[7] = reactEnergy[3];
    packet->payload[8] = reactEnergy[4];
    packet->payload[9] = reactEnergy[5];
    packet->payload[10] = reactEnergy[6];
    packet->payload[11] = reactEnergy[7];

    Comm_writePacket(packet);
}

void CommandHandler_transmitApparentEnergy(Packet_t *packet,
                                           uint8_t phaseID,
                                           uint8_t *appEnergy)
{
    packet->length = 12;
    packet->payload[0] = COMMAND_HANDLER_EM_GUI_ID_BYTE;
    packet->payload[1] = COMMAND_HANDLER_APPARENT_ENERGY_ID;
    packet->payload[2] = COMMAND_HANDLER_WRITE_CMD;
    packet->payload[3] = phaseID;
    packet->payload[4] = appEnergy[0];
    packet->payload[5] = appEnergy[1];
    packet->payload[6] = appEnergy[2];
    packet->payload[7] = appEnergy[3];
    packet->payload[8] = appEnergy[4];
    packet->payload[9] = appEnergy[5];
    packet->payload[10] = appEnergy[6];
    packet->payload[11] = appEnergy[7];

    Comm_writePacket(packet);
}

I hope this is helpful.

Regards,

James

Hello Anuradha,

Was my last post helpful? Were you able to get your communication working?

Regards,

James