Zynq DMM Shield Library User Guide

Digilent provides a DMM Shield Zynq library targeted on Digilent Arty Z7-20 board, to be used with Xilinx SDK development tool.
It accesses the DMM Shield hardware in order to implement DMM Shield functionality. The library has multiple modules, corresponding to different hardware modules.
The library is designed to run on the Digilent Arty Z7-20 board, which acts as a system board for the DMM Shield. The DMM Shield is attached to the Arty Z7-20, that is accessing DMM Shield using digital pins.

• Arty Z7-20 board
• Micro-USB cable
• DMM Shield

• Vivado Design Suite & Xilinx SDK 2018.2
  • Version 2018.2 must be used to generate the project
  • There is am old Release corresponding to Vivado 2016.4
• Digilent Board Support Files for Vivado
  • Follow the Vivado Board Files for Digilent 7-Series FPGA Boards guide on how to install Board Support Files for Vivado.

Arty Z7-20 DMM Shield Project Repository – ZIP Git Repo

The Vivado hardware configuration implemented for this demo has the following features:

• basic Zynq configuration, having UART_PS0 checked
• AXI_GPIO core having 2 GPIO channels: GPIO0 for the 6 output IO signals (CS_Eprom, CS_DMM, SPI_CLK, DI, RLU, RLD, RLI) and GPIO2 for the input signal DO.

The following image shows the block design.

The following image shows the library modules and the links between them.

The diagram from Library Overall Structure shows the general structure of the DMM Shield library, the library modules, and the relations between them.
The diagram is using green arrows for the calls from outside (calls to library functions provided as a public interface) and blue arrows for the inside calls (function calls between different modules).
From the perspective of providing to the user the access to the hardware, there as three stacked layers.
The GPIO module, SPI module and UART module belong to the lowest level, which can be seen as the Data layer. The GPIO module provides a direct connection to the hardware digital pins, while the SPI module implements the SPI bit-bang protocol over the digital pins. The UART module provides the communication from the UART interface of the system board.
The DMM module, EPROM module, CALIB module and SERIALNO module belong to the middle layer, which can be seen as the Business layer.
The DMM module and EPROM module functionality is implemented using the SPI module.
The CALIB module functionality is implemented using the DMM module and EPROM module.
The SERIALNO module functionality is implemented using the EPROM module.

The library can be used as a whole or modules can be individually included in the user applications.

The provided software package can be used to access all the DMM Shield functionality. The main function calls a command interpreter from DMMCMD module, that provides access to all DMM Shield functionality.

The user may choose to include different modules in specific applications. For example, the user may choose to include DMM module in order to perform DMM configuration and measurements, CALIB module to perform user calibration operations, or EPROM module in order to perform EPROM operations.
Thus, user can decide not to use the provided command interpreter DMMCMD module, implementing a different user interface.

The DMMCMD module implements a command interpreter that has these functions:

1. It listens over UART for individual DMM Shield commands. The user will have to provide these commands using a terminal connected to the USB port corresponding to the connected Arty Z7-20 board.
2. The commands are recognized by DMMCMD module and implemented by calls to needed modules.
3. The command interpreter will send over UART (see UART module) the commands output messages, which can be seen in the terminal window.

It is important to comply with each command expected formalism. It might contain one or more arguments, as detailed in the subsequent sections of the document.
The following chapters provide details about data formatting:

• Interpreting values provided as parameter
• Format of values in the answer text
  

The DMMMCMD module is initialized using DMMCMD_Init function.
The command interpretter loop is implemented in the DMMCMD_CheckForCommand function. The following list enumerates the commands implemented in the DMMCMD module:

• DMMConfig
• DMMMeasureRep
• DMMMeasureStop
• DMMMeasureRaw
• DMMMeasureAwg
• DMMCalib
• DMMMeasureForCalib
• DMMFinalizeCalib
• DMMSaveEPROM
• DMMVerifyEPROM
• DMMImportCalib
• DMMRestoreFactCalibs
• DMMReadSerialNo

void DMMCMD_Init();

<none>

uint8_t - The error code:

This function initializes the modules involved in the DMMCMD module.

It initializes the DMM, UART, CALIB and SERIALNO modules.

The return values are related to errors when calibration is read from user calibration area of EPROM during calibration initialization call.

The function returns ERRVAL_SUCCESS for success.

The function returns ERRVAL_EPROM_MAGICNO when a wrong magic number was detected in the data read from EPROM.

The function returns ERRVAL_EPROM_CRC when the checksum is wrong for the data read from EPROM.

#include “dmmcmd.h”

DMMCMD_Init();

void DMMCMD_CheckForCommand();

<none>

uint8_t - The error code:
<none>

This function checks on UART if a command was received.

It compares the received command with the commands defined in the commands array. If recognized, the command is processed accordingly.

It also performs the repeated commands.

#include “dmmcmd.h”

DMMCMD_CheckForCommand();

“DMMConfig <Scale>”

“DMMConfig VoltageDC5”

The DMMConfig command configures the DMM for a specific scale.

The possible values from the <Scale> are shown in the Scale column of the following table:

“DMMMeasureRep”

This commands initiates a session of repetitive measurements. These repetitive measurements will be performed until the DMMMeasureStop command is issued.

<none>

> - After issuing the command: “OK, Measure repeated” > - Repeatedly, for each measurement:

“DMMMeasureStop”

This command terminates the repetitive measurements session initiated by DMMMeasureRep or DMMMeasureRaw commands.

<none>

“OK, Measure stop”

“DMMMeasureRaw”

This command initiates a session of repetitive measurements of raw values. Raw values are values acquired from DMM, without applying the calibration corrections. These repetitive measurements will be performed until the DMMMeasureStop command is issued.

<none>

- After issuing the command: “OK, Measure raw”
- Repeatedly, for each measurement:

“DMMMeasureAvg”

This commands performs one average measurement (taking the average value of a set of measurements).

<none>

“DMMCalib<P, N or Z> <reference value>”

“DMMCalibP 5.000115 V”

“DMMCalibN -5.001185”

“DMMCalibZ”

This command performs the positive, negative, or on zero calibration, depending on the character following DMMCalib command (‘P’, ‘N’ or ‘Z’). This is performed by initiating a measurement and then saving the measured value to be later processed when all the needed data will be present and the calibration will be finalized. For positive and negative calibration, a reference value is provided as a parameter, which is also saved together with the measured value.

“DMMMeasureForCalib<P or N>”

“DMMMeasureForCalibP”

or

“DMMMeasureForCalibN”

This command initiates the positive or negative (depending on the character following DMMCalib command: ‘P’ or ‘N’) measurement for calibration, depending on the character following DMMCalib command (‘P’ or ‘N’). This is performed by initiating a measurement and then saving the measured value to be later processed when all the needed data will be present and the calibration will be finalized. Compared to DMMCalib function, the calibration process is split in two steps:
- the calibration measurement is launched (using this command) prior declaring the reference value
- the reference value is later declared using DMMFinalizeCalib command.

<none>

“DMMFinalizeCalib<P or N> <reference value>”

“DMMFinalizeCalibP 5.000115 V”

or

“DMMFinalizeCalibN -5.001185”

This command finalizes the positive or negative (depending on the character following DMMCalib command: ‘P’ or ‘N’) calibration process started using DMMeasureForCalib by declaring the reference value. The reference value is saved to be later processed when all the needed data will be present and the calibration will be finalized. Compared to DMMCalib function, the calibration process is split into two steps:
- the calibration measurement is launched (using DMMeasureForCalib command) prior declaring the reference value
- the reference value is later declared using this command.

“DMMSaveEPROM”

This command saves to user EPROM all the calibrations. It is important to save calibration data to EPROM after calibrations are performed, otherwise, the calibrations are lost next time the board is powered off.

<none>

“DMMVerifyEPROM”

This function verifies the content of the calibration data against the user calibration data stored in EPROM.

<none>

“DMMExportCalib”

This command exports the content of the user calibration data as a table, showing for each scale index the additive and multiplicative coefficients. The coefficients are formatted as fractional numbers, with 6 decimals.

<none>

“DMMImportCalib <Scale index>, <Multiplicative calibration coefficient>, <Additive calibration coefficient>”

“DMMImportCalib 10, 0.021222, -0.000125”

This command imports the calibration data for a specific scale. It does not save calibration the data in EPROM.

“DMMRestoreFactCalibs”

This command restores the calibration data with the factory loaded values. It reads data from the factory calibration area of EPROM and saves it to the user calibration area of EPROM.

<none>

“DMMReadSerialNo”

This command retrieves the 12 digits serial number information from EPROM.

<none>

Values formatted in character strings must be provided as parameters for some functions, for example the reference value provided as parameter to calibration functions in DMMCMD module, see DMMCalib.
Providing a value as a parameter must comply to the following rules: The value is composed by a fractional number followed by the unit. The unit is formed by the base unit (“V”, “A” or “Ohm”), eventually prefixed by multiple/submultiple designators (“u”, “m”, “k” and “M”). It is mandatory that the base unit matches the currently selected scale, otherwise the following error is returned: “ERROR, The provided value <value string> has a wrong measure unit”.
The function that implements value interpreting is DMM_InterpretValue.

Example: “2.456789 mV” is correct for VoltageDC5 scale, and corresponds to the 0.002456789 value.

Some functions return character strings representing values, for example get value functions of the DMMCMD module, see DMMMeasureRep.
The values will be formatted as a fractional number (6 decimals), followed by the base unit (“V”, “A” or “Ohm”) corresponding to the current selected scale. No multiple / submultiple designators of the base unit are used.

Example: 0.002456789 is formatted “0.002456 V” for all of the voltage scales.

The DMM library module implements DMM (digital multimeter) related functions.
These functions configure the DMM device over the custom SPI in order to set a specific scale. They read over the custom SPI the status / converter values specific to each scale, thus retrieving measured values.
The value retrieval function waits until the converters provide valid values. The values retrieved from DMM device are considered raw values. The DMM module applies (controlled by a flag) calibration coefficients over the raw values, obtaining measured values. See Calibration Procedure for more details.
In order to implement the custom SPI communication, the DMM module accesses functions implemented in SPI Module. It uses digital IO pins exposed in the DMM Shield connector: CS_DMM (SPI chip select), DO (SPI MISO), DI (SPI MOSI) and CLK (SPI CLK). While the chip select is specific to DMM, the SPI lines (data and clock) are shared with EPROM Device.
The DMM module functions are accessed by CALIB Module and DMMCMD module functions. See Library overall structure for more details about the interaction between modules.
See DMM device for more details about DMM functionality.
See DMM Measured Values for more information regarding the values retrieved from DMM.
Read DMM_DGetValue for more details about the measured values.

The DMM functions can be grouped in the following way:
- Initialization:

• DMM_Init
  

- Scale functions:

• DMM_SetScale
• DMM_GetCurrentScale

- Value functions:

• DMM_DGetValue
• DMM_DGetAvgValue
• DMM_SetUseCalib
• DMM_CheckAcceptedMeasurementDispersion

- Value formatting functions:

• DMM_FormatValue
• DMM_InterpretValue

void DMM_Init();

<none>

<none>

This function initializes the DMM module.

It calls the SPI_Init() function to initialize the digital pins used by DMM Shield.

#include “dmm.h”

DMM_Init();

uint8_t DMM_SetScale(int idxScale);

uint8_t - The error code:

This function configures a specific scale as the current scale.
According to this scale, it uses data defined in dmmcfg structure to configure the switches and to set the value of the registers (24 registers starting at 0x1F address).

It also verifies the configuration setting success status by reading the values of these registers.

It returns ERRVAL_SUCCESS if the operation is successful.

It returns ERRVAL_DMM_CFGVERIFY if verifying fails.

It returns ERRVAL_DMM_IDXCONFIG if the scale index is not valid.

#include “dmm.h”

bErrCode = DMM_SetScale(idxCfg);

int DMM_GetCurrentScale();

<none>

int

This function returns the current scale index. This is the last scale index selected using the DMM_SetScale function.

In case no current scale was selected, the function returns -1.

#include “dmm.h”

int idxScale = DMM_GetCurrentScale();

double DMM_DGetValue(uint8_t *pbErr);

The *pbErr parameter can be set to:

double

This function repeatedly retrieves the value from the converter / RMS registers, until a valid value is detected

It returns INFINITY when measured values are outside the expected converter range.

If there is no valid current scale selected, the function sets the error value to ERRVAL_DMM_IDXCONFIG and NAN value is returned.

If there is no valid value retrieved within a specific timeout period, the error is set to ERRVAL_DMM_VALIDDATATIMEOUT and NAN value is returned.

This function compensates the not linear behavior of VoltageDC50 scale.

When no errors are detected, the error is set to ERRVAL_SUCCESS.

The error is copied in the byte pointed by pbErr, if pbErr is not null.

#include “dmm.h”

double dVal = DMM_DGetValue(&bErr);

double DMM_DGetAvgValue(uint8_t *pbErr);

The *pbErr parameter can be set to:

double

This function computes an average value corresponding to the DMM value returned by DMM_DGetValue, for the specified number of samples.

If there is no valid current scale selected, the error is set to ERRVAL_DMM_IDXCONFIG.

If there is no valid value retrieved within a specific timeout period, the error is set to ERRVAL_DMM_VALIDDATATIMEOUT.

It returns INFINITY when measured values are outside the expected converter range.

When no error is detected, the error is set to ERRVAL_SUCCESS.

The error is copied on the byte pointed by pbErr, if pbErr is not null.

When errors are detected, the function returns NAN.

#include “dmm.h”

double dVal;

dVal = DMM_DGetAvgValue(20, &bResult);

void DMM_SetUseCalib(uint8_t f);

<none>

This function sets the parameter that will determine whether or not the calibration coefficients will be applied when value is computed in subsequent DMM_DGetStatus calls.

The default value for this parameter is 1.

#include “dmm.h”

DMM_SetUseCalib(0);

uint8_t DMM_CheckAcceptedMeasurementDispersion(double dMeasuredVal, double dRefVal, double *pDispersion);

uint8_t

This function checks if the measurement dispersion exceeds the accepted range.

The dispersion is computed as the difference of the measured and reference values, divided by the scale range.

The positive dispersion is checked to be smaller than parameter calibAcceptP of the scale configuration data.

The range of accepted values for dispersion is specific to each scale and it's defined in dmmcfg array.

The positive values of dispersion are checked to be smaller than field calibAcceptP of dmmcfg.

The negative values of dispersion are checked to be smaller than field calibAcceptN of dmmcfg.

If dispersion is not in the accepted range then ERRVAL_DMM_MEASUREDISPERSION is returned and the error string is set to last error string in ERRORS module. This string can be later accessed with ERRORS_GetszLastError function.

If there is no valid current configuration selected, the function returns ERRVAL_DMM_IDXCONFIG.

