In the previous blog the issue of having too many options when choosing an IoT solution was introduced. As a way to judge how easy it it is to select a solution, a project was proposed that could be implemented using different hardware and software. Once these projects are implemented on these platforms a comparison will be done to determine, from a prototyping perspective, what is an easy platform to use.
Power consumption at home and in the office is becoming a more conscious issue. The concept of leaving appliances to use whatever power they need at all hours of the day and night is no longer socially acceptable. Unfortunately most people do not know what power they are consuming or when they consume it. For these reasons this project aims to monitor power consumption of a device in either a residential or commercial setting.
Hardware & Setup
The hardware used to prototype this project consists of three components. The code that controls the various components is run on the MSP430F5529. The power consumption data is acquired using a MCP39F511 power monitoring IC from Microchip. Lastly the data is uploaded to the cloud via a CC3100 SimpleLink WiFi boosterpack that provides WiFi connectivity.
This initial implementation of the project was decided to be implemented on an MSP430 launchpad and programmed using Energia. The simplicity of both the hardware and software was also a factor in this selection. Another factor was the ability to easily move the prototype to a production model. The MSP430FR5969 was initially selected for this project because of the desire for a platform with a minimal number prebuilt examples. Unfortunately due to connectivity issues that were not immediately resolved the MSP40F5529 was selected. Subsequently it has been observed that it may be the first CC3100 used that has an issue and not the MSP430FR5969. The second choice of the MSP430F5529 was based on the availability of all 40 header pins in the boosterpack standard as well as previous experience with this board.
MSP430F5529 Launchpad with CC3100 Boosterpack Mounted Underneath and UART Connections Wired to the Top Headers
The MCP39F511 was selected as an easy to use power monitoring solution. The MCP39F511 records 16 different values relevant to power consumption. These values include the usual voltage, current, active reactive and apparent power. In addition to these there is also power factor and imported and exported power counters allowing for both power consumed and generated to be accounted for. The MCP39F511 communicates via UART and allows for most of its functionality to be customized to fit your specific application. With a configurable power range as well as minimum accumulated power consumption, this solution is capable of covering a large range of applications. In this project the MCP39F511 is contained in the ADM00667 evaluation kit The ADM00667 provides isolation between the high and low sides ensuring any control electronics do not get damaged There are also headers for easy connection to an external UART device to simplify communications with an external controller
MCP39F511 in the ADM00667 Evaluation Lit
In order to upload the data to the selected cloud platform a CC3100 boosterpack is mounted on the MSP430. The CC3100 is WiFi certified and contains a TCP/IP stack as well as various other protocols. This makes the CC3100 a simple solution for connecting to the internet and uploading data to any desired cloud platform. Texas Instruments provides an API for communicating with the CC3100 in C allowing for easy progression to a large scale manufacturable device.
CC3100 Simplelink WiFi BoosterPack
Since the CC3100 is a boosterpack that mounts directly on the MSP430F5529 the only wired connections that need to be made are to the MCP39F511 The UART connections provided through the 40-pin headers are used for this purpose Also because the ADM00667 provides isolation between the high and the low voltage sides 5V needs to be provided to the low side to power the optocouplers For this an additional connection could be made from the MSP430F529 as long as the CC3100 is mounted under the MSP430F5529 Once these connections are made the hardware is setup and ready to be used
The software for this project was written using C/C++ in the Energia IDE. The simplicity as well as abundance of libraries allowed for a prototype to be up and running in a very short period of time. The code has two main parts, the initialization code found in the setup function and a 6 state, state machine in the loop function. The initialization code sets up a WiFi object, sets the UART baud rate to 115200 bps and initializes two outputs for indicator LEDs. The WiFi connection is used to communicate to the M2X cloud platform. The MSP430 communicates to both the MCP39F511 and the connected PC via UART. This is used for both retrieving data from the MCP39F511 as well as debugging software and communication issues via the PC connection.
Communicating with the MCP39F511
The communication protocol for the MCP39F511 device is based on the Simple Sensor Interface (SSI) protocol. This protocol is used for point-to-point communication from a single-host MCU to a single-slave MCP39F511. It is important to note that the maximum number of bytes in either a receive or transmit frame is 35.
The SSI protocol requires that each message start with a header (0xA5), the number of bytes in the frame, a command byte and a valid checksum.
MCP39F511 Packet Format
Every frame that is sent starts with the same header or start byte, 0xA5. The number of bytes in the frame includes the payload as well as the header and checksum bytes. The checksum is generated by adding all bytes in the frame and taking to modulo of 256. There are 10 commands that can be sent to the MCP39F511 that allow for reading and writing to registers, setting and clearing the EEPROM as well as calibrating various functions in the MCP39F511. An issue to be aware of with the MCP39F511 is that although the default baud rate is 115200 bps, the MCP39F511 needs a few microseconds (~300) between every grouping of two bytes.
The MCP39F511 has three device responses. The first is an ACK, this signifies that the frame was received correctly and the commands were executed correctly. The second response is a NAK, this is used to let the host controller know that the frame was received but was either not understood or could not be executed. Lastly there is a CSFAIL response that lets the host know the frame may be correct but the checksum is not and the frame needs to be resent.
The code for this project was started from two other base projects and then rehashed to provide the functionality needed for this project.
The first code base used was the MultiSerial.ino example from Energia. This allowed for basic communication between two different serial devices. In this case the MSP430F5520 would request data from the MCP39F511 via UART and then pass it to a host PC via the UART backchannel. The second code base used was the LaunchPasWiFiPost.ino example from M2X bundled with Energia. This postes a value to the M2X cloud based on the value read from the onboard buttons.
The two projects were then merged once they were determined to be working satisfactory. That is that the MCP39F511 could reliably be polled for data and the data correctly outputted to the PC. Since the data is received LSB first, the bytes first need to swapped to correctly interpret the data. Also the MCP39F511 data sheet does not clearly explain the conversion factors between the measured data and the received data. In order to achieve the correct results trial and error along with the provided “Power Monitoring Utility” were used.
For the M2X demo, the major issue was trying to get multiple data points uploaded simultaneously without having a real time clock. While there apparently is a function to retrieve the server time from the M2X server, Energia had issues finding the correct data types in the M2X library. There is also mention of a single value upload for multiple data streams but again the functionality could not be found in the Energia library. Eventually multiple single value uploads were used decreasing the reliable polling rate for the MCP39F511.
The system uses a 6 state, state machine of which the last state is a fail case should the WiFi/internet connection be dropped. This case was added after experiencing the issue with the damaged CC3100 in the hope that resetting the connection would resolve the issue. Ultimately this did not resolve the issue with this particular boosterpack but was left in as a preventative measure for other fully functional CC3100 boosterpacks.
The first state is the only state where data is requested from the MCP39F511. In this state the MSP430 sets the address pointer for the MCP39F511 to 0x00 and then requests the next 28 bytes of data. This allows the system to retrieve the values for voltage RMS, line frequency, power factor, current RMS as well as active, reactive and apparent power. Since this request is repeated every 10 seconds an array is used to store this command sequence. This state also sets the green LED high for the duration of requesting data from the MCP39F511 as a visual indicator that the system is working.
The second state looks for an ACK from the MCP39F511. If an ACK is received the state is incremented and the state machine can progress to receiving the number of bytes in the current frame. If there is an issue the MCP39F511 sends back other device responses to indicate the possible issues. The first device response is a NAK, this indicates that the frame was received but the command could not be executed or could not be understood. It is also possible that there was an issue in the command byte. The second possible device response is CSFAIL. In this case the frame again was received but the checksum was incorrect. If either a NAK or CSFAIL are received the state is decremented so that the command can be resent.
The next state (3rd) receives the number of bytes in the frame. This is used in the next state to know how many more bytes need to be received.
The 4th state receives the remaining bytes in the frame. At every iteration through this state the number of bytes received is compared to the number of bytes to be received. Once these numbers are equal the state is incremented. In the current implementation of the software there is no time out or other check to ensure an issue between the MSP430 and the MCP39F511 does not cause the system to hang. There is however a precaution in place to be sure any unread data does not cause ongoing issues by including a Serial.flush at the start of the first state.
The last continually used state is the 5th state which process and sends the retrieved data to the M2X cloud platform. In order to send the data correctly to the cloud the data first needs to be organized correctly. The MCP9F511 returns all data LSB first, therefore the order of the returned bytes needs to be swapped. Before the data can be processed the validity of the received data needs to be checked. To accomplish this the checksum is first calculated and checked. If the received checksum and the locally calculated checksum match then the data is processed. If the checksums do not match, the data is discarded and a new request is issued.
System State Machine with Six States
The code and discoveries in this project were done in a way that hopefully they could easily be reproduced. To better aid in this the full code revision has been uploaded to github. The Git repository for this project can be found here and can be cloned by anyone wanting to add, change or use the code for their own purposes. It should be noted there is a need to add your own WiFi and M2X credentials in the associated WiFi_Credentials.h file.
The next steps for this project would be to improve the timing resolution. This would need either the addition of a RTC or a connection to a time server. The next major step is to see how this compares to the MangOH Green board to get a better sense of of the comparable capabilities and prototyping time frames.
Real Time Power Consumption in Watts
Personal blog here:
More pictures here:
Upcoming reviews and info here: