MPISynqNetTiming
Definition
typedef struct MPISynqNetTiming {
double controllerFreq; /* kHz */
double controllerPeriod; /* uS */
int32_t txTime; /* % */
double calculationLimit; /* uS */
double calculationTime; /* uS */
double calculationSlack; /* uS */
int32_t bandwidthUsage; /* % */
struct {
double synq; /* uS - synq packet + spacing */
double demand; /* uS - sum demand packets + spacing */
double control; /* uS - sum control packets + spacing */
double total; /* uS */
} downstream;
struct {
double feedback; /* uS - sum feedback packets + spacing */
double status; /* uS - sum status packets + spacing */
double total; /* uS */
} upstream;
struct {
double updateFreq; /* uS */
double updatePeriod; /* uS */
double demandLatency; /* uS */
double feedbackLatency; /* uS */
double latencyOverhead; /* uS */
double controlLatency; /* uS */
double discoveryLatencyTolerance; /* +/- uS per network discovery */
} node[MPISynqNetMaxNODE_COUNT];
} MPISynqNetTiming;
Change History: Modified in the 03.04.00.
Description
MPISynqNetTiming contains static data that is determined during network initialization. It identifies timing statistics about the current network. Most values are just reported based on network timing calculations. The values that can be configured by the MPI are stated below as configurable.
| controllerFreq | The sample rate calculation of the SynqNet controller board, in kHz. It is also the rate at which SynqNet packets are sent. The controllerFreq must be configured so that the driveUpdateFreq is an integer multiple of the controllerFreq.This value is configurable. See MPIControlConfig. |
|---|---|
| controllerPeriod | The sample period calculation of the SynqNet controller board, in uS. Derived from controllerFreq. |
| txTime | The scheduled time for SynqNet packets to be sent, in % (of the controllerPeriod). Defaults to 75%. Must be set to a value greater than the foreground calculation time, and less than 100%.This value is configurable. See MPIControlConfig. |
| calculationLimit | The maximum allowed foreground calculation time, in uS. Derived from txTime * controllerPeriod. |
| calculationTime | The foreground calculation time of the controller, in uS. |
| calculationSlack | The available slack time between the foreground calculation time, and the scheduled txTime, in uS. |
| bandwidthUsage | The amount of SynqNet bandwidth used, in %, for this SynqNet configuration. The actual packet payload configured is divided by the maximum available SynqNet bandwidth, for both upstream and downstream packets. The greater of the two is reported. |
| downstream | Total downstream (controller to nodes) packet payload, in uS. Includes spacing between packets. Breaks down into the following three packet types. |
| downstream.synq | Downstream SYNQ packet payload, in uS. Includes spacing between packets. |
| downstream.demand | Downstream DEMAND packet payload, in uS. Includes spacing between packets. |
| downstream.control | Downstream CONTROL packet payload, in uS. Includes spacing between packets. |
| upstream | Total upstream (nodes to controller) packet payload, in uS. Includes spacing between packets. Breaks down into the following two packet types. |
| upstream.feedback | Upstream FEEDBACK packet payload, in uS. Includes spacing between packets. |
| upstream.status | Upstream STATUS packet payload, in uS. Includes spacing between packets. |
| node.updateFreq | The cyclic communication rate of a drive processor on a SynqNet node, in kHz. Typically fixed to 16 kHz, but may vary depending on drive type. May be configurable on some drives. This rate often matches the drive PWM rate. Analog drives that do not have drive processors and thus have no scheduled updates, do not have update frequencies and will report 0. |
| node.updatePeriod | The cyclic communication period of a drive processor on a SynqNet node, in uS. Derived from driveUpdateFreq. Analog drives that do not have drive processors and thus have no scheduled updates, do not have update frequencies and will report 0. |
| node.demandLatency | The time to send SynqNet demand data downstream from controller to nodes, in uS. Does not include drive demand delays. |
| node.feedbackLatency | The time to send SynqNet feedback data upstream from nodes to controller, in uS. Rounded up to make the total SynqNet latency an integer multiple of the driveUpdatePeriod. Does not include drive feedback delays. |
| node.latencyOverhead | |
| node.controlLatency | The overall SynqNet system control latency, in uS. Always rounded up to an integer multiple of driveUpdatePeriod. Control latency begins when position feedback is sampled on the node, includes upstream packet delays, controller foreground calculation, downstream packet delays, and ends when demands are strobed on the nodes. Note drive feedback and demand delays are NOT included. Control latency can be broken down into the four components listed below: feedbackLatency, calculationTime, calculationSlack, and demandLatency. |
| node.discoveryLatencyTolerance |
Sample Code
/*
This function allows you to calculate how much of your SynqNet cycle you are actually using. The Foreground Cycle is reading values from all the nodes, where the TX (transmit) is sending data to nodes, and commanding motion. The larger the TX Start means that the Transmiting is happening later in the SynqNet Cycle (increasing latency between reading values, and interpreting them). However it is crucial that the TX Cycle Start NEVER is lower than the Foreground Cycle legnth. Always leave a Buffer. */ int32_t synqNetTimingStatistics(MPIControl control, MPISynqNet synqNet)
{ MPISynqNetTiming timingValues;
int32_t returnValue; // Grab Timing Data & Calculate Positions
returnValue = mpiControlStatisticsReset(mpiObjects->MpiControl());
if(returnValue != MPIMessageOK){
return returnValue;
} returnValue = mpiSynqNetTiming(mpiObjects->MpiSynqNet(), &timingValues); if(returnValue != MPIMessageOK){
return returnValue;
} printf("Foreground Cycle Usage: %3.2lf%%\n", timingValues.calculationTime/SQcontrollerPeriod*100); printf("TX Start @ Cycle Percent: %3.2lf%%\n", timingValues.txTime);
printf("TX Cycle Usage: %3.2lf%%\n", timingValues.downstream.total/timingValues.controllerPeriod*100); return returnValue;
}