When the dispersion is in the accepted range, the function returns ERRVAL_SUCCESS.

#include “dmm.h”

bResult = DMM_CheckAcceptedMeasurementDispersion( *pMeasuredVal, dRefVal, pDispersion);

uint8_t DMM_FormatValue(double dVal, char *pString);

uint8_t

The function formats a value according to the current selected scale.

The parameter value dVal must correspond to the base Unit (V, A or Ohm), mainly a measured value returned by DMM_DGetValue.

The function multiplies the value according to the scale specific multiple / submultiple.

It formats the value with 6 decimals.

If fUnit is not 0 it adds the measure unit text (including multiple / submultiple) corresponding to the scale.

If dVal is +/- INFINITY (converter values are outside expected range), then “OVERLOAD” string is used for all scales except Continuity.

If dVal is +/- INFINITY (converter values are outside expected range), then “OPEN” string is used for Continuity scale.

The function returns ERRVAL_DMM_IDXCONFIG if the current scale is not valid.

For example it formats the value 0.0245678912 into the “24.678912 mV” if the current scale is VoltageDC50m.

#include “dmm.h”

DMM_FormatValue(dRefVal, szRefVal);

uint8_t DMM_InterpretValue(char *pString, double *pdVal);

uint8_t

The function extracts a value from a string containing a value, eventually followed by a Unit.

The string Unit must match the current scale base Unit (V, A or Ohm), still different multiples/submultiples can be used.

The function returns in the variable pointed by pdVal the extracted value in the base Unit, regardless of the multiple / submultiple used in the input string, or the multiple / submultiple specific to the current scale.

If the string is “OVERLOAD” or “OPEN”, then INFINITY value is returned.

If the measure unit is missing then the unit (with multiple / submultiple) corresponding to the current scale is used.

The function returns ERRVAL_DMM_IDXCONFIG if the current scale is not valid.

The function returns ERRVAL_CMD_VALWRONGUNIT if the measure unit does not match the current scale base Unit (V, A or Ohm).

The function returns ERRVAL_CMD_VALMISSINGUNIT if the measure unit is missing.

The function returns ERRVAL_CMD_VALFORMAT if the numeric value cannot be extracted from the provided string.
For example it interprets the string “24.678912 mV” and returns the value 0.0245678912 if the current scale is any of the Voltage scales.

#include “dmm.h”

bErrCode = DMM_InterpretValue(szVal, &dRefVal);

CALIB module groups functions that implement calibration functionality of DMM Shield. The functions are implemented in calib.c source file.
The DMM Shield measuring hardware has errors due to DMM device and DMM Shield's additional components.
Calibration is the process of establishing some correction coefficients that, applied to the acquired values, allow more precise measurements. Calibration is done for each scale (see DMM module).
For each scale, calibration is done in multiple points: positive, on zero or negative, depending on scale). The positive/negative calibrations are done at a value close to the maximum/minimum scale value. The reference value is measured using a separate measuring device, as accurate as possible.
Calibration is done by calling calibration functions to inform the system that in a specific moment the reference values are applied to the DMM Shield connectors. The library functions initiate a DMM Shield measurement and then the measured value and reference value are stored, to be used when all the calibration data exists.

There are three groups of functions:
- Initialization:

• CALIB_Init
  

- Functions that implement calibration functionality:

• CALIB_CalibOnPositive
• CALIB_CalibOnNegative
• CALIB_CalibOnZero
• CALIB_MeasureForCalibPositiveVal
• CALIB_MeasureForCalibNegativeVal

- Main functions that deal with EPROM calibration data:

• CALIB_WriteAllCalibsToEPROM_User
• CALIB_ReadAllCalibsFromEPROM_User
• CALIB_RestoreAllCalibsFromEPROM_Factory

- Auxiliary functions that deal with EPROM calibration data::

• CALIB_VerifyEPROM
• CALIB_ExportCalibs_User
• CALIB_ExportCalibs_Factory
• CALIB_ImportCalibCoefficients

Read Calibration chapter for more details about calibration.
The CALIB module maintains a data structure that stores the partial calibration data, called partCalibData, collecting (as a result of calls to calibration functions) all the necessary data until a calibration is complete. This has the following fields:

• double Calib_Ms_Zero;
• double Calib_Ms_ValP;
• double Calib_Ref_ValP;
• double Calib_Ms_ValN;
• double Calib_Ref_ValN;

These fields will be later used in the function description.

uint8_t CALIB_Init();

<none>

uint8_t - The error code:

This function initializes the calibration related data.

It initializes the EPROM module, the partial calibration data and reads all the calibration values from user calibration area of EPROM.

The return values are related to errors when calibration is read from user calibration area of EPROM.

The function returns ERRVAL_SUCCESS when success.

The function returns ERRVAL_EPROM_MAGICNO when a wrong magic number was detected in the data read from EPROM.

The function returns ERRVAL_EPROM_CRC when the checksum is wrong for the data read from EPROM.

#include “calib.h”

bResult = CALIB_Init();

