Pentametric input unit and computer interface (lower middle)

Instructions for communicating with Pentametric via the serial interface can be found in this document: How to access data via the RS232 port from the PentaMetric battery monitor.

I will post the full source code here after it is finished but here is a preview of the “short read” command:

bool pentametric_short_read(uint8_t a, uint8_t n, uint8_t *msg)
{
    uint8_t crc, i;

    putchar(usart_data_, 0x81);
    putchar(usart_data_, a);
    putchar(usart_data_, n);
    crc = 0x81 + a + n;
    putchar(usart_data_, ~crc);
    crc = 0;
    for(i=0;i<n;i++)
    {
        msg[i] = getchar(usart_data_);
        crc += msg[i];
    }
    crc += getchar(usart_data_);
    if (crc != 0xff)
        return false;
    return true;
}

nRF24LE1 module

I have also made up my mind to order the Pentametric Battery Monitor from Bogart Engineering and use it for current measurement instead of the circuit described below. The Pentametric has a computer interface that can be used to read out all data captured. This means I also need a micro controller with more than one serial port. More on that later.

Surely enough, the radio did not like these conditions. I had to place the receiver in a window facing the tool shed and the transmitter in the door opening on my tool shed to be within range. Luckily I had two other modules with SMA connectors and matching 2.4GHz antennas that I could use. With these modules the radios functioned flawlessly.

Below is a picture of the transmitter (with PCB antenna) in the tool shed. The SunSaver MPPT is on the wall to the left. The box on the wall, in the middle is the Bogart Engineering Trimetric and the big blue box partly in the right of the picture is a Victron Energy Inverter/Charger. On the floor are two SunXtender AGM batteries with the nRFgo evaluation board on top of the battery to the right.

Even if we do not need the full 32 bytes payload length at once, I will use this length from start so I do not need to increase it later. I will also add a packet type to the beginning of each packet such that I can add other packet types later. For example the SunSaver MPPT store 32 days of historical data that can be read out through the Modbus. Maybe I will add this in a future version of the firmware. The figure below shows the suggested format for RF packet type 1.

RF packet type 1 format

I have also spent a few days programming and trying out the ADC in the nRF24LE1 and the resolution is closer to 10 bits than 12 bits. This together with the requirement of measuring 10mA calls for a prescaler with variable gain. Two or three gain settings would suffice.

I have ordered samples of a programmable gain amplifier (PGIA) from Linear Technology and if I receive them I will use this amp instead of making  my own. Here are details about the PGIA: LTC6915 – Zero Drift, Precision Instrumentation Amplifier with Digitally Programmable Gain

As mentioned below I will use a non-inverting summation amplifier to offset the input voltage to the 0V to 1.2V required by the nRF24LE1:

Non-inverting summing amplifier.

The output voltage for this amplifier is given by this equation:

Vo = (1+R4/R3)(Vi R2+Vr R1)/(R1+R2)

Where Vr is a reference voltage that we will choose such that the voltage at the input is 0V when Vi is -110mV. If we set R1=R2 then Vr=110mV. Using these values and the fact that we want full scale (Vo=1.2V) on the ADC input when the input voltage is 50mV we get

R4/R3 = 14

The only task left then is to choose impedance level because there are an infinite number of resistor values that fits these equations. There are numerous articles on the net on this issue so I will not go into great detail here other than saying that in similar designs in the past, values from 10KΩ to 100KΩ ± has worked for me. Therefore I will start with these values: R1=R2=20KΩ, R3=10KΩ and R4=140KΩ.

To generate Vr I will use a simple voltage divider on the 3.3V supply voltage and run the divided voltage to a spare ADC input on the RF24LE1. Again there are an infinite number of resistor values to choose from and the voltage will be more stable with a low impedance level than with a high. On the other hand we are on a limited budget current-wise here so I will set a current limit on the divider to 1mA (3.3KΩ).

Voltage divider

With the standard resistor values R5=3.3KΩ and R6=120Ω we get Vr=116mV which is close enough. The exact value is not important since we will sample Vr together with Vo and use both in the equation to calculate Vi.

The SunSaver uses the Modbus in RTU mode to communicate with any external (master) device as detailed in the SunSaver MPPT MODBUS Document. In the first version of the wireless remote meter I will only use the data in the Input Registers of the SunSaver. Detailed examples of the message format with CRC values can be found in the Modbus Specification. C-language source code for the CRC calculation can be found at the end of the Modbus Serial Line Protocol and Implementation Guide. Using the information in these documents and the uart library from the nRFgo Software Development Kit (SDK) a function to read the Input Registers of the SunSaver can be written easily:

#define SS_MODBUS_ADDR 0x01

static void modbus_send_msg(uint8_t n, uint8_t *msg)
{
  uint8_t i;
  uint16_t crc;
  crc = crc16(msg, n);
  msg[n] = crc & 0xff;
  msg[n+1] = crc >> 8;
  for (i=0;i<(n+2);i++)
    hal_uart_putchar(msg[i]);
}

bool ss_mppt_read_input_registers(uint8_t a, uint8_t n, uint16_t xdata *buf)
{
  uint8_t xdata msg[256];
  uint8_t i;
  uint16_t reg;
  msg[0] = SS_MODBUS_ADDR;// Default SunSaver MPPT Modbus Address
  msg[1] = 0x04; // Read Input Registers
  msg[2] = 0; // MSB of register address
  msg[3] = a; // Register address
  msg[4] = 0; // MSB of number of registers to read
  msg[5] = n; // Number of registers to read
  modbus_send_msg(6, msg);
  if (hal_uart_getchar() != SS_MODBUS_ADDR)
    return false;
  if (hal_uart_getchar() != 0x04)
    return false;
  if (hal_uart_getchar() != (2*n))
    return false;
  for (i=0;i<n;i++)
  {
    reg = hal_uart_getchar();
    reg <<= 8;
    reg |= hal_uart_getchar();
    buf[i] = reg;
  }
  // Ignore CRC:
  hal_uart_getchar();
  hal_uart_getchar();
  return true;
}

Please note that only minimal error checking is done on the response from the SunSaver; the inter-character delay as per the Modbus spec. is not checked and the CRC is ignored. A check on these will be implemented in a future version of the firmware.

Also note that the code above uses keywords specific to the Keil C51 compiler. I will try to port the code to the free SDCC compiler after the code is finished.