Electricity Meter (EM) Reference Design Based on the MAXQ3120 Microcontroller

There are two options for customizing this program. You can choose to change the values ​​assigned to disp.Item and the order in which they are selected in the program, or you can choose to replace the program entirely. The latter option is probably better. Obviously, the item selection structure is more flexible if a separate bit is assigned to each item that may be displayed, or a list index is assigned to the displayable items. The above structure was chosen because it requires the least amount of RAM space.

Adding Registers

DL/T 645 specifies a large number of registers that are used to control various aspects of the meter's operation. Each register is specified by a 16-bit register number. In the reference design, many registers have been added to control various aspects of the meter's operation; descriptions of these registers are given in the code. This discussion provides the necessary information to obtain more information from the meter or to control new meter operating features by extending the register map.

How the Register Manager Works

All tasks cannot suspend normal task wheel operation, and the Register Manager task has a great deal of difficulty in following this principle. This is because the Register Manager is the only task that can read/write the EEPROM, and EEPROM write operations take a (relatively) long time - several milliseconds. Because processor time is provided to the DSP program every 20ms (16.7ms at 60Hz), the register manager cannot allow the system to hang for tens of milliseconds during the EEPROM write cycle.

An obvious way to solve the EEPROM write time problem is to set the I2C program to interrupt processing mode. In this way, the register manager can start an EEPROM transfer process and then return to the main function entry main(); each time it is called, the register manager will check the status of the EEPROM subsystem to determine whether the task has been completed. The problem with this solution is that the ADC cycle is so short that the ADC interrupt service routine needs to monopolize the interrupt subsystem. Therefore, some other protection mechanism must be adopted.

The solution is to use a global flag: EEPROMOpPending. When this flag is low, the task wheel is essentially an infinite loop process, repeatedly calling every task in the system. When the flag is high, the task wheel is executed once and returns when it is called, without calling the register manager. Does this help?

When the register manager needs to execute a long function, it starts this function and polls to determine whether it has completed. During polling, the register manager sets EEPROMOpPending high and recursively calls the task round. The following code gives a practical example:

01: uint8 ReadEEPROM(uint16 Address, uint8 Length, uint8 *pData)
02: {
03: int i;
04: g_MessageBoard.EEPROMOpPending = 1;
05: for(i=0; i 06: {
07: if(i＞0)SpinTaskWheel();
08: eeprom_address = Address++;
09: while(eeprom_read_byte())
10: S
pinTaskWheel();
11: *pData++ = eeprom_data;
12: } // for
13: g_MessageBoard.EEPROMOpPending = 0;
14: return 1;
15: }

In line 4 above, the EEPROMOpPending flag is set high. In lines 7 and 10, SpinTaskWheel is called. If the task wheel is called while the EEPROM flag is high, the SpinTaskWheel function runs once and returns without calling the register manager. This allows the rest of the meter to continue operating normally even if the register manager is stalled waiting for the EEPROM to complete an operation.

Which tasks know about these registers?

Only two tasks know the register numbers: the register manager and the message decoder. Of these routines, only the register manager is usually the only one that needs to be modified. The message decoder identifies registers that are relevant to password management and other monitoring functions, and must obtain this information before normal processing rules can be used. Therefore, to build your own registers, you only need to be familiar with the register manager. Three Classes of Registers

Typically, there are three classes of registers: read-only, read-write, and read-write registers with additional functions. An example of a read-only register is B611, RMS Volts, phase A. Writing to this register by the host is not executable; in fact, the meter discards the write data if it receives it. Also, most read-only registers are not in the EEPROM: typically, the results of these registers are calculated online and reported as needed.

An example of a read-write register is C032, Meter Number. Writing a value has no effect on the meter's operation, and the data can be retrieved at any time. Finally, an example of a read-write register with additional functionality is C030, Meter Constant, active. When this register is written, the register manager must update not only the EEPROM, but also the meter constant used by the DSP program.

Which tasks require register information?

The following table lists the tasks that require register information.



Generally, you will consider adding registers that are accessible through the message decoder. You can add registers for display (or other tasks, but as a rule, you will consider registers that are retrieved through the communication port).

Read-Write Registers

First consider the first case, which is storing and reading a read-write register with no additional functionality. To add a register that is stored in the EEPROM, you must add information in two places: the MAXQ3120RD.h file and the ProcessRegisterNumber procedure in the register manager.

The MAXQ3120RD.h file contains a data type named EEPROM_DATA, which is defined by typedef. This definition is not actually instantiated; it is merely a template for defining how data is stored in the EEPROM. Below the EEPROM_DATA definition, two macros are defined that return two values: the offset address of a member in the structure and the number of bytes that the member occupies. The first step in defining a new register is to add members to the structure (preferably at the end) to allocate EEPROM storage space for the register.

The next step is to define the register number. This requires editing the RegParmTable structure defined in the register manager. This table contains each register defined in the meter, sorted by number. Each member consists of:

The register number, a 16-bit unsigned value.

The physical data unit number, which is used to calculate the actual register value. For example, register 9110 requests the total forward reactive power usage for the month. It is the sum of two energy accumulators: the power usage in quadrant 1 and the power usage in quadrant 4. Therefore, the number of physical units is two. The register manager must extract the data from the specified cell (CurrentQuadrant1AccumTariff) and the next cell (CurrentQuadrant4AccumTariff) and sum them to get the required information.

The length of each cell, in bytes.

The type of data stored: INT_REG, indicating that the register contains binary data that is treated as an integer;

BCD_REG, indicating that the register contains BCD data that does not need further conversion before transmission; or MDH_REG, indicating that the register contains date information (month:day:hour).

The offset of the data in the EEPROM (in bytes).

To save processing time, the ProcessRegisterNumber procedure uses a binary search algorithm to find the register address. Therefore, it is very important that the table remains sorted. If the register table becomes out of order, the results are unpredictable.

Once the table is updated, the new register can be read and written through the communication channel. Exactly how the meter handles this information is the subject of the next section.

Reading and Writing Registers with Additional Functionality

There is also an application case where you want a write event to trigger additional functionality. To achieve this effect, the register manager must send a message to the additional task or update the RAM contents involved in performing the additional function. As an example, search for C030 in the register manager and you will find the following code:

switch(Register.Word)
{
case 0xC030: // Meter constant, real
action_value = 0;
for(i=4; i＞1; i--)
{
action_value *= 100;
action_value += (g_CommBuffer.Message[ i] & 0xf) +
(g_CommBuffer.Message[ i] ＞＞ 4) * 10;
}
set_E_pulse(action_value); // this will set E_pulse

break;