uint8_t CALIB_CalibOnPositive(double dRefVal, double *pMeasuredVal, uint8_t bEarlyMeasurement, double *pDispersion, uint8_t fIgnoreDispersion);

uint8_t

This function implements the calibration on positive value procedure, for the currently selected scale.

It is possible that function CALIB_MeasureForCalibPositiveVal was previously called. This is considered early measurement, and in this case parameter bEarlyMeasurement must be set to a non 0 value.

If no early measurement was performed (bEarlyMeasurement parameter is 0), the function calls CALIB_MeasureForCalibPositiveVal in order to perform the measurement and provide the measured value.

If early measurement was performed (bEarlyMeasurement parameter is non 0), the measured value is copied from Calib_Ms_ValP field of partCalibData.

If early measurement was performed and Calib_Ms_ValP is not valid (no valid measurement was previously performed), the function returns ERRVAL_CALIB_MISSINGMEASUREMENT.

The dispersion is computed as the difference of the measured and reference values, divided by the scale range. The dispersion is checked to be in the accepted range using DMM_CheckAcceptedMeasurementDispersion function.

If the parameter fIgnoreDispersion is non 0, the dispersion check is skipped, meaning that all the values are accepted and ERRVAL_DMM_MEASUREDISPERSION error is never returned.

Caution when calling the function with fIgnoreDispersion parameter with non 0 values, as calibration data can be seriously altered.

If dispersion is not in the accepted range then calibration is not finalized, partial calibration data is initialized and ERRVAL_DMM_MEASUREDISPERSION is returned.

When success, the reference value is stored in the Calib_Ref_ValP field of partCalibData.

When success, if the calibration process is complete then the calibration coefficients are computed.

If there is no valid current configuration selected, the function returns ERRVAL_DMM_IDXCONFIG and the measured value is set to NAN.

If a valid measurement cannot be performed, the function returns ERRVAL_DMM_VALIDDATATIMEOUT and the measured value is set to NAN.

#include “calib.h”

bErrCode = CALIB_CalibOnPositive(dRefVal, &dMeasuredVal, 0, &dispersion, 0);

uint8_t CALIB_CalibOnNegative(double dRefVal, double *pMeasuredVal, uint8_t bEarlyMeasurement, double *pDispersion, uint8_t fIgnoreDispersion);

uint8_t

This function implements the calibration on negative value procedure, for the current selected scale.

It is possible that function CALIB_MeasureForCalibNegativeVal was previously called. This is considered early measurement, and in this case parameter bEarlyMeasurement must be set to any non 0 value.

If no early measurement was performed (bEarlyMeasurement parameter is 0), the function calls CALIB_MeasureForCalibNegativeVal in order to perform the measurement and provide the measured value.

If early measurement was performed (bEarlyMeasurement parameter is non 0), the measured value is copied from Calib_Ms_ValN field of partCalibData.
If early measurement was performed and Calib_Ms_ValP is not valid (no valid measurement was previously performed), the function returns ERRVAL_CALIB_MISSINGMEASUREMENT.

The dispersion is computed as the difference of the measured and reference values, divided by the scale range. The dispersion is checked to be in the accepted range using DMM_CheckAcceptedMeasurementDispersion function.

If parameter fIgnoreDispersion is non 0, the dispersion check is skipped, meaning that all the values are accepted and ERRVAL_DMM_MEASUREDISPERSION error is never returned.

Caution when calling the function with fIgnoreDispersion parameter with non 0 values, as calibration data can be seriously altered.

If dispersion is not in the accepted range then calibration is not finalized, partial calibration data is initialized and ERRVAL_DMM_MEASUREDISPERSION is returned.

When success, the reference value is stored in the Calib_Ref_ValN field of partCalibData.

When success, if the calibration process is complete then the calibration coefficients are computed.

If there is no valid current configuration selected, the function returns ERRVAL_DMM_IDXCONFIG and the measured value is set to NAN.

If a valid measurement cannot be performed, the function returns ERRVAL_DMM_VALIDDATATIMEOUT and the measured value is set to NAN.

#include “calib.h”

bErrCode = CALIB_CalibOnNegative(dRefVal, &dMeasuredVal, 0, &dispersion, 0);

uint8_t CALIB_CalibOnZero(double *pMeasuredVal, double *pDispersion, uint8_t fIgnoreDispersion);

uint8_t

This function implements the calibration on zero procedure, for the currently selected scale.

The function performs the measurement and then if the calibration process is complete the calibration coefficients are computed.

The dispersion is computed as the difference between the measured and reference values, divided by the scale range.

The dispersion is checked to be in the accepted range if parameter fIgnoreDispersion 0.

If parameter fIgnoreDispersion is non 0, the dispersion check is skipped, meaning that all the values are accepted and ERRVAL_DMM_MEASUREDISPERSION error is never returned. Caution when calling the function with fIgnoreDispersion parameter having values different than 0, as calibration data can be seriously altered.

If dispersion is not in the accepted range then calibration is not finalized, and ERRVAL_DMM_MEASUREDISPERSION is returned.

If there is no valid current configuration selected, the function returns ERRVAL_DMM_IDXCONFIG and the measured value is set to NAN.

If a valid measurement cannot be performed, the function returns ERRVAL_DMM_VALIDDATATIMEOUT and the measured value is set to NAN.

#include “calib.h”

bErrCode = CALIB_CalibOnZero(&dMeasuredVal, &dispersion, 0);

uint8_t CALIB_MeasureForCalibPositiveVal(double *pMeasuredVal);

uint8_t

This function performs the measurement for the calibration on positive value procedure, for the currently selected scale.

The function calls the DMM_DGetAvgValue function in order to acquire the measured value without the calibration correction being applied.
When success, the measured value is stored in the Calib_Ms_ValP field of partCalibData structure, and it's set as measured value.

If there is no valid current configuration selected, the function returns ERRVAL_DMM_IDXCONFIG and the measured value is set to NAN.

If a valid measurement cannot be performed, the function returns ERRVAL_DMM_VALIDDATATIMEOUT and the measured value is set to NAN.

This function can be called by CALIB_CalibOnPositive or can be called directly, before CALIB_CalibOnPositive (this is considered early measurement).

#include “calib.h”

bResult = CALIB_MeasureForCalibPositiveVal(pMeasuredVal);

uint8_t CALIB_MeasureForCalibNegativeVal(double *pMeasuredVal);

uint8_t

This function performs the measurement for the calibration on negative value procedure, for the currently selected scale.

The function calls the DMM_DGetAvgValue function in order to acquire the measured value without the calibration correction being applied.
When success, the measured value is stored in the Calib_Ms_ValN field of partCalibData structure, and it's set as measured value.

If there is no valid current configuration selected, the function returns ERRVAL_DMM_IDXCONFIG and the measured value is set to NAN.

If a valid measurement cannot be performed, the function returns ERRVAL_DMM_VALIDDATATIMEOUT and the measured value is set to NAN.

This function can be called by CALIB_CalibOnNegative or can be called directly, before CALIB_CalibOnNegative (this is considered early measurement).

#include “calib.h”

bResult = CALIB_MeasureForCalibNegativeVal(pMeasuredVal);

uint8_t CALIB_WriteAllCalibsToEPROM_User();

<none>

uint8_t - Number of modified calibrations or the error code:

This function writes calibration data in the user calibration area of EPROM.

This function should be called after changes are made in calibration data, in order to save them in the non-volatile memory.

In case of success the function returns the number of configurations that were modified since last save.

It returns ERRVAL_EPROM_WRTIMEOUT when calibration data write in EPROM is not properly performed.

#include “calib.h”

bErrCode = CALIB_WriteAllCalibsToEPROM_User();

uint8_t CALIB_ReadAllCalibsFromEPROM_User();

<none>

uint8_t - The error code:

This function reads the user calibration data from EPROM.

It calls the local function CALIB_ReadAllCalibsFromEPROM_Raw function providing the address of user calibration area in EPROM,
The function returns ERRVAL_SUCCESS for success.

The function returns ERRVAL_EPROM_MAGICNO when a wrong magic number was detected in the data read from EPROM.

The function returns ERRVAL_EPROM_CRC when the checksum is wrong for the data read from EPROM.

#include “calib.h”

bResult = CALIB_ReadAllCalibsFromEPROM_User();

uint8_t CALIB_RestoreAllCalibsFromEPROM_Factory();

<none>

uint8_t - The error code:

This function restores the factory calibration data from EPROM.

This function reads factory calibration data from EPROM and writes the calibration data into the user calibration area of EPROM.

The function returns ERRVAL_SUCCESS for success.

It verifies the read factory calibration data from EPROM and detects the following errors: ERRVAL_EPROM_MAGICNO when a wrong magic number was detected, and ERRVAL_EPROM_CRC when the checksum is wrong.

It also returns ERRVAL_EPROM_WRTIMEOUT when calibration user data write in EPROM is not properly performed.

#include “calib.h”

bResult = CALIB_ReadAllCalibsFromEPROM_User();

uint8_t CALIB_VerifyEPROM();

<none>

uint8_t - The error code:

This function compares the user calibration data from EPROM with the current calibration data.

The function returns ERRVAL_SUCCESS for success, the user calibration data from EPROM is identical to the current calibration data.

The function returns ERRVAL_EPROM_VERIFY for mismatch values found when comparing the user calibration data from EPROM with the current calibration data.

The function returns ERRVAL_EPROM_MAGICNO when a wrong magic number was detected in the data read from EPROM.

The function returns ERRVAL_EPROM_CRC when the checksum is wrong for the data read from EPROM.

#include “calib.h”

bErrCode = CALIB_VerifyEPROM();

uint8_t CALIB_ExportCalibs_User(char *pSzCalibs);

uint8_t - The error code:

This function exports user calibration data into a text.

The export is performed by formatting the calibration values in a text, copied in pSzCalibs, one row for each Scale index.

Therefore is important that the caller of this function allocates enough space in pSzCalibs (750 characters).

The function returns ERRVAL_SUCCESS for success.

The function returns ERRVAL_EPROM_MAGICNO when a wrong magic number was detected in the data read from EPROM.

The function returns ERRVAL_EPROM_CRC when the checksum is wrong for the data read from EPROM.

#include “calib.h”

char calExp[1024];

bErrCode = CALIB_ExportCalibs_User(calExp);

uint8_t CALIB_ExportCalibs_Factory(char *pSzCalibs);

uint8_t - The error code:

This function exports factory calibration data into a text.

The export is performed by formatting the calibration values in a text, copied in pSzCalibs, one row for each Scale index.

Therefore is important that the caller of this function allocates enough space in pSzCalibs (750 characters).

The function returns ERRVAL_SUCCESS for success.

The function returns ERRVAL_EPROM_MAGICNO when a wrong magic number was detected in the data read from EPROM.

The function returns ERRVAL_EPROM_CRC when the checksum is wrong for the data read from EPROM.

#include “calib.h”

char calExp[1024];

bErrCode = CALIB_ExportCalibs_Factory(calExp);

uint8_t CALIB_ImportCalibCoefficients(int idxScale, float fMult, float fAdd);

uint8_t - The error code:

This function imports the MULT and ADD calibration coefficients, for the provided Scale.

On success, the coefficients are copied in the calibration data corresponding to the provided Scale.

The function copies the calibration coefficients into the calibration data and marks the calibration for the provided Scale as dirty (needs to be written in EPROM).

The function returns ERRVAL_DMM_IDXCONFIG if the provided Scale is not valid.

#include “calib.h”

bErrCode = CALIB_ImportCalibCoefficients(10, 0.021222, -0.000125);

The DMM Shield provides a non-volatile EEPROM memory 93LC66BT, having 512 bytes (4kbits).
It is accessed over a custom SPI protocol, using digital IO pins exposed in the DMM Shield connector: CS_EEPROM (EPROM SPI chip select), DO (SPI MISO), DI (SPI MOSI) and CLK (SPI CLK).
While the chip select is specific to EPROM, the SPI lines (data and clock) are shared with DMM device (see DMM module). The EPROM is used to store the following system information:

• Serial number:
  • 12 bytes payload (see Serial Number)
  • 2 extra bytes: magic number, checksum
  • Total 14 bytes, see the address space table below.
• User Calibration:
  • 27*2*4 bytes payload (2 values of 4 bytes (float) for 27 scales)
  • 2 extra bytes: magic number, checksum
  • Total 218 bytes, see the address space table below.
• Factory Calibration:
  • 27*2*4 bytes payload (2 values of 4 bytes (float) for 27 scales)
  • 2 extra bytes: magic number, checksum
  • Total 218 bytes, see the address space table below.

Note that the structure of User Calibration area is identical to the structure of Factory Calibration area.
For more details about Calibration process, read more on CALIB module.
Each of the tree above mentioned sections contains, for safety reasons, additional information:

• a byte containing a specific number called magic number (0x23)
• a byte containing the checksum of all the bytes written in the specific section

When reading a section content from EPROM, these two security bytes are checked, returning errors when mismatches are found.
The following table details the address space:

The addressing unit of the memory is a 16-bit word. As the memory capacity is 256 words, the word addresses are implemented using 8-bit byte type.
Apart from this system information stored in EPROM, applications can be implemented to store specific user data using write functions from EPROM module, to access the unused memory starting at address 0. These functions are protected against writing over the system areas detailed above.

void EPROM_Init();

<none>

<none>

This function initializes the EPROM module.

It calls the SPI_Init() function to initialize the digital pins used by DMM Shield.

This function is called by CALIB_Init() and SERIALNO_Init().

The function guards against multiple calls using a static flag variable.

#include “eprom.h”

EPROM_Init();

void EPROM_ReadWords(uint8_t bAddress, uint16_t *prgVals, int cwVals)

<none>

This function reads the specified number of words (16 bit values) from the specified EPROM word address into the specified buffer.

#include “eprom.h”

EPROM_ReadWords(0, (uint16_t *)&pUserData, 31);

uint8_t EPROM_WriteWords(uint8_t bAddress, uint16_t *prgVals, int cwVals);

uint8_t - The error code:

This function writes the specified number of words (16-bit values) in EPROM, at the specified word address.

It is mandatory to enable the write operation before sending the data to EPROM, by calling the EPROM_WriteEnable() function.

The function returns ERRVAL_EPROM_ADDR_VIOLATION if write is attempted over the system reserved areas of EPROM.

Otherwise, the function returns ERRVAL_SUCCESS for success or ERRVAL_EPROM_WRTIMEOUT when EPROM is not answering with the write successful message.

#include “eprom.h”

bErrorCode = EPROM_WriteWords(0, (uint16_t *)&pUserData, 31);

void EPROM_WriteEnable();

<none>

<none>

This function implements the EWEN (Write Enable) EPROM instruction.

Call this function before any EPROM write operations.

#include “eprom.h”

EPROM_WriteEnable();

void EPROM_WriteDisable();

<none>

<none>

This function implements the EWDS (Write Disable) EPROM instruction.

Use this function to protect the values written in EPROM against subsequent writes.

#include “eprom.h”

EPROM_WriteDisable();

void EPROM_Erase(uint8_t bAddress);

<none>

This function implements the ERASE EPROM instruction that erases one word.

Call this function in order to force all 16 bits of the specified address to 1.

#include “eprom.h”

EPROM_Erase(0x10);

The SERIALNO module implements the functions related to Serial Number data (stored during factory process into the EPROM memory). See Serial Number for more details about the information contained in the Serial Number. The module provides an initialization function (SERIALNO_Init) and a data retrieving function SERIALNO_ReadSerialNoFromEPROM. It uses the EPROM module in order to access EPROM memory.

Each board has a unique serial number information (called SerialNo), built as follows:

• 6 characters DMM Shield prefix (Digilent ID + Schematic ID): “210356”
  
• 6 characters unique serial of each board (read from the barcode label, after ‘D’): for example “A76C0C”
  

Example of DMM Shield SerialNo: “210356A76C0C”
This is written in the EPROM during the manufacturing procedure and shouldn’t be altered by the user. For more details see SERIALNO module and EPROM module.

void SERIALNO_Init();

<none>

<none>

This function initializes the SERIALNO module.

It calls the initialization function for the EPROM module.

#include “SERIALNO.h”

SERIALNO_Init();

uint8_t SERIALNO_ReadSerialNoFromEPROM(char *pSzSerialNo);

uint8_t - The error code:

This function retrieves the Serial Number information (12 characters) from EPROM .

Therefore is important that the caller of this function allocates enough space in pSzSerialNo.

The function returns ERRVAL_SUCCESS when success.

The function returns ERRVAL_EPROM_MAGICNO when a wrong magic number was detected in the data read from EPROM.

The function returns ERRVAL_EPROM_CRC when the checksum is wrong for the data read from EPROM.

#include “SERIALNO.h”

char szSerialNo[13];
bResult = SERIALNO_ReadSerialNoFromEPROM(szSerialNo);

The SPI module implements the SPI communication needed for DMMCMD module and EPROM module.
It uses the GPIO module for configuring and accessing the output digital lines SPI clock and SPI data out, and the input digital line SPI data in.
The functions of this module allow the transfer of any number of bits, needed in order to implement the communication protocols with the above mentioned modules.
The module should only be accessed through the functions from upper level modules.

The GPIO module provides the lowest level, the hardware access level to the digital lines.
It configures the required digital lines as output or input digital line, provides the possibility to set a specific output digital line to 0 or 1 value, and to read the value of a digital input line.
It is accessed by SPI module in order to implement the custom SPI access, by DMM module that accesses DMM SPI chip select and relays digital lines and by EPROM module that accesses EPROM SPI chip select digital line.
This module is the only module dependent to the hardware.
The module should only be accessed through the functions from upper-level modules.

The UART module implements the functionality needed to communicate on UART_PS0 hardware interface of the Arty Z7 - 20 board, connected to the USB - UART.
For example, using this module, UART communication between Arty Z7 - 20 and PC can be implemented over USB cable. Connecting the Arty Z7 - 20 to the PC creates a new COM port which can be used in a simple terminal application.
The module initializes the UART without interrupts. Polling method is used to receive available characters.
This module has no DMM functionality. It is just included to provide communication capabilities. It doesn't have to include in an application that doesn't need communication (for example an application that uses an LCD connected to Arty Z7 - 20 board using the shield connector). We recommend initializing the module at 115200 baud rate for a basic application.
The module is only accessed by DMMCMD module.
The module provides: - Initialization function:

• UART_Init
  

- Character string transmit function:

• UART_PutString
  

- Character string receive function:

• UART_GetString
  

u8 UART_Init(u32 dwBaudRate);

uint8_t - The error code:

This function initializes the UART-PS controller at the specified baud rate.

#include “uart.h”

UART_Init(115200);

void UART_PutString(char szData[])

<none>

This function transmits all the characters from a zero terminated string over UART1.
The terminator character is not sent.

#include “uart.h”

UART_PutString(“Hello World\r\n”);

uint8_t UART_GetString(char* pchBuff, int cchBuff)

<none>

This function provides a zero terminated string received over UART1 which was placed in the circular buffer by the UART interrupt handler.

If a received string is available in the circular buffer, the string is copied in the pchBuff string and its length is returned.

Otherwise, the function returns 0.

#include “uart.h”

cchi = UART_GetString(uartCmd, 0x40);

DMM Shield allows selecting one from the following set of scales. The following table shows all the scales, together with 2 extra columns: corresponding Base measure unit and the Measure unit used when formatting the value. See DMM Measured Values for these columns.

• Arduino DMM Shield Library User Guide
• Arty Z7 DMM Shield Oled Demo User Guide
• Arty Z7-20 DMM Shield Webserver Demo User Guide
• DMM Shield Reference Manual
• DMM Shield Schematic (Rev. C)
• PIC32 DMM Shield Library User Guide
• Zynq DMM Shield Library User Guide