Changes - Dynomotion

KMotionDef

27,762 bytes added, 19:07, 11 February 2016

/* No summary */

===KMotionDef.h===

The KMotionDef.h, is a C header file which lists all variables and functions available to [[KFLOP C Programs]]. The KMotionDef.h file can be located in the <KMotion Installation Dir >\DSP_KFLOP\ directory.

~~The KMotionDef.h, is a C header file which lists all variables and functions available to [[KFLOP C Programs]]. The KMotionDef.h file can be found at <KMotion Installation Directory>\DSP_KFLOP\~~

====The Big List====

Please Note - at the moment this is a direct copy and paste of the KMotionDef.h file. As time allows, it will gradually link to other pages containing further details and examples of related variables and functions. If you wish to contribute to this task, please register.

To make already linked variables/functions stand out, the original unedited text has been coloured Blue. As the page is edited and linked, it will revert to normal wiki text colours.

// // KMotionDef.h - MAIN HEADER FILE FOR USER C PROGRAMS // // Copyright Dynomotion 2/20/2004 // // Include this header file in User C programs that execute // in the DSP to define all User accessible KMotion functions, // constants, and data structures

// // KMotionDef.h - MAIN HEADER FILE FOR USER C PROGRAMS // // Copyright Dynomotion 2/20/2004 // // Include this header file in User C programs that execute // in the DSP to define ~~KMotionDef_h~~all User accessible KMotion functions, // constants, and data structures

#~~define KFLOP~~ifndef KMotionDef_h #define ~~C6722~~KMotionDef_h

#~~define BOARD~~ define KFLOP #define C6722

~~extern const char VersionAndBuildTime[]~~# define BOARD "KFLOP"</~~/ string with version and build time~~span>

extern const char VersionAndBuildTime[]; // ~~200 MHz~~string with version and build time</4 span>

~~typedef int BOOL~~# define CLOCKFREQ 50.0e6 // 200 MHz/4

~~#ifndef _SIZE_T~~<~~br />~~span style="color: #~~define _SIZE_T typedef ~~unsigned~~ int ~~size_t~~BOOL; ~~#endif

#ifndef ~~NULL~~_SIZE_T #define ~~NULL 0~~_SIZE_T typedef unsigned int size_t; #endif

#~~ifndef FALSE~~<~~br />~~span style="color: #~~define FALSE 0 ~~#endif #~~ifndef ~~TRUE~~NULL ~~#define TRUE 1~~ ~~#endif~~ <~~br />~~span style="color: #~~ifndef PI #define ~~PI 3.14159265358979323846264~~NULL 0 ~~#endif~~ ~~#ifndef PI_F~~<~~br />~~span style="color: #~~define PI_F 3.1415926535f #~~endif endif #ifndef TWO_PI_F #define TWO_PI_F (2.0f * 3.1415926535f) #endif #ifndef PI_2F #define PI_2F (3.1415926535f * 0.5f) #endif #ifndef TWO_PI #define TWO_PI (2.0 * 3.14159265358979323846264) #endif

# ifndef FALSE #define FALSE 0 #endif #ifndef TRUE #define TRUE 1 #endif #ifndef PI #define PI 3.h14159265358979323846264 #endif #ifndef PI_F #define PI_F 3.1415926535f #endif #ifndef TWO_PI_F #define TWO_PI_F (2.0f * 3.1415926535f) #endif #ifndef PI_2F #define PI_2F (3.1415926535f * 0.5f) #endif #ifndef TWO_PI #define TWO_PI (2.0 * 3.14159265358979323846264) #endif

~~// Global Host Status that the PC Application can specify as it Requests Global Status~~ ~~// to inform KFLOP User threads of its current state. ie Job Actively running~~<~~br /~~span style="color: #0000ff;">~~// up to 32 bits of status can be specified. See~~ #include "PC-DSP.h ~~for normal bit defines~~" // contains common structures shared by PC and DSP ~~extern int volatile HostStatus;~~

// Global Host Status that the PC Application can specify as it Requests Global Status // to inform KFLOP User threads of its current state. ie Job Actively running // up to 32 bits of status can be specified. See PC-DSP.h for normal bit defines extern int volatile HostStatus ~~& HOST_JOB_ACTIVE_BIT)~~;

# define JOB_ACTIVE (HostStatus & HOST_JOB_ACTIVE_BIT)

~~// standard math funtions~~

~~extern float sqrtf (float x);~~<~~br />extern float expf (float x)~~span style="color: #0000ff;~~ ~~extern float logf (float x);<br~~ /~~>extern float log10f(float x);<br~~ /~~>extern float powf (float x, float y);standard math funtions extern float sinf (float x); extern float cosf (float x); extern float tanf (float x); extern float asinf (float x); extern float acosf (float x); extern float atanf (float x); extern float atan2f(float y, float x); extern float fast_fabsf (float y);

extern ~~double sqrt~~ float sqrtf (~~double~~ float x); extern ~~double exp~~ float expf (~~double~~ float x); extern ~~double log~~ float logf (~~double~~ float x); extern ~~double log10~~float log10f(~~double~~ float x); extern ~~double pow~~ float powf (~~double~~ float x, ~~double~~ float y); extern ~~double sin~~ float sinf (~~double~~ float x); extern ~~double cos~~ float cosf (~~double~~ float x); extern ~~double tan~~ float tanf (~~double~~ float x); extern ~~double asin~~ float asinf (~~double~~ float x); extern ~~double acos~~ float acosf (~~double~~ float x); extern ~~double atan~~ float atanf (~~double~~ float x); extern ~~double atan2~~float atan2f(~~double~~ float y, ~~double~~ float x); extern ~~double fast_fabs~~ float fast_fabsf (~~double~~ float y);

extern double sqrt (double x); extern double exp ((volatile unsigned char *double x)~~0x91000000)~~ ;</~~/ Base of FPGA addresses~~span> extern double log (Xdouble x) ; extern double log10(~~FPGA_ADDR[(X)*4+2]~~double x); extern double pow ((volatile unsigned short int *double x, double y)~~0x91000000)~~ ;</~~/ Base of FPGA addresses~~span> extern double sin (Xdouble x) ; extern double cos (~~FPGA_ADDRW[(X)*2+1]~~double x); extern double tan (double x);</~~/ This structure is set to default every time the program runs UNTIL~~span> extern double asin (double x); extern double acos (double x); extern double atan (double x); extern double atan2(double y, ~~so data that was present at the~~double x); extern double fast_fabs (double y);</~~/ time it was flashed will persist~~ span>

#define ~~N_USER_DATA_VARS 200~~FPGA_ADDR ((volatile unsigned char *)0x91000000) // Base of FPGA addresses #define FPGA(X) (FPGA_ADDR[(X)*4+2]) ~~typedef struct~~#define FPGA_ADDRW ((volatile unsigned short int *)0x91000000) // Base of FPGA addresses {#define FPGAW(X) (FPGA_ADDRW[(X)*2+1]) ~~int RunOnStartUp~~ // ~~word Bits 1-7 selects which threads~~ This structure is set to ~~execute on startup~~ default every time the program runs UNTIL ~~unsigned int EntryPoints[N_USER_THREADS]~~// ~~each downloaded~~ the program~~'s entry point~~image has been FLASHED using the FLASH command ~~int UserData[N_USER_DATA_VARS]~~// ~~General purpose way to share and or save user program~~ from then on it will not be cleared, so datathat was present at the ~~} PERSIST~~// time it was flashed will persist

~~extern PERSIST persist~~# define N_USER_DATA_VARS 200 typedef struct { int RunOnStartUp; // word Bits 1-7 selects which threads to execute on startup unsigned int EntryPoints[N_USER_THREADS]; // each downloaded program's entry point int UserData[N_USER_DATA_VARS]; // General purpose way to share and or save user program data } PERSIST;

extern ~~int StatusRequestCounter~~PERSIST persist; / </ ~~increments each time host requests status~~span>

extern int StatusRequestCounter; // ~~data gathering variables~~increments each time host requests status

// data gathering variables

#~~define GATHER_NULL_TYPE 7~~<~~br />~~span style="color: #~~define GATHER_ADC_TYPE 6 #define ~~GATHER_DOUBLE_TYPE 5~~MAX_GATHER_VALUES 32 ~~#define GATHER_FLOAT_TYPE 4 #define GATHER_LASTPWMC_TYPE 3 #define GATHER_LASTPWM_TYPE 2 #define GATHER_INT_TYPE 1 #define GATHER_END_TYPE 0

~~typedef struct //~~ # define ~~a size and address to store~~GATHER_NULL_TYPE 7 { ~~int type; // GATHER_XXXXX_TYPE, 0~~#define GATHER_ADC_TYPE 6 ~~void *addr;~~ ~~} GATHER_VALUE_DEF~~#define GATHER_DOUBLE_TYPE 5 ~~typedef struct~~<~~br /~~span style="color: #0000ff;">{#define GATHER_FLOAT_TYPE 4 ~~double *bufptr; // data gathering buffer pointer~~ ~~double *endptr; // done if bufptr~~ #define GATHER_LASTPWMC_TYPE 3 ~~double Dest~~#define GATHER_LASTPWM_TYPE 2 ~~int Inject~~#define GATHER_INT_TYPE 1 ~~GATHER_VALUE_DEF list[MAX_GATHER_VALUES]~~#define GATHER_END_TYPE 0 ~~} GATHER;~~

~~extern GATHER gather~~typedef struct // define a size and address to store { int type; // GATHER_XXXXX_TYPE, 0=end of list void *addr; } GATHER_VALUE_DEF; typedef struct { double *bufptr; // data gathering buffer pointer double *endptr; // done if bufptr = endptr double Dest; // Save where the injection will be relative to int Inject; // if set, 1st address is to be copied from buffer to the address GATHER_VALUE_DEF list[MAX_GATHER_VALUES]; // list of addresses to gather (null after last value) } GATHER;

extern GATHER gather ~~buffer (number of doubles, 8 bytes each).~~ ; ~~extern double *gather_buffer~~ </~~/ Large buffer for data gathering, Bode plots, or User use~~span>

#define ~~N_CPLX 2048~~MAX_GATHER_DATA 1000000 // Size of gather buffer (number of doubles, 8 bytes each). extern double *gather_buffer; // Large buffer for data gathering, Bode plots, or User use

~~extern float *input~~# define N_CPLX 2048

~~void SetupGatherAllOnAxis(int c, int n_Samples)~~extern float *input; ~~// Prepares to gather info for an axis~~ ~~void TriggerGather(); // starts gathering defined items into gather buffer~~

void SetupGatherAllOnAxis(int c, int n_Samples); // Prepares to gather info for an axis void TriggerGather(); // starts gathering defined items into gather buffer

#define TRAJECTORY_OFF 0 // no trajectory generation #define TRAJECTORY_INDEPENDENT 1 // simple independent axis (3rd order funtion of time) #define TRAJECTORY_LINEAR 2 // linear interpolated from coord system 0 (x = c*p+d) #define TRAJECTORY_CIRCULAR 3 // circular interpolated from coord system 0 (x = c*sin(p*a+b)+d) #define TRAJECTORY_SPECIAL 4 // Special Command to clear/set IO bit // do the operation // 0 = clearbit // 1 = setbit // 2 = wait for bit low // 3 = wait for bit high // 4 = beginning of Rapid // 5 = end of Rapid // param 0 = bit number

#define TRAJECTORY_OFF 0 // no trajectory generation #define TRAJECTORY_INDEPENDENT 1 // simple independent axis (3rd order funtion of time) #define TRAJECTORY_LINEAR 2 // linear interpolated from coord system 0 (x = c*p+d) #define TRAJECTORY_CIRCULAR 3 // circular interpolated from coord system 0 (x = c*sin(p*a+b)+d) #define TRAJECTORY_SPECIAL 4 // Special Command to clear/set IO bit // do the operation // 0 = clearbit // 1 = setbit // 2 = wait for bit low // 3 = wait for bit high // 4 = beginning of Rapid // 5 = end of Rapid // param 0 = bit number

~~ #define TRAJECTORY_EXPONENTIAL 5 // independent axis (exponentially approach Dest a=Ratio per tick, b=Dest)~~

~~#define LAST_MOTION_JOG 0 // type of last independent motion was a jog~~ #define ~~LAST_MOTION_MULTI 2~~ TRAJECTORY_EXPONENTIAL 5 // ~~type of last~~ independent ~~motion was a multi~~ axis ~~move~~ (~~G0 type~~exponentially approach Dest a=Ratio per tick, b=Dest) ~~#define LAST_MOTION_EXP 3 // type of last independent motion was an exponential~~

# <~~br /~~span style="color: #0000ff;">~~typedef struct~~ define LAST_MOTION_JOG 0 // ~~linear (only c and d are used),or sine equation~~type of last independent motion was a jog { ~~double a;~~ <~~br /> double b~~span style="color: #0000ff; ">#define LAST_MOTION_MOVE 1 // type of last independent motion was a move ~~double c;~~ ~~double d~~#define LAST_MOTION_MULTI 2 // ~~always t^0 constant coefficient~~ type of last independent motion was a multi axis move (~~starting position~~G0 type) ~~} TRIP_CIRCLE_LINEAR~~#define LAST_MOTION_EXP 3 // type of last independent motion was an exponential

typedef struct // linear (only c and d are used),or sine equation { double a; double b; double c; double d; // always t^0 constant coefficient (starting position) } ~~TRIP_LINEAR~~TRIP_CIRCLE_LINEAR;

//<~~br /~~span style="color: #0000ff;">typedef struct // ~~Motion structure for a coordinate system~~linear (only c and d are used) // ~~// 3rd order polynomial for the parametric parameter~~ { // ~~// defines a parametric parameter p that varies from 0-~~~~1 over the~~ double c; ~~// segment of motion as a function of time. All the associated axes~~ double d; // ~~derive their~~ always t^0 constant coefficient (starting position ~~from this (either circular or linear~~) } TRIP_LINEAR;</~~/ using either a circular formula or linear formula~~span>

~~typedef struct~~ //>{ ~~char trajectory_mode; // Off, circular, or linear~~ ~~unsigned char x_axis~~// ~~associated x axis / or special command~~ Motion structure for a coordinate system ~~unsigned char y_axis; // associated y axis~~ ~~unsigned char z_axis~~// ~~associated z axis~~ ~~unsigned char a_axis; // associated a axis~~ ~~unsigned char b_axis~~// ~~associated b axis~~3rd order polynomial for the parametric parameter ~~unsigned char c_axis; // associated c axis~~ ~~unsigned char u_axis~~// ~~associated u axis~~ ~~unsigned char v_axis; // associated v axis~~ ~~short int special_param~~// ~~special param~~ defines a parametric parameter p that varies from 0->1 over the ~~double t; // time duration (in sec) of trip state~~ ~~double a~~// ~~t^3 coefficient (Jerk)~~segment of motion as a function of time. All the associated axes ~~double b; // t^2 coefficient (initial acceleration)~~ ~~double c~~// ~~t^1 coefficient~~ derive their position from this (~~initial velocity~~either circular or linear) ~~double d; // t^0 constant coefficient (starting position)~~ ~~TRIP_CIRCLE_LINEAR X,Y;~~<~~br /> TRIP_LINEAR Z,A,B,C,U,V~~span style="color: #0000ff;">// using either a circular formula or linear formula ~~} PARAMETRIC_COEFF;~~

typedef struct { char trajectory_mode; // Off, circular, or linear unsigned char x_axis; // associated x axis / or special command unsigned char y_axis; // associated y axis unsigned char z_axis; // associated z axis unsigned char a_axis; // associated a axis unsigned char b_axis; // associated b axis unsigned char c_axis; // associated c axis unsigned char u_axis; // associated u axis unsigned char v_axis; // associated v axis short int special_param; // special param 0 double t; // time duration (in sec) of trip state double a; // t^3 coefficient (Jerk) double b; // t^2 coefficient (initial acceleration) double c; // t^1 coefficient (initial velocity) double d; // t^0 constant coefficient (starting position) TRIP_CIRCLE_LINEAR X,Y; TRIP_LINEAR Z,A,B,C,U,V; } PARAMETRIC_COEFF;

typedef struct // 3rd order polynomial for a single trip state { int trajectory_mode; double t; // time duration (in sec) of trip state double a; // t^3 coefficient (Jerk) double b; // t^2 coefficient (initial acceleration) double c; // t^1 coefficient (initial velocity) double d; // t^0 constant coefficient (starting position) } TRIP_COEFF; typedef struct // 2nd order IIR Filter { float A1; // output coefficient Z-1 float A2; // output coefficient Z-2 float B0; // input coefficient Z-0 float B1; // input coefficient Z-1 float B2; // input coefficient Z-2 float d0,d1; // delay values } IIR;

typedef struct / ~~MOTION TRAJECTORY STRUCTURES~~/ 3rd order polynomial for a single trip state { int trajectory_mode; ~~extern~~ double ~~CS0_t~~t; // ~~Current Coordinated Motion Segment Times~~time duration (in sec) of trip state ~~extern~~ double ~~CS0_TimeExecuted~~a; // ~~Sum of all previous Coordinated Motion Segments Executed~~t^3 coefficient (Jerk) ~~extern~~ double ~~CS0_TimeDownloaded~~b; // ~~Sum of all Coord Motion Segments downloaded from Host~~t^2 coefficient (initial acceleration) ~~extern double CS0_TimeLost~~ double c; // ~~Sum of all Coord Motion Segments downloaded from Host that have been discarded~~ t^1 coefficient (~~buffer wrap~~initial velocity) ~~extern~~ double ~~CS0_TimeBase~~d; // ~~how much coordinated motion is advanced each tick~~t^0 constant coefficient (starting position) ~~extern double CS0_TimeBaseDelta~~} TRIP_COEFF; ~~extern~~ typedef struct // 2nd order IIR Filter { float ~~CS0_DecelTime~~A1; // output coefficient Z-1 float A2; // ~~how long to take to stop the coordinated motion (computed by StopMotion)~~output coefficient Z-2 ~~extern double CS0_TimeBaseDesired~~ float B0; // ~~Last Desired rate~~input coefficient Z-of0 float B1; // input coefficient Z-~~time (TIMEBASE~~ 1 float B2; // input coefficient Z-2 float d0,d1; // delay values } IIR;

// MOTION TRAJECTORY STRUCTURES extern ~~BOOL CS0_DoingRapid~~double CS0_t; // ~~Flag indicating Rapid in Progress so use normal Time Base ignoring FRO~~ Current Coordinated Motion Segment Times extern double CS0_TimeExecuted; // Sum of all previous Coordinated Motion Segments Executed extern double CS0_TimeDownloaded; // Sum of all Coord Motion Segments downloaded from Host extern double CS0_TimeLost; // Sum of all Coord Motion Segments downloaded from Host that have been discarded (~~except for FeedHold~~buffer wrap) extern ~~BOOL CS0_Flushed~~double CS0_TimeBase; // ~~Coordinated~~ how much coordinated motion ~~Terminated so no longer necessary to worry about starvation~~ is advanced each tick extern ~~BOOL CS0_HoldAtEnd~~double CS0_TimeBaseDelta; // ~~Coordinated~~ max amount coordinated motion time base is changed per tick extern float CS0_DecelTime; // how long to ~~not Terminate but rather Hold when reaching end~~ take to stop the coordinated motion (computed by StopMotion) extern double CS0_TimeBaseDesired; // Last Desired rate-of ~~buffer~~ -time (TIMEBASE = real time)

extern ~~float CS0_NomDecel2TB2~~BOOL CS0_DoingRapid; // ~~Nominal Decel~~ Flag indicating Rapid in Progress so use normal Time/Base ignoring FRO (~~2 TIMEBASE^2~~except for FeedHold) extern BOOL CS0_Flushed; // Coordinated motion Terminated so no longer necessary to ~~relate buffer time to TimeBase~~ worry about starvation extern BOOL CS0_HoldAtEnd; // Coordinated motion to ~~be able to stop~~not Terminate but rather Hold when reaching end of buffer

~~extern int CS0_StoppingState; // emergency stop in progress, 0~~ extern PARAMETRIC_COEFF *CoordSystem0~~"color: #0000ff; ~~// current pointer into Coordinated Motion extern ~~PARAMETRIC_COEFF *LastCoordSystem0~~float CS0_NomDecel2TB2;~~<br~~ /~~>extern int ParametricIndex;~~ /Nominal Decel Time/ ~~Index of where~~ (2 TIMEBASE^2) = Factor to ~~put next downloaded Coord Motion Segment or command extern BOOL ParametricIndexWrapped; // Indicates that Coord Motion Buffer has wrapped and additional segments will cause segments~~ relate buffer time to TimeBase to be ~~lost extern PARAMETRIC_COEFF *ParametricCoeffs; // Points~~ able to ~~beginning of Coord Motion Buffer~~stop extern PARAMETRIC_COEFF *ParametricCoeffsEnd; // Points to End+1 of Allocated Coord Motion Buffer (MAX_SEGMENTS) extern PARAMETRIC_COEFF *LastCoordSystem0; // Pointer to last Segment executed when finished extern PARAMETRIC_COEFF *LastValidTrajSegment; // Last Segment actually Executed

~~void StopCoordinatedMotion(void)~~extern int CS0_StoppingState; // ~~bring any coordinated motion to a~~ emergency stop ~~ASAP~~in progress, 0 = not stopping, 1=stopping coord motion, 2=stopping indep, 3=fully stopped, 4=ind stopped ~~void ResumeCoordinatedMotion(void); // resume coordinated/Indep motion after an emergency stop~~ ~~void ClearStopImmediately(void)~~extern PARAMETRIC_COEFF *CoordSystem0; // ~~Clear Stop Condition without resuming~~current pointer into Coordinated Motion ~~void UpdateStoppingState(void); // Update Stopping Status (only required for indep stopping)~~ ~~float GetNominalFROChangeTime(void)~~extern PARAMETRIC_COEFF *LastCoordSystem0;</~~/ computed time to change from FRO 1.0 to 0.0 for all defined CoordSystem Axes and their specified Vel, Accel, jerk~~span> ~~void SetFRO(float FRO)~~extern int ParametricIndex; // ~~change from current~~ Index of where to ~~the specified FRO (FRO=1.0=Realtime)using a nominal rate based on computed time to change from 1.0 to 0.0~~put next downloaded Coord Motion Segment or command ~~void SetRapidFRO(float FRO); // change from current to the specified Rapid FRO (FRO=1.0=Realtime)using a nominal rate based on computed time to change from 1.0 to 0.0~~ ~~void SetFROTemp(float FRO)~~extern BOOL ParametricIndexWrapped; // ~~Temporarily change from current~~ Indicates that Coord Motion Buffer has wrapped and additional segments will cause segments to ~~the specified FRO using a nominal rate, override FeedHold, don't save as LastFRO~~ be lost ~~void SetFROwRate(float FRO, float DecelTime)~~extern PARAMETRIC_COEFF *ParametricCoeffs; // ~~change from current~~ Points to ~~the specified FRO (FRO=1.0=Realtime)using a rate based on caller specified time to change from 1.0 to 0.0~~beginning of Coord Motion Buffer ~~void SetRapidFROwRate(float FRO, float DecelTime)~~extern PARAMETRIC_COEFF *ParametricCoeffsEnd; // ~~change from current~~ Points to ~~the specified Rapid FRO~~ End+1 of Allocated Coord Motion Buffer (~~FRO=1.0=Realtime~~MAX_SEGMENTS)~~using a rate based on caller specified time to change from 1.0 to 0.0~~ ~~void SetFROwRateTemp(float FRO, float DecelTime)~~extern PARAMETRIC_COEFF *LastCoordSystem0; // ~~Temporarily change from current~~ Pointer to ~~the specified FRO using a rate based on caller specified time, override FeedHold, don't save as LastFRO~~last Segment executed when finished extern ~~float CS0_LastFRO~~PARAMETRIC_COEFF *LastValidTrajSegment; // Last ~~Desired FRO (used for Resume after FeedHold or for changes in FRO while in FeedHold)~~ Segment actually Executed ~~extern float CS0_LastRapidFRO; // Last Desired FRO (used for Resume after FeedHold during Rapid)~~

void StopCoordinatedMotion(void); // ~~Called after adding something~~ bring any coordinated motion to ~~the Cood Motion Buffer.~~a emergency stop ASAP void ResumeCoordinatedMotion(void); ~~Increments the Coord Motion Buffer pointer~~ // resume coordinated/Indep motion after an emergency stop void ClearStopImmediately(void); // ~~while keeping track of how much time is currently in the buffer~~ Clear Stop Condition without resuming void UpdateStoppingState(~~CS0_TimeDownloaded~~void); // Update Stopping Status (only required for indep stopping) float GetNominalFROChangeTime(void);// computed time to change from FRO 1.0 to 0.0 for all defined CoordSystem Axes and their specified Vel, ~~also how much~~ Accel, jerk void SetFRO(float FRO); // ~~was over written due~~ change from current to ~~buffer wrapping~~ the specified FRO (~~CS0_TimeLost~~FRO=1.0=Realtime) using a nominal rate based on computed time to ~~be able~~ change from 1.0 to 0.0 void SetRapidFRO(float FRO); // change from current to ~~determine~~ the ~~extent that it is~~ specified Rapid FRO (FRO=1.0=Realtime)using a nominal rate based on computed time to change from 1.0 to 0.0 void SetFROTemp(float FRO); // ~~possible~~ Temporarily change from current to ~~reverse~~the specified FRO using a nominal rate, ~~and keep~~ override FeedHold, don't save as LastFRO void SetFROwRate(float FRO, float DecelTime); // change from current to the ~~buffer terminated with TRAJECTORY_OFF~~specified FRO (FRO=1.0=Realtime)using a rate based on caller specified time to change from 1.0 to 0.0 void ~~IncParametricIndex~~SetRapidFROwRate(float FRO, float DecelTime); // change from current to the specified Rapid FRO (FRO=1.0=Realtime)using a rate based on caller specified time to change from 1.0 to 0.0 voidSetFROwRateTemp(float FRO, float DecelTime);// Temporarily change from current to the specified FRO using a rate based on caller specified time, override FeedHold, don't save as LastFRO extern float CS0_LastFRO; // Last Desired FRO (used for Resume after FeedHold or for changes in FRO while in FeedHold) extern float CS0_LastRapidFRO; // Last Desired FRO (used for Resume after FeedHold during Rapid)

// Called after adding something to the Cood Motion Buffer. Increments the Coord Motion Buffer pointer // ~~max trip states for individual axis moves~~while keeping track of how much time is currently in the buffer (CS0_TimeDownloaded), also how much ~~extern TRIP_COEFF TripCoeffs[N_CHANNELS][MAX_TRIP]~~// ~~Trip Coeff lists for each channel~~was over written due to buffer wrapping (CS0_TimeLost) to be able to determine the extent that it is // possible to reverse, and keep the buffer terminated with TRAJECTORY_OFF void IncParametricIndex(void);

#define MAX_TRIP 20 / ~~Limit Switch Options~~/ max trip states for individual axis moves extern TRIP_COEFF TripCoeffs[N_CHANNELS][MAX_TRIP]; // Trip Coeff lists for each channel

~~// Bit 0 1=Stop Motor on Neg Limit, 0=Ignore Neg limit~~<~~br />// Bit 1 1~~span style=~~Stop Motor on Pos Limit, 0=Ignore Pos limit // ~~Bit 2 Neg~~ Limit ~~Polarity 0=stop on high, 1=stop on lowSwitch Options // Bit 3 Pos Limit Polarity 0=stop on high, 1=stop on low // // Bits 4-7 Action - 0 Kill Motor Drive // 1 Disallow drive in direction of limit // 2 Stop movement // // Bit 8=use Extended Limit Bit Numbers (LimitNegSwitchBit,LimitPosSwitchBit) // // (for legacy support allow packed 8-bit numbers) // Bits 16-23 Neg Limit I/O Bit number // Bits 24-31 Pos Limit I/O Bit number

// Bit 0 1=Stop Motor on Neg Limit, 0=Ignore Neg limit // Bit 1 1=Stop Motor on Pos Limit, 0=Ignore Pos limit // Bit 2 Neg Limit Polarity 0=stop on high, 1=stop on low // Bit 3 Pos Limit Polarity 0=stop on high, 1=stop on low // // Bits 4-7 Action - 0 Kill Motor Drive // 1 Disallow drive in direction of limit // 2 Stop movement // // Bit 8=use Extended Limit Bit Numbers (LimitNegSwitchBit,LimitPosSwitchBit) // // (for legacy support allow packed 8-bit numbers) // Bits 16-23 Neg Limit I/O Bit number // Bits 24-31 Pos Limit I/O Bit number

~~ // M A I N S T R U C T U R E T H A T D E F I N E S A N A X I S~~

~~typedef struct~~ { int ChanNumber; // channel number 0-3 int Enable; // enables feedback int InputMode; // sets position input mode (See Axis Input Modes) int OutputMode; // sets servo/motor mode (See Axis Output Modes) int LimitSwitchOptions; // see above for description int LimitSwitchNegBit; // Neg Limit I/O Bit number int LimitSwitchPosBit; // Pos Limit I/O Bit number int MasterAxis; // -1 if none, else master axis channel to slave to double SlaveGain; // Multiplicative Factor for slave motion double MaxFollowingError; // Kill motor if error exceeds this value double LastFollowingError; // Last Measured Following Error double t; // current time in secs within the trip state double Dest; // current dest position for servo double UnfilteredDest; // unfiltered current dest position for servo (before CM smoothing) double DestOffset; // Additional offset to position (used by Injection) float Vel; // max velocity for the move trajectory float Accel; // max Acceleration for the move trajectory float Jerk; // max Jerk (rate of change of Accel) for the move float FFAccel; // Acceleration feed forward float FFVel; // Velocity feed forward double Position; // encoder, ADC, Resolver, reading double invDistPerCycle; // for stepper distance for one complete cycle (4 full steps) // for brushless 3-4 phase encoder counts for one complete cycle // (saved as reciprical for speed) float StepperAmplitude; // Microstepper Amplitude in PWM counts to apply (moving slow, without lead comp) float Output; // Value output to PWM or DAC or CL Stepper offset float prev_output; // previous Output so Slave can track Master when in CL Stepper float Lead; // Lead compensation to correct for step motor inductance TRIP_COEFF *pcoeff; // pointer to coeff that interrupt routine uses, NULL if done double last_position; // last measured error double last_dest; // last destination from beginning of prev servo interrupt double prev_dest; // prev destination from end of prev servo interrupt (will incl User changes to Dest) int LastNonZeroDir; // Last direction we actually moved some amount(+1span style=~~Positive, 0=undefined, -1=negative) int DirectionOfMotion~~"color: #0000ff; ~~// Dest change was in this direction (+1=Positive, 0=none, -1=negative) ~~float last_vel;~~ // ~~last destination velocity float x1last,x2last; // used with lead compensation int OutputChan0,OutputChan1;~~ // pwm or DAC channels to use int InputChan0,InputChan1; // Encoder or ADC channels to use float InputOffset0,InputGain0; // offsets and gains for Resolver Input 0,1 (x'=ax+b) float InputOffset1,InputGain1; // or for ADC, or (InputGain0=-1 reverses encoder) float OutputGain; // Scale or Reverse Output Magnitude or Direction float OutputOffset; // Offset the output float CommutationOffset; // 3 or 4 phase commutation offset, PhaseA = sin((Position+CommutationOffset)*invDistPerCycle) float last_theta; // last resolver theta reading float theta_correction; // resolver correction offset to correct for nonlinearities signed char last_enc; // last fpga encoder reading float P,M A I,N S T R U C T U R E T H A T D~~; // pid gain valuesE F I N E S A N A X I S float MaxI; // max integrator windup float MaxErr; // error saturates at this value float integrator; // current integrator vlue float MaxOutput; // max allowed servo output float DeadBandRange; // Range about zero where gain change occurs float DeadBandGain; // Additional gain within DeadBand Range int LastMotionType; // Type of last move - used in Immediate Stop/Resume double LastMotionDest; // Where last move was to go - used in Immediate Stop/Resume float ExpMotionVc; // Velocity point on exp curve where Max Accel is obtained float ExpMotionXc; // Distance point on exponential curve where Max Accel is obtained float SoftLimitNeg; // Negative Soft Limit (counts) float SoftLimitPos; // Positive Soft Limit (counts) int BacklashMode; // Type of correction: Currently only BACKLASH_OFF, BACKLASH_LINEAR float BacklashAmount; // Amount of Backlash to be applied float BacklashRate; // Rate Backlash shoule be applied, counts/sec int BacklashDirection; // Last non zero direction moved float PrevBacklashDest; // Prev Destination where backlash was determined to allow small hysteresis float Backlash; // current amount of compensation being applied

typedef struct { int ChanNumber; // channel number 0-3 int Enable; // enables feedback int InputMode; // sets position input mode (See Axis Input Modes) int OutputMode; // sets servo/motor mode (See Axis Output Modes) int LimitSwitchOptions; // see above for description int LimitSwitchNegBit; // Neg Limit I/O Bit number int LimitSwitchPosBit; // Pos Limit I/O Bit number int MasterAxis; // -1 if none, else master axis channel to slave to double SlaveGain; // Multiplicative Factor for slave motion double MaxFollowingError; // Kill motor if error exceeds this value double LastFollowingError; // Last Measured Following Error double t; // current time in secs within the trip state double Dest; // current dest position for servo double UnfilteredDest; // unfiltered current dest position for servo (before CM smoothing) double DestOffset; // Additional offset to position (used by Injection) float Vel; // max velocity for the move trajectory float Accel; // max Acceleration for the move trajectory float Jerk; // max Jerk (rate of change of Accel) for the move float FFAccel; // Acceleration feed forward float FFVel; // Velocity feed forward double Position; // encoder, ADC, Resolver, reading double invDistPerCycle; // for stepper distance for one complete cycle (4 full steps) // for brushless 3-4 phase encoder counts for one complete cycle // (saved as reciprical for speed) float StepperAmplitude; // Microstepper Amplitude in PWM counts to apply (moving slow, without lead comp) float Output; // Value output to PWM or DAC or CL Stepper offset float prev_output; // previous Output so Slave can track Master when in CL Stepper float Lead; // Lead compensation to correct for step motor inductance TRIP_COEFF *cpcoeff; // pointer to coeff that interrupt routine uses, NULL if done double last_position; // last measured error double last_dest; // last destination from beginning of prev servo interrupt double prev_dest; // prev destination from end of prev servo interrupt (will incl User changes to Dest) int LastNonZeroDir; // Last direction we actually moved some amount(+1=Positive, 0=undefined, -1=negative) int DirectionOfMotion; // Dest change was in this direction (+1=Positive, 0=none, -1=negative) float last_vel; // last destination velocity float x1last,x2last; // used with lead compensation int OutputChan0,OutputChan1; // ~~move profile polynomial coefficients list~~ pwm or DAC channels to use int InputChan0,InputChan1; // Encoder or ADC channels to use float InputOffset0,InputGain0; // offsets and gains for Resolver Input 0,1 (~~up tp MAX_TRIP~~x'=ax+b) ~~IIR iir[N_IIR_FILTERS]~~float InputOffset1,InputGain1; // or for ADC, or (InputGain0=-1 reverses encoder) float OutputGain; // Scale or Reverse Output Magnitude or Direction float OutputOffset; // Offset the output float CommutationOffset; // 3 or 4 phase commutation offset, PhaseA = sin((Position+CommutationOffset)*invDistPerCycle) float last_theta; // last resolver theta reading float theta_correction; // ~~several IIR filters~~resolver correction offset to correct for nonlinearities ~~}CHAN~~ signed char last_enc; // last fpga encoder reading float P,I,D; // pid gain values float MaxI; // max integrator windup float MaxErr; // error saturates at this value float integrator; // current integrator vlue float MaxOutput; // max allowed servo output float DeadBandRange; // Range about zero where gain change occurs float DeadBandGain; // Additional gain within DeadBand Range int LastMotionType; // Type of last move - used in Immediate Stop/Resume double LastMotionDest; // Where last move was to go - used in Immediate Stop/Resume float ExpMotionVc; // Velocity point on exp curve where Max Accel is obtained float ExpMotionXc; // Distance point on exponential curve where Max Accel is obtained float SoftLimitNeg; // Negative Soft Limit (counts) float SoftLimitPos; // Positive Soft Limit (counts) int BacklashMode; // Type of correction: Currently only BACKLASH_OFF, BACKLASH_LINEAR float BacklashAmount; // Amount of Backlash to be applied float BacklashRate; // Rate Backlash shoule be applied, counts/sec int BacklashDirection; // Last non zero direction moved float PrevBacklashDest; // Prev Destination where backlash was determined to allow small hysteresis float Backlash; // current amount of compensation being applied

TRIP_COEFF *c; // ~~continuously sent by DMA to DACs~~move profile polynomial coefficients list (up tp MAX_TRIP) ~~extern short int DAC_Buffer~~ IIR iir[~~N_DACS~~N_IIR_FILTERS]; // ~~format 12 bits data~~ several IIR filters ~~#define DAC(ch, v) DAC_Buffer[ch]~~}CHAN;</~~/ set DAC channel to value (range -2048/+2047)~~span>

// continuously sent by DMA to DACs extern short int ~~ADC_BufferIn~~DAC_Buffer[~~N_ADCS~~N_DACS]; // ~~format~~ format 12 bits data #define ~~ADC~~DAC(ch, v) ~~(ADC_BufferIn~~DAC_Buffer[ch]=((v-2048) &0xfff) // ~~return ADC reading of specified~~ set DAC channel to value (range -2048/+2047)~~extern int ADC_BufferIn[N_ADCS]; /~~</ ~~format 4-dummy bits 12 bits data 16 dummy~~span>

extern int ~~ADC_BufferInSnap~~ADC_BufferIn[~~2*N_ADCS_SNAP~~N_ADCS]; // ~~Snap Amp Current~~ format 12 bits data #define ADC ~~format 16~~(ch) (ADC_BufferIn[ch]-2048) // return ADC reading of specified channel (range -2048/2047)extern int ADC_BufferIn[N_ADCS]; // format 4-dummy bits 12 bits data16 dummy

~~#define FULL_RANGE_CURRENT 4.85f~~<~~br />~~span style="color: #~~define MeasuredAxisAmps(axis) ((ADC(axis+4)+2048)~~0000ff;">extern int ADC_BufferInSnap[2*~~(FULL_RANGE_CURRENT~~N_ADCS_SNAP]; //~~4096.0f))~~ Snap Amp Current ADC format 16-bits data</~~/ returns measured current in an axis (Amperes)~~span>

# define FULL_RANGE_CURRENT 4.85f #define MeasuredAxisAmps(axis) ((ADC(axis+4)+2048)*(FULL_RANGE_CURRENT/4096.0f)) // returns measured current in an axis (Amperes)

~~void WritePWMR(int ch, int v);~~ // ~~Write to~~ On board Power Amp PWM ~~- Recirculate mode (+ or - power then shorted)~~control ~~#define MAX_PWM_VALUE 230 // Max value for PWMs in antiphase mode void WritePWM(int ch, int v); // Write to PWM - locked anti-phase mode (+ power then - power)~~

#define ~~MAX_PWMC_VALUE 1000~~ MAX_PWMR_VALUE 400 // Max value for PWMs in ~~Current Mode~~ Recirculate mode void WritePWMR(~~SnapAmps only~~int ch, int v); // Write to PWM - Recirculate mode (+ or - power then shorted) #define MAX_PWM_VALUE 230 // Max value for PWMs in antiphase mode void ~~WritePWMC~~WritePWM(int ch, int v); // Write to PWM - ~~Current Loop~~ locked anti-phase mode (+ power then - ~~Always optimal decay~~power)

~~extern int SnapAmpPresent~~# define MAX_PWMC_VALUE 1000 // ~~1 = SnapAmp Present 0= Not Present~~Max value for PWMs in Current Mode (SnapAmps only) ~~extern int DisableSnapAmpDetectOnBoot; // disables using Bits 12,13, and 15 on JP7 detect AutoDetect SnapAmps~~ void ~~WriteSnapAmp~~WritePWMC(int ~~add~~ch, int ~~data~~v); // ~~write a 16~~Write to PWM -~~bit word directly to SnapAmp FPGA~~ Current Loop mode - Always optimal decay ~~int ReadSnapAmp(int add); // read a 16-bit word directly from SnapAmp FPGA~~

extern int SnapAmpPresent; // 1 = SnapAmp Present 0= Not Present extern int DisableSnapAmpDetectOnBoot; // ~~Digital I~~disables using Bits 12,13, and 15 on JP7 detect AutoDetect SnapAmps</~~O bit PWM control~~ span> void WriteSnapAmp(~~8 I~~int add, int data); /~~O bits on KFlop JP6 may be pulsed~~/ write a 16-bit word directly to SnapAmp FPGA int ReadSnapAmp(int add); // read a 16-bit word directly from SnapAmp FPGA

~~#define N_IO_PWMS 8 // Number of pwms that may be assigned to GPIO bits~~ // ~~FPGA offset to IO~~ Digital I/O bit PWM ~~registers~~ control (~~2 bytes each - value, enable(bit0)~~8 I/O bits on KFlop JP6 may be pulsed) ~~#define IO_PWMS_PRESCALE 0x2f // FPGA offset to IO PWM Pre-Scale clock divider 0-255, 0 = 16.6MHz, 1=8.33MHz, ... #define IO_PWM_MAX_VALUE 255 // 0 = 0%, 255 = 100 % duty cycle~~

# define N_IO_PWMS 8 // ~~addr~~ Number of pwms that may be assigned to rGPIO bits </~~w encoder noise rejection filter value (0..255),~~ span> #define IO_PWMS 0xD0 // ~~Bit8 switches Encoders Ch4-7 from JP5~~ FPGA offset to ~~JP6~~IO PWM registers (2 bytes each - value, enable(bit0)) ~~// Bit9 switches Encoders Ch0-3 from JP7 to JP4~~ #define ~~ENC_0_3_JP4 0x200~~IO_PWMS_PRESCALE 0x2f // FPGA offset to IO PWM Pre-Scale clock divider 0-255, 0 = 16.6MHz, 1=8.33MHz, ... ~~#define ENC_4_7_JP6 0x100~~ #define ~~ENC_NOISE_FILTER_DEFAULT_VAL 7~~ IO_PWM_MAX_VALUE 255 // ~~noise rejection filter default value (100MHz/3/7/2~~ 0 = ~~2MHz)~~0%, 255 = 100 % duty cycle

// addr to r/w encoder noise rejection filter value (0..255), // ~~encoder sudden change by 2 error address~~Bit8 switches Encoders Ch4-7 from JP5 to JP6, // ~~encoder sudden change by 2 error bit for encoder 0~~Bit9 switches Encoders Ch0-3 from JP7 to JP4 #define ~~ENC_NOISE_ERR_BIT1 5 /~~ENC_NOISE_FILTER_ADD 0x05 </ ~~encoder sudden change by 2 error bit for encoder 1~~span> #define ~~ENC_NOISE_ERR_BIT2 6~~ ENC_0_3_JP4 0x200 #define ENC_4_7_JP6 0x100 #define ~~ENC_NOISE_ERR_BIT3~~ ENC_NOISE_FILTER_DEFAULT_VAL 7 // ~~encoder sudden change by 2 error bit for encoder~~ noise rejection filter default value (100MHz/3/7/2 = 2MHz)

#define ENC_NOISE_ERR_ADD 0x08 // encoder sudden change by 2 error address #define ENC_NOISE_ERR_BIT0 4 // encoder sudden change by 2 error bit for encoder 0 #define ENC_NOISE_ERR_BIT1 5 // encoder sudden change by 2 error bit for encoder 1 #define ENC_NOISE_ERR_BIT2 6 // encoder sudden change by 2 error bit for encoder 2 #define ENC_NOISE_ERR_BIT3 7 // encoder sudden change by 2 error bit for encoder 3

~~// FPGA Step and Direction Frequency Generators (8) are available // // #define NSTEPDIR 8~~

~~// address of 6 bit pulse length 0-63~~// FPGA Step and Direction Frequency Generators (8) are available // ~~bit6 muxes generators 0-3 from JP7 to JP4 and JP6,~~ // ~~bit7 reverses polarity (0=pulses low & Pos Dir high, 1=pulses high & Pos Dir Low)~~ #define ~~STEP_PULSE_LENGTH_ADD 0x06~~NSTEPDIR 8

// ~~default~~ address of 6 bit pulse length ~~of ~ 2us~~0-63= # 16.666MHz clocks, // bit6 muxes generators 0-3 from JP7 to JP4 and JP6, // bit7 reverses polarity (0=pulses low & Pos Dir high, 1=pulses high & Pos Dir Low) #define STEP_PULSE_LENGTH_ADD 0x06

#~~define STEP_RATE_ADD 0x3c // write a 32 bit word - Bit31~~~~"color: #~~define STEP_POSITION_ADD0 0x40 // read a 16 bit word - step count0 - 9 bits signed position and 7 bits of fraction #define ~~STEP_POSITION_ADD1 0x42~~ STEP_PULSE_LENGTH_DEFAULT 32 // ~~read a 16 bit word - step count1 - 9 bits signed position and 7 bits~~ default pulse length of ~~fraction~~~ 2us #define STEP_POSITION_ADD2 0x44 // read a 16 bit word - step count2 - 9 bits signed position and 7 bits of fraction #define STEP_POSITION_ADD3 0x46 // read a 16 bit word - step count3 - 9 bits signed position and 7 bits of fraction #define STEP_POSITION_ADD4 0x48 // read a 16 bit word - step count4 - 9 bits signed position and 7 bits of fraction #define STEP_POSITION_ADD5 0x4a // read a 16 bit word - step count5 - 9 bits signed position and 7 bits of fraction #define STEP_POSITION_ADD6 0x4c // read a 16 bit word - step count6 - 9 bits signed position and 7 bits of fraction #define STEP_POSITION_ADD7 0x4e // read a 16 bit word - step count7 - 9 bits signed position and 7 bits of fraction

# define STEP_RATE_ADD 0x3c // write a 32 bit word - Bit31=enable, Bit27=Drive, Bits24-26=chan, 0-23= signed fraction of 16.666MHz ~~extern int KanalogPresent~~#define STEP_POSITION_ADD0 0x40 // 1read a 16 bit word - step count0 - 9 bits signed position and 7 bits of fraction #define STEP_POSITION_ADD1 0x42 // read a 16 bit word - step count1 - 9 bits signed position and 7 bits of fraction ~~extern int DisableKanalogDetectOnBoot~~#define STEP_POSITION_ADD2 0x44 // ~~disables using Bits~~ read a 16bit word -20 step count2 - 9 bits signed position and ~~23 on JP4 to detect AutoDetect Kanalog~~7 bits of fraction #define STEP_POSITION_ADD3 0x46 // read a 16 bit word - step count3 - 9 bits signed position and 7 bits of fraction #define STEP_POSITION_ADD4 0x48 // read a 16 bit word - step count4 - 9 bits signed position and 7 bits of fraction #define STEP_POSITION_ADD5 0x4a // read a 16 bit word - step count5 - 9 bits signed position and 7 bits of fraction #define STEP_POSITION_ADD6 0x4c // read a 16 bit word - step count6 - 9 bits signed position and 7 bits of fraction #define STEP_POSITION_ADD7 0x4e // read a 16 bit word - step count7 - 9 bits signed position and 7 bits of fraction

extern int ~~KStepPresent~~KanalogPresent; // 1=~~KStep~~ Kanalog Present extern int DisableKanalogDetectOnBoot; // disables using Bits 16- ~~set this~~ 20 and 23 on JP4 to ~~mux inputs into virtual bits 48-63~~detect AutoDetect Kanalog

~~// Kanalog FPGA Registers for internal use only~~<~~br />~~span style="color: #~~define KAN_TRIG_REG 0xA0 // triggers a transfer to/from Kanalog, 1-enables Kanalog, 2-enables RS232, 3-both ~~#define KAN_DAC_REGS 0x80 // 8 - 12 bit r/w regs #define KAN_FET_OPTO 0x88~~ extern int KStepPresent; // 1 =KStep Present - ~~16 bit 15~~set this to mux inputs into virtual bits 48-~~8 FET drivers, 7-0 Opto Outputs63 #define KAN_GPOUT 0x89 // 1 - 8 bit 7-0 GP 3.3V OUTPUTS #define KAN_ADC_REGS 0x90 // 8 - 12 bit r/w regs #define KAN_OPTOIN_GPIN 0x98 // 1 - 16 bit 15-8 OptoInputs, 7-0 GP 3.3V inputs

// Kanalog ~~IO Bit numbers~~FPGA Registers for internal use only #define ~~KAN_INPUTS 128~~ KAN_TRIG_REG 0xA0 // ~~16 Bits 128~~triggers a transfer to/from Kanalog, 1-~~143 (128~~enables Kanalog, 2-~~135 GPIN~~enables RS232, ~~136~~3-~~143 Opto in)~~both #define ~~KAN_NINPUTS 16~~ KAN_DAC_REGS 0x80 // ~~16 Input Bits~~8 - 12 bit r/w regs #define ~~KAN_OUTPUTS 144~~ KAN_FET_OPTO 0x88 // ~~24 Bits 144~~1 -~~167 (144~~16 bit 15-~~151 Opto out~~8 FET drivers, ~~152~~7-~~159 FET~~0 Opto Outputs</~~Relay Drivers, 160~~span> #define KAN_GPOUT 0x89 // 1 -~~167 GPOUT)~~8 bit 7-0 GP 3.3V OUTPUTS #define ~~KAN_NOUTPUTS 24~~ KAN_ADC_REGS 0x90 // ~~24 output Bits~~8 - 12 bit r/w regs #define KAN_OPTOIN_GPIN 0x98 // 1 - 16 bit 15-8 OptoInputs, 7-0 GP 3.3V inputs

// Kanalog IO Bit numbers #define KAN_INPUTS 128 // 16 Bits 128-143 (128-135 GPIN, 136-143 Opto in) #define KAN_NINPUTS 16 // 16 Input Bits #define KAN_OUTPUTS 144 // 24 Bits 144-167 (144-151 Opto out, 152-159 FET/Relay Drivers, 160-167 GPOUT) #define KAN_NOUTPUTS 24 // 24 output Bits

// 3 Phase manual control. Angle is specified in cycles. // cycles is a double precision value an may be a very // large number. Only the fractional part will be used. #define MAXV 230.0f // Max allowed 3 phase vector (512/2/sin(60) - EOFF*4) void Write3PH(CHAN *ch0, float v, double angle_in_cycles); // put a voltage v on a 3 Phase motor at specified commutation angle void Write4PH(CHAN *ch0, float v, double angle_in_cycles); // put a voltage v on a 4 Phase motor at specified commutation angle

// 3 Phase manual control. Angle is specified in cycles. ~~extern int LastPWM[N_PWMS+~~// cycles is a double precision value an may be a very // large number. Only the fractional part will be used. #define MAXV 230.0f // Max allowed 3 phase vector (512/2/sin(60) - EOFF*~~N_PWMS_SNAP]~~4) void Write3PH(CHAN *ch0, float v, double angle_in_cycles); // +put a voltage v on a 3 Phase motor at specified commutation angle</~~- 255 counts~~span> void Write4PH(CHAN *ch0, float v, double angle_in_cycles); // put a voltage v on a 4 Phase motor at specified commutation angle

~~int ReadADC(int ch); // User Programs should use ADC() command instead~~ ~~void WriteDAC(int ch,~~ extern int v)LastPWM[N_PWMS+2*N_PWMS_SNAP]; // ~~User Programs should use DAC() command instead~~+/- 255 counts

int ReadADC(int ch); // User Programs should use ADC() command instead void WriteDAC(int ch, int v); // User Programs should use DAC() command instead

~~// S P I N D L E A N D T H R E A D I N G S U P P O R T~~

// ~~main Spindle data structure which maintains Spindle~~ S P I N D L E A N D T H R E A D I N G S U P P O R T ~~// Position Info and threading control~~

~~typedef struct~~ { double Position; // position in revs double StartPosition; // position in revs to begin threading double LastUpdatePosition; // last position in revs where speed was computed double RevsPerCount; // inverse of counts/rev double UpdateTick; // which servo tic we should calc RPM double DeltaTicks; // span style="color: # ~~Servo tics between speed measurement double AdjTimeFilt~~0000ff; ~~// Lead Adjusted, filtered, time ~~double LastCSTime; // Previous Coordinate System Time double *pEncoderPos;~~ // ~~pointer to~~ main Spindle ~~Position double K; // Tau low pass filter coefficient float TrueSpeedRPS; // last measured speed float InvBaseSpeedRPS; // Reciprocal of Base speed of~~ data structure which ~~trajectory was planned~~maintains Spindle ~~double InvBaseSpeedRPSK1; // InvBaseSpeedRPS * (1-K)~~ ~~float InvUpdateTime; // Reciprocal of update time to avoid division~~<~~br /> float Tau~~span style="color: #0000ff; ~~// Time constant for spindle filtering ~~int Type;~~ // ~~Type=0 None, Type=1 uses encoder to measure spindle position~~Position Info and threading control ~~int ThreadingActive; // True when threading is in progress~~

~~} SPINDLE~~typedef struct { double Position; // position in revs double StartPosition; // position in revs to begin threading double LastUpdatePosition; // last position in revs where speed was computed double RevsPerCount; // inverse of counts/rev double UpdateTick; // which servo tic we should calc RPM double DeltaTicks; // # Servo tics between speed measurement double AdjTimeFilt; // Lead Adjusted, filtered, time double LastCSTime; // Previous Coordinate System Time double *pEncoderPos; // pointer to Spindle Position double K; // Tau low pass filter coefficient float TrueSpeedRPS; // last measured speed float InvBaseSpeedRPS; // Reciprocal of Base speed of which trajectory was planned double InvBaseSpeedRPSK1; // InvBaseSpeedRPS * (1-K) float InvUpdateTime; // Reciprocal of update time to avoid division float Tau; // Time constant for spindle filtering int Type; // Type=0 None, Type=1 uses encoder to measure spindle position int ThreadingActive; // True when threading is in progress

~~extern~~ } SPINDLE ~~Spindle~~;

~~void ConfigureSpindle(int Type, int Axis, float UpdateTimeSecs, float Tau, float CountsPerRev)~~extern SPINDLE Spindle ~~feedback~~; ~~void TrigThreading(float BaseSpeedRPS); // triggers threading coordinated motion, BaseSpeed is the ideal Spindle speed thatthe motion was planned for~~

void ConfigureSpindle(int Type, int Axis, float UpdateTimeSecs, float Tau, float CountsPerRev); // configures for type of Spindle feedback void TrigThreading(float BaseSpeedRPS); // triggers threading coordinated motion, BaseSpeed is the ideal Spindle speed thatthe motion was planned for

~~// T I M E F U N C T I O N S~~

~~double Time_sec()~~// ~~returns total time since power up in seconds~~ T I M E F U N C T I O N S

~~void WaitUntil(~~double ~~time_sec~~Time_sec();// ~~wait until a specified~~ returns total timesince power up in seconds

void ~~Delay_sec~~WaitUntil(double ~~sec~~time_sec);// ~~Delay~~ wait until a specified time ~~in seconds~~

~~// (returns current time)~~<~~br /~~span style="color: #0000ff;">void Delay_sec(double ~~WaitNextTimeSlice(void~~sec);// ~~wait until a thread's new~~ Delay time ~~slice begins~~in seconds

// (returns current time) double WaitNextTimeSlice(void);// wait until a thread's new time slice begins

~~#define TIMER0 (*(volatile int *)0x42000010) // 32 bit raw hardware timer counts at CLOCKFREQ (see PC_DSP.h)~~

~~extern volatile double ServoTick; // increments each servo interrupt extern volatile unsigned int LastTimer0; // Last timer value when the ServoTick was incremented~~

# define TIMER0 (*(volatile int *)0x42000010) // 32 bit raw hardware timer counts at CLOCKFREQ (see PC_DSP.h)

<~~br />extern CHAN chan[N_CHANNELS]~~span style="color: #0000ff; ~~// the axes channel related structures extern ~~CHAN *ch0~~volatile double ServoTick; // ~~global pointer to axis 0~~ increments each servo interrupt ~~extern CHAN *ch1; // global pointer to axis 1~~ ~~extern CHAN *ch2; // global pointer to axis 2~~ <~~br />extern CHAN *ch3~~span style="color: #0000ff; ~~// global pointer to axis 3 extern ~~CHAN *ch4~~volatile unsigned int LastTimer0; // ~~global pointer to axis 4~~ Last timer value when the ServoTick was incremented extern CHAN *ch5; // global pointer to axis 5 extern CHAN *ch6; // global pointer to axis 6 extern CHAN *ch7; // global pointer to axis 7

~~ // This status contains the majority of all status // so that it can be uploaded as a bulk transfer extern MAIN_STATUS MainStatus;~~

extern CHAN chan[N_CHANNELS]; // the axes channel related structures extern CHAN *ch0; // global pointer to axis 0 extern CHAN *ch1; // global pointer to axis 1 extern CHAN *ch2; // global pointer to axis 2 extern CHAN *ch3; // global pointer to axis 3 extern CHAN *ch4; // global pointer to axis 4 extern CHAN *ch5; // global pointer to axis 5 extern CHAN *ch6; // global pointer to axis 6 extern CHAN *ch7; // global pointer to axis 7

~~void DisableAxis(int ch)~~ // ~~Disable~~ This status contains the ~~Axis, Servo output is set to zero~~majority of all status // so that it can be uploaded as a bulk transfer extern MAIN_STATUS MainStatus;

~~ void EnableAxisDest(int ch, double Dest); // enable the Axis and set the destination~~

<~~br /~~span style="color: #0000ff;">void ~~EnableAxis~~DisableAxis(int ch); // ~~enable~~ Disable the Axis ~~at the current encoder position~~, Servo output is set to zero

~~// do this before enabling servo or when~~<~~br />// filter coefficients change void ~~ResetFilters~~EnableAxisDest(int ch, double Dest); // ~~Resets Filter history to known stateenable the Axis and set the destination

void ~~Zero~~EnableAxis(int ch); // ~~Zero~~ enable the ~~Encoder Position and Current Commanded Position~~Axis at the current encoder position

~~// Basic motion commands to move one axis~~ ~~void Move(int ch, double x)~~// ~~move using absolute coordinates~~do this before enabling servo or when ~~void MoveAtVel(int chno, double x, float MaxVel); // move using absolute coordinates and specify the velocity~~ ~~void MoveRel(int ch, double dx)~~// ~~move relative to current destination~~filter coefficients change ~~void MoveRelAtVel(int chno, double x, float MaxVel); // move relative to current destinatio and specify the velocity~~ void ~~Jog~~ResetFilters(int ch~~, double vel~~); // ~~move continiously at specified velocity~~Resets Filter history to known state ~~void MoveExp(int chno, double x, double Tau); // exponentially approach a target at time constant Tau~~

~~int CheckDone~~ void Zero(int ch); // ~~returns 1 if axis is Done, 0 if not, -1 if axis is disabled~~Zero the Encoder Position and Current Commanded Position

<~~br /~~span style="color: #0000ff;">// Basic motion commands to move ~~3 axes~~ one axis void Move(int ch, double x); // move using absolute coordinates void ~~MoveXYZABC~~MoveAtVel(int chno, double x, ~~double y~~float MaxVel); // move using absolute coordinates and specify the velocity void MoveRel(int ch, double zdx); // move relative to current destination void MoveRelAtVel(int chno, double ax, ~~double b, double c~~float MaxVel); // ~~Moves 6 axes (each axis moves independently)~~ move relative to current destinatio and specify the velocity ~~int CheckDoneXYZABC~~void Jog(int ch, double vel); // ~~Check if all CS axis have completed~~ move continiously at specified velocity void MoveExp(int chno, ~~returns 1 if all complete~~double x, ~~-1 if any is disabled, otherwise 0~~double Tau); // exponentially approach a target at time constant Tau

<~~br /~~span style="color: #0000ff;">int ~~CheckDoneBuf~~CheckDone(int ch); // returns 1 if axis is Done, 0 if not, -1 if ~~any~~ axis ~~in CS~~ is disabled ~~int CheckDoneGather(); void StartMove(int ch);~~

~~void SetupForMove(double From, double To, float MaxVel, CHAN *ch, int CoeffOffset,~~ ~~int NoJerkControlAtStart,~~ <~~br /~~span style="color: #0000ff;"> ~~int NoJerkControlAtEnd,~~// Basic motion commands to move 3 axes ~~int Start,~~ ~~int *Nstates)~~// void ~~SetupForMotionPause~~MoveXYZABC(double x,~~CHAN *ch~~double y,~~int CoeffOffset~~double z, double ~~time~~a, double b, double c); // ~~stay still~~ Moves 6 axes (each axis moves independently) int CheckDoneXYZABC(); // Check if all CS axis have completed , returns 1 if all complete, -1 if any is disabled, otherwise 0

~~// coordinate systems #0 - axis definitions~~ ~~extern int CS0_axis_x~~~~extern~~ int ~~CS0_axis_y~~CheckDoneBuf(); // ~~Axis channel number to use as y~~ returns 1 if Done, 0 if not, -1 if any axis in CS disabled ~~extern int CS0_axis_z; // Axis channel number to use as z~~ ~~extern int CS0_axis_a~~~~extern~~ int ~~CS0_axis_b~~CheckDoneGather(); ~~// Axis channel number to use as b~~ ~~extern int CS0_axis_c; // Axis channel number to use as c~~ ~~extern~~ void StartMove(int ~~CS0_axis_u~~ch); ~~// Axis channel number to use as u~~ ~~extern int CS0_axis_v; // Axis channel number to use as v~~

void ~~DefineCoordSystem~~SetupForMove(~~int axisx~~double From, ~~int axisy~~double To, ~~int axisz~~float MaxVel, CHAN *ch, int ~~axisa);~~ CoeffOffset, int NoJerkControlAtStart,~~y,z,a (set -1 to disable)~~ ~~void DefineCoordSystem6(~~ int ~~axisx~~NoJerkControlAtEnd, int ~~axisy, int axisz~~Start, int ~~axisa, int axisb, int axisc~~*Nstates); void ~~DefineCoordSystem8~~SetupForMotionPause(~~int axisx~~double x, ~~int axisy~~CHAN *ch, int ~~axisz~~CoeffOffset, ~~int axisa, int axisb, int axisc, int axisu, int axisv~~double time); // ~~define axis chan numbers to use as x,y,z,a,b,c,u,v (set -1 to disable)~~stay still

// coordinate systems #0 - axis definitions extern int CS0_axis_x; // ~~A Low Pass filter can be applied~~ Axis channel number to ~~all 8 axes of coordinated motion~~use as x extern int CS0_axis_y; // ~~by setting the KLP coefficient. To compute an appropriate coefficient~~Axis channel number to use as y extern int CS0_axis_z; // ~~from a time constant Tau in seconds~~ Axis channel number to use ~~KLP~~ as z extern int CS0_axis_a; /~~Tau)~~/ Axis channel number to use as a extern int CS0_axis_b; // Axis channel number to use as b extern int CS0_axis_c; // Axis channel number to use as c extern ~~double KLP~~int CS0_axis_u; // ~~coordinated motion low pass filter coefficient~~Axis channel number to use as u extern int CS0_axis_v; // Axis channel number to use as v

void DefineCoordSystem(int axisx, int axisy, int axisz, int axisa); // ~~TauKLP =~~ define axis chan numbers to use as x,y,z,a (set -~~TIMEBASE~~1 to disable)</~~log~~span> void DefineCoordSystem6(~~KLP~~int axisx, int axisy, int axisz, int axisa, int axisb, int axisc); ~~automatically computed by ExecBuf command~~// define axis chan numbers to use as x,y,z,a,b,c (set -1 to disable) ~~extern float TauKLP~~void DefineCoordSystem8(int axisx, int axisy, int axisz, int axisa, int axisb, int axisc, int axisu, int axisv); // ~~"smoothing" related time constant used for End Motion~~define axis chan numbers to use as x,y,z,a,b,c,u,v (set -1 to disable)

~~extern float SplineTauFactor~~ // ~~Final Spline motion~~ A Low Pass filter can be applied to ~~target will have~~ all 8 axes of coordinated motion // by setting the KLP coefficient. To compute an appropriate coefficient // from a time ~~duration of this number of TauKLP~~ constant Tau in seconds use KLP = exp(~~defaults to 2~~-TIMEBASE/Tau); extern double KLP; // coordinated motion low pass filter coefficient

<~~br /~~span style="color: #0000ff;">// ~~Stop profile generation<br~~ TauKLP = -TIMEBASE/~~>// which will stop updating~~ log(~~freeze~~KLP) ~~the destination~~ ; automatically computed by ExecBuf command extern float TauKLP; // ~~new commands can then be placed into the queue~~"smoothing" related time constant used for End Motion

~~void StopMotion~~extern float SplineTauFactor; // Final Spline motion to target will have a time duration of this number of TauKLP (~~CHAN *ch~~defaults to 2);

/ ~~put a trajectory off into the queue~~ / Stop profile generation ~~void SetupForMotionEnd~~// which will stop updating (~~CHAN *ch, int CoeffOffset~~freeze) the destination // new commands can then be placed into the queue

<~~br />// Digital I/O Functions ~~span style="color: #~~define BIT_SET 0x100 // rel address in FPGA where bit set ports reside ~~#define BIT_CLR 0x110 // rel address in FPGA where bit clear ports reside~~void StopMotion(CHAN *ch); ~~#define BIT_DIR 0x120 // rel address in FPGA where bit Direction ports reside #define BIT_READ 0x130 // rel address in FPGA where bit read ports reside

// ~~Fixed I~~put a trajectory off into the queue </~~O bit definitions~~span> void SetupForMotionEnd(CHAN *ch, int CoeffOffset) ;

// Digital I/O Functions #define ~~LED0 46~~ BIT_SET 0x100 // ~~KFLOP LED~~ rel address in FPGA where bit set ports reside #define BIT_CLR 0x110 // rel address in FPGA where bit ~~number~~clear ports reside #define ~~LED1 47~~ BIT_DIR 0x120 // ~~KFLOP LED~~ rel address in FPGA where bit Direction ports reside #define BIT_READ 0x130 // rel address in FPGA where bit ~~number~~read ports reside

<~~br /~~span style="color: #0000ff;">// ~~Virtual~~ Fixed I/O ~~bits~~bit definitions ~~extern int VirtualBits; // Virtual I/O bits simulated in memory, use SetBit/ClearBit/SetStateBit(32-63 to reference)~~

# define LED0 46 // ~~Virtual I~~KFLOP LED #0 bit number</~~O bits Extended 1024-2047~~span> ~~extern int VirtualBitsEx[N_VIRTUAL_BITS_EX/32]~~#define LED1 47 // ~~1024 Expanded Virtual Bits (1024-2047)~~KFLOP LED #1 bit number

~~extern int BitDirShadow[2]; // direction of all 64 I/O bits~~ ~~extern int BitDirShadowSnap0~~// ~~direction of 14 Snap Amp, 1st board,~~ Virtual I/O bits extern int ~~BitDirShadowSnap1~~VirtualBits; // ~~direction of 14 Snap Amp, 2nd board,~~ Virtual I/O bitssimulated in memory, use SetBit/ClearBit/SetStateBit(32-63 to reference)

~~void SetBitDirection(int bit, int dir)~~// ~~define bit as input (0) or output (1)~~ Virtual I/O bits Extended 1024-2047 ~~int GetBitDirection(int bit); // returns whether bit is defined as input (0) or output (1)~~ ~~void SetBit(int bit)~~~~void ClearBit(~~extern int ~~bit);~~ VirtualBitsEx[N_VIRTUAL_BITS_EX/~~/ set a bit low (bit must be defined as an output, see SetBitDirection) void SetStateBit(int bit, int state)~~32]; // ~~set a bit high or low~~ 1024 Expanded Virtual Bits (~~bit must be defined as an output, see SetBitDirection~~1024-2047) ~~int ReadBit(int bit); // read the state of an I/O bit~~

extern int BitDirShadow[2]; // direction of all 64 I/O bits extern int BitDirShadowSnap0; // ~~Non volatile Flash functions~~direction of 14 Snap Amp, 1st board, I/O bits extern int BitDirShadowSnap1; // direction of 14 Snap Amp, 2nd board, I/O bits

void SetBitDirection(int bit, int dir); // define ~~FLASH~~ bit as input (0) or output (volatile char *1)~~0x90000000)~~ </~~/ beginning of FLASH - first 1MByte is for System Use~~span> int GetBitDirection((volatile char *int bit)~~0x90100000)~~ ; // ~~2nd MegByte~~ returns whether bit is ~~for User use~~defined as input (0) or output (1) void SetBit(~~0x10000~~int bit) ; // ~~FLASH erases in 64KByte Blocks~~ set a bit high (bit must be defined as an output, see SetBitDirection) ~~#define IRAM ((volatile char *)0x10000000)~~ void ClearBit(int bit); // set a bit low (~~volatile char *)0x80000000~~bit must be defined as an output, see SetBitDirection) ~~int ProgramFlash~~void SetStateBit(~~volatile char *src,~~ int ~~Length~~bit, ~~volatile char *dest, char *message~~int state); //~~Programs Flash source address of data, length in 16-~~set a bit high or low (bit ~~words, dest add~~ must be ~~on 64KByte block~~defined as an output, ~~optional \n terminated message~~see SetBitDirection) ~~void SetFlashBank~~int ReadBit(~~volatile unsigned short *add~~int bit); // ~~sets~~ read the ~~currently addressable flash bank (address bits 14-19)~~state of an I/O bit

// Non volatile Flash functions

# define FLASH ((volatile char *)0x90000000) // ~~KONNECT AUX PORT FUNCTIONS~~beginning of FLASH - first 1MByte is for System Use // #define FLASH_USER ((volatile char *)0x90100000) // ~~Example:~~2nd MegByte is for User use // #define FLASH_BLOCK_SIZE (0x10000) // ~~Configure KFLOP to service Konnect 32 Input 16 output IO board~~FLASH erases in 64KByte Blocks ~~// Board address is 0,~~ ~~// 16 Outputs are mapped to Virtual IO 48-63~~ #define IRAM (~~VirtualBits~~(volatile char *)0x10000000) #define SDRAM (~~VirtualBits[0]~~(volatile char *)0x80000000) // ~~// InitAux~~int ProgramFlash(volatile char *src, int Length, volatile char *dest, char *message); //Programs Flash source address of data, length in 16-bit words, dest add must be on 64KByte block, optional \n terminated message void SetFlashBank(volatile unsigned short *add); // ~~AddKonnect~~sets the currently addressable flash bank (~~0,&VirtualBits,VirtualBitsEx~~address bits 14-19); //

~~void InitAux(void); // Initialize the AUX Port KFLOP JP4 or JP6 and clear list of board to be serviced (only one Aux Port may be used at a time)~~

// KONNECT AUX PORT FUNCTIONS // // Example: // // Configure KFLOP to service Konnect 32 Input 16 output IO board // Board addressis 0, ~~address of 32-bit into~~ // 16 Outputs are mapped to ~~get the Output Bits~~ Virtual IO 48-63 (~~in low 16 bits~~VirtualBits)~~, address of where to put~~ // 32 Inputsare mapped to Virtual IO 1024-1055 (VirtualBits[0]) ~~void AddKonnect~~// // InitAux(); // AddKonnect(~~int BoardAddress~~0, ~~int *OutputAddress~~&VirtualBits, ~~int *InputAddress~~VirtualBitsEx); //

~~// Board address, address of 32-bit into to get the Output Bits (in low 16 bits), address of where to put 32 Inputs~~<~~br /~~span style="color: #0000ff;">void ~~AddKonnect_Aux0~~InitAux(~~int BoardAddress, int *OutputAddress, int *InputAddress~~void); // ~~add a Konnect Board to~~ Initialize the AUX Port KFLOP JP4 or JP6 and clear list of ~~AUX0 Port Boards~~ board to be serviced(only one Aux Port may be used at a time)

<~~br /~~span style="color: #0000ff;"> ~~<br~~ />/~~/ User Print Routines // // sends a string~~ Board address, address of 32-bit into to get the ~~user console~~ Output Bits (in low 16 bits), address of ~~the KMotion~~where to put 32 Inputs ~~// application. Because other threads may be sending~~ ~~// characters, the strings are buffered in a queue~~<~~br /~~span style="color: #0000ff;">~~// and sent by the primary thread as soon as there // is no PC input to process.~~void AddKonnect(int BoardAddress, int *OutputAddress, int *InputAddress); ~~The string prepends // an escape so the PC application knows for sure ~~// add a Konnect Board to ~~send this~~ list of AUX1 Port Boards to ~~the Console window and not to // process it as a response to a command that may //~~ be ~~in the pipeline.~~serviced ~~// // // normally the routine exits to the caller quickly // unless the queue is full, then it must wait~~

// Board address, address of 32-bit into to get the Output Bits (in low 16 bits), address of where to put 32 Inputs void AddKonnect_Aux0(int BoardAddress, int *OutputAddress, int *InputAddress); // ~~must~~ add a Konnect Board to list of AUX0 Port Boards to be ~~binary~~ serviced

</ ~~Note~~span> // User Print Routines // // sends a string to the user console of the KMotion // application. Because other threads may be sending // characters, the strings are buffered in a queue // and sent by the primary thread as soon as there // is no PC input to process. The string prepends // an escape so the PC application knows for sure // to send this to the Console window and not to // process it as a response to a command that may // be in the pipeline. // // // normally the routine exits to the caller quickly // unless the queue is full, then it must wait

~~int printf(const char *format, ...)~~# define MAX_STRING 128 </~~/ Print formatted string to console~~span> ~~int sprintf(char *s, const char *format, ...)~~#define MAX_NSTRINGS 256 // ~~Print formatted string to string~~must be binary

~~typedef int FILE;~~<~~br />FILE *fopen(const char*, const char*); // Open a text file for writing on the PC (2nd param~~ span style= "rtcolor: #0000ff;" ~~or "wt") ~~int fprintf(FILE *f, const char * format, ...);~~ // ~~Print formatted string to the PC's Disk File~~Note: standard C language printf ~~int fclose(FILE *f); // Close the disk file on the PC

int ~~Print~~printf(const char *sformat, ...); // Print a formatted string to ~~the~~ console ~~window~~ ~~int PrintFloat(char *Format, double v); // Print a double using printf format, ex "%8.3f\n"~~ ~~int PrintInt(char *Format, int v)~~ int ~~sscanf~~sprintf(~~const~~ char *~~_str~~s, const char *~~_fmt~~format, ...); //~~scan~~ Print formatted string ~~and convert~~ to ~~values~~string

~~extern volatile~~ typedef int ~~read_disk_buffer_status~~FILE; ~~//status of read disk buffer 1=line available, 2=error, 3=eof~~ ~~extern char read_disk_buffer[MAX_READ_DISK_LENGTH+1];~~ ~~char~~ FILE *~~fgets~~fopen(const char *~~str~~, ~~int n, FILE~~ const char*~~file~~); //~~read string from PC disk~~ Open a text file~~, str=buffer, n=buffer length, f=FILE pointer, returns NULL~~ for writing on ~~error~~the PC (2nd param = "rt" or "wt") int ~~fscanf~~fprintf(FILE *f, const char *format, ...); //~~read sting from~~ Print formatted string to the PC 's Disk ~~file, convert values, returns number of items converted~~File int ~~feof~~fclose(FILE *f); // ~~End of file status for~~ Close the disk ~~reading~~file on the PC

/*<~~br /~~span style="color: #0000ff;"> int Print(char * ~~MessageBox(~~s) ~~Flags thes can be passed~~ ; // Print a string to the ~~PC to invoke MessageBoxes~~console window * for some applications such as KMotionCNC which monitor upload * status and present message boxes when requested. See the pc-dsp.h<~~br /~~span style="color: #0000ff;"> int PrintFloat(char * ~~header for more information ~~Format, double v); * /~~<br~~ /~~>#define MB_OK 0x00000000L~~Print a double using printf format, ex "%8.3f\n" ~~#define MB_OKCANCEL 0x00000001L~~ ~~#define MB_ABORTRETRYIGNORE 0x00000002L~~<~~br />~~span style="color: #~~define MB_YESNOCANCEL 0x00000003L ~~#define MB_YESNO 0x00000004L<br~~ int PrintInt(char *Format, int v); /~~>#define MB_RETRYCANCEL 0x00000005L<br~~ /~~>#define MB_CANCELTRYCONTINUE 0x00000006L~~Print an integer using printf format, ex "result=%4d\n" ~~#define MB_ICONHAND 0x00000010L~~ ~~#define MB_ICONQUESTION 0x00000020L~~<~~br />~~span style="color: #~~define MB_ICONEXCLAMATION 0x00000030L ~~#define MB_ICONASTERISK 0x00000040L~~ ~~#define MB_APPLMODAL 0x00000000L~~ ~~#define MB_SYSTEMMODAL 0x00001000L~~<~~br />~~span style="color: #~~define MB_TASKMODAL 0x00002000L ~~#define MB_NOFOCUS 0x00008000L<br~~ int sscanf(const char *_str, const char *_fmt, ...); /~~>#define MB_SETFOREGROUND 0x00010000L<br~~ /~~>#define MB_DEFAULT_DESKTOP_ONLY 0x00020000L~~scan string and convert to values ~~#define MB_TOPMOST 0x00040000L #define MB_RIGHT 0x00080000L

# define MAX_READ_DISK_LENGTH 1024 /*/ max allowed length of disk file line length * Dialog Box Command IDs *extern volatile int read_disk_buffer_status; //status of read disk buffer 1=line available, 2=error, 3=eof extern char read_disk_buffer[MAX_READ_DISK_LENGTH+1]; ~~#define IDCANCEL 2~~ char *fgets(char *str, int n, FILE *file); //read string from PC disk file, str=buffer, n=buffer length, f=FILE pointer, returns NULL on error ~~#define IDRETRY 4~~ int fscanf(FILE *f, const char *format, ...); //read sting from PC Disk file, convert values, returns number of items converted ~~#define IDYES 6~~ int feof(FILE *f); // End of file status for disk reading

/* * MessageBox() Flags thes can be passed to the PC to invoke MessageBoxes * for some applications such as KMotionCNC which monitor upload * status and present message boxes when requested. See the pc-dsp.h * header for more information */ #define MB_OK 0x00000000L #define MB_OKCANCEL 0x00000001L #define MB_ABORTRETRYIGNORE 0x00000002L #define MB_YESNOCANCEL 0x00000003L #define MB_YESNO 0x00000004L #define MB_RETRYCANCEL 0x00000005L #define MB_CANCELTRYCONTINUE 0x00000006L #define MB_ICONHAND 0x00000010L #define MB_ICONQUESTION 0x00000020L #define MB_ICONEXCLAMATION 0x00000030L #define MB_ICONASTERISK 0x00000040L #define MB_APPLMODAL 0x00000000L #define MB_SYSTEMMODAL 0x00001000L #define MB_TASKMODAL 0x00002000L #define MB_NOFOCUS 0x00008000L #define MB_SETFOREGROUND 0x00010000L #define MB_DEFAULT_DESKTOP_ONLY 0x00020000L #define MB_TOPMOST 0x00040000L #define MB_RIGHT 0x00080000L

/*</ ~~Misc routines~~span> * Dialog Box Command IDs */ #define IDOK 1 #define IDCANCEL 2 #define IDABORT 3 #define IDRETRY 4 #define IDIGNORE 5 #define IDYES 6 #define IDNO 7

~~void DoResolverInput2(CHAN *chx, float x, float y); // optimized routine to handle sin/cosine resolver input~~

~~extern double ResolverFactor~~// ~~defaults to 1000.0~~Misc routines</~~TWO_PI converts sine/cosine angle to reported Position~~span>

<~~br /~~span style="color: #0000ff;">void DoResolverInput2(CHAN *chx, float x, float y); // ~~M U L T I - T H R E A D S U P P O R T~~optimized routine to handle sin/cosine resolver input

extern double ResolverFactor; // ~~user threads are numbered 1~~ defaults to 1000.~~. n~~0/TWO_PI converts sine/cosine angle to reported Position

~~void StartThread(int thread); // starts a downloaded program at it's entry point~~ ~~void PauseThread(int thread); // stops a thread from executing~~<~~br />int ResumeThread(int thread)~~span style="color: #0000ff; ~~// resumes a tread after a pause ~~void ThreadDone(void);~~ // ~~call to terminate current thread~~M U L T I - T H R E A D S U P P O R T ~~extern int CurrentThread; // current thread that is/was executing 0 = Pri 1-7 = User Threads

// user threads are numbered 1 .. n

void StartThread(int thread); // ~~A User Program Call Back can be defined to be called every Servo Sample~~starts a downloaded program at it's entry point void PauseThread(int thread); // ~~Set to Non-NULL for the the Callback to be made. The Callback Routine~~stops a thread from executing int ResumeThread(int thread); // ~~must return with~~ resumes a ~~few micro seconds or the system may become unstable~~tread after a pause ~~typedef~~ void ~~USERCALLBACK~~ThreadDone(void); // call to terminate current thread extern ~~USERCALLBACK *UserCallBack~~int CurrentThread; // current thread that is/was executing 0 = Pri 1-7 = User Threads

// used to allow mutual exclusive access to a resource // (waits until resource is available, then locks it) // if the thread that locked it is no longer active, // release the lock

// A User Program Call Back can be defined to be called every Servo Sample // Set to Non-NULL for the the Callback to be made. The Callback Routine // must return with a few micro seconds or the system may become unstable typedef void ~~MutexLock~~USERCALLBACK(~~int *mutex~~void); ~~void MutexUnlock(int~~ extern USERCALLBACK *~~mutex)~~UserCallBack;

/ ~~These routines are written in assembly such that~~/ used to allow mutual exclusive access to a resource // ~~they are atomic and are un-interruptible by using~~(waits until resource is available, then locks it) // ~~instructions in delayed branching~~if the thread that locked it is no longer active, // release the lock

void ~~AtomicSet~~MutexLock(int *~~p, int mask~~mutex); ~~//{~~ ~~// *p~~ void MutexUnlock(int *~~p | mask~~mutex); ~~//}~~

~~void AtomicClear(int *p, int mask);~~<~~br /~~span style="color: #0000ff;">//{These routines are written in assembly such that // they are atomic and are un-interruptible by using //}instructions in delayed branching

void AtomicSet(int *p, int mask); //{ // ~~to value.~~ ~~returns the original~~*p = *p | mask; // ~~value. routine is atomic~~}

~~int TestAndSet~~void AtomicClear(int *~~mutex~~p, int ~~value~~mask); //{ ~~// register result = *mutex;~~ // ~~if (result=~~ *p =0) *~~mutex=value~~p & mask; ~~// return result;~~ //}

// test a location and if zero, set // ~~S N A P A M P D E F I N I T I O N S~~to value. returns the original // value. routine is atomic

int TestAndSet(int *mutex, int value); ~~#define KM_SNAP_READ_HI 0xd~~ //{ ~~#define KM_SNAP_CLK_ENA 0x09~~ // register result = *mutex; ~~#define KM_SNAP_WRITE_HIGH_TRIG 0x0b~~ // if (result==0) *mutex=value; // return result; // ~~FPGA Registers~~}

~~#define SNAP0 0x40 // Base Addresse SNAP AMP #0~~ // ~~Base Addresse SNAP AMP #1~~ S N A P A M P D E F I N I T I O N S

# define KM_SNAP_READ_LOW 0xc #define KM_SNAP_READ_HI 0xd #define KM_SNAP_READ_EXCEPTION 0x10 #define KM_SNAP_CLK_ENA 0x09 #define KM_SNAP_SHIFT_BYTE 0x0a #define KM_SNAP_WRITE_HIGH_TRIG 0x0b #define KM_SNAP_READ_ADD_TRIG 0x0c #define KM_SNAP_READ_ADD_BITMAP 0x28 // FPGA Registers

#~~define SNAP_PWMS 0 // (4) 16 bit PWMs~~ <~~br />#define SNAP_CLR_ENC_ERRS 8 // any write clears all encoder errors #define SNAP_CUR_LOOP_GAINS 9 // (4) 8 bit Current Loop Gains Default~~span style=~~16 ~~"color: #~~define SNAP_SET_BIT 17 // (14) GPIO bits #define ~~SNAP_CLR_BIT 18~~ SNAP0 0x40 // ~~(14) GPIO bits ~~Base Addresse SNAP AMP #~~define SNAP_DIR_BIT 19 // (14) GPIO bits~~0 ~~#define SNAP_SUPPLY_CLAMP0 20 // 16 bit power supply clamp setting side A~~ ~~#define SNAP_SUPPLY_CLAMP_ENA0 21 // 1 bit power supply clamp enable side A~~<~~br />~~span style="color: #~~define SNAP_SUPPLY_CLAMP1 22 // 16 bit power supply clamp setting side B #define ~~SNAP_SUPPLY_CLAMP_ENA1 23~~ SNAP1 0x60 // ~~1 bit power supply clamp enable side B ~~Base Addresse SNAP AMP #~~define SNAP_PEAK_CUR_LIMIT0 24 // 4 bits peak current limit side A~~1 ~~#define SNAP_PEAK_CUR_LIMIT1 25 // 4 bits peak current limit side B~~

// ~~read~~ write addresses

#define SNAP_PWMS 0 // (4) 16 bit PWMs #define ~~SNAP_ENC 8~~ SNAP_CLR_ENC_ERRS 8 // ~~(4) 16 bit Encoders (bit15=error 7-0=data)~~ any write clears all encoder errors #define ~~SNAP_CURRENT_A0 12~~ SNAP_CUR_LOOP_GAINS 9 // ~~Measured Current Side A Lead A~~ (~~14bits~~4)8 bit Current Loop Gains Default=16 ~~#define SNAP_CURRENT_C0 13 // Measured Current Side A Lead C~~ #define ~~SNAP_CURRENT_A1 14~~ SNAP_SET_BIT 17 // ~~Measured Current Side B Lead A~~(14) GPIO bits ~~#define SNAP_CURRENT_C1 15 // Measured Current Side B Lead C~~ #define ~~SNAP_DIFF_IN 16~~ SNAP_CLR_BIT 18 // ~~16 bits~~ (~~15-8= Diff inputs 7-0=encoder inputs~~14) GPIO bits #define ~~SNAP_IN_BIT 17~~ SNAP_DIR_BIT 19 // (14) GPIO bits #define ~~SNAP_SUPPLY_VOLT0 22~~ SNAP_SUPPLY_CLAMP0 20 // ~~Measured Supply Voltage Side~~ 16 bit power supply clamp setting side A #define ~~SNAP_SUPPLY_VOLT1 23~~ SNAP_SUPPLY_CLAMP_ENA0 21 // ~~Measured Supply Voltage Side B~~1 bit power supply clamp enable side A #define ~~SNAP_TEMP0 24~~ SNAP_SUPPLY_CLAMP1 22 // ~~Measured Temperature Side A~~16 bit power supply clamp setting side B #define ~~SNAP_TEMP1 25~~ SNAP_SUPPLY_CLAMP_ENA1 23 // ~~Measured Temperature Side~~ 1 bit power supply clamp enable side B #define ~~SNAP_STATUS 30~~ SNAP_PEAK_CUR_LIMIT0 24 // ~~Status (FAN,OverTemp1,OverTemp0,OVER_CUR1,OVER_CUR0,Fault)~~4 bits peak current limit side A #define ~~SNAP_RESET 31~~ SNAP_PEAK_CUR_LIMIT1 25 // ~~Reset~~4 bits peak current limit side B

//~~RS232 FPGA Register Definitions~~read addresses

#define ~~RS232_STATUS 0xc1~~ SNAP_PWMS 0 // ~~Status Reg Address~~(4) 16 bit PWMs #define ~~RS232_DATA 0xc0~~ SNAP_ENC 8 // 8 (4) 16 bit Encoders (bit15=error 7-0=data ~~read~~) </~~write reg address~~span> #define ~~RS232_DATA_READY 0x01~~ SNAP_CURRENT_A0 12 // ~~Data ready to read status mask~~Measured Current Side A Lead A (14bits) #define ~~RS232_TRANSMIT_FULL 0x02~~SNAP_CURRENT_C0 13 // ~~Transmit buffer full status mask~~Measured Current Side A Lead C #define SNAP_CURRENT_A1 14 // Measured Current Side B Lead A #define SNAP_CURRENT_C1 15 // Measured Current Side B Lead C #define SNAP_DIFF_IN 16 // 16 bits (15-8= Diff inputs 7-0=encoder inputs) #define SNAP_IN_BIT 17 // (14) GPIO bits #define SNAP_SUPPLY_VOLT0 22 // Measured Supply Voltage Side A #define SNAP_SUPPLY_VOLT1 23 // Measured Supply Voltage Side B #define SNAP_TEMP0 24 // Measured Temperature Side A #define SNAP_TEMP1 25 // Measured Temperature Side B #define SNAP_STATUS 30 // Status (FAN,OverTemp1,OverTemp0,OVER_CUR1,OVER_CUR0,Fault) #define SNAP_RESET 31 // Reset

~~#define RS232_BAUD_REG 0xc1 // Set Baud rate 8-bit divisor Reg Address~~ <~~br />~~span style="color: #~~define RS232_BAUD_115200 ((16666666/115200/16)-1)// 8-bit divisor value to set 115200 baud ~~#define RS232_BAUD_57600 ((16666666~~/~~57600~~/~~16)-1) // 8-bit divisor value to set 57600 baudRS232 FPGA Register Definitions #define RS232_BAUD_38400 ((16666666/38400/16)-1) // 8-bit divisor value to set 38400 baud #define RS232_BAUD_19200 ((16666666/19200/16)-1) // 8-bit divisor value to set 19200 baud #define RS232_BAUD_9600 ((16666666/9600/16)-1) // 8-bit divisor value to set 9600 baud #define RS232_BAUD_4800 ((16666666/4800/16)-1) // 8-bit divisor value to set 4800 baud

~~void InitRS232(int baud)~~# define RS232_STATUS 0xc1 // Status Reg Address ~~void EnableRS232Cmds(int baud)~~#define RS232_DATA 0xc0 // 8 bit data read/write reg address #define RS232_DATA_READY 0x01 // Data ready to read status mask #define RS232_TRANSMIT_FULL 0x02// Transmit buffer full status mask

~~extern char * volatile pRS232RecIn~~# define RS232_BAUD_REG 0xc1 // Set Baud rate 8-bit divisor Reg Address #define RS232_BAUD_115200 ((16666666/115200/ ~~Buffered Receive Pointer Head~~16)-1)// 8-bit divisor value to set 115200 baud ~~extern char *pRS232RecOut~~#define RS232_BAUD_57600 ((16666666/57600/ ~~Buffered Receive Pointer Tail~~16)-1) // 8-bit divisor value to set 57600 baud ~~extern char *pRS232TxIn~~#define RS232_BAUD_38400 ((16666666/38400/ ~~Buffered Transmit Pointer Head~~16)-1) // 8-bit divisor value to set 38400 baud ~~extern char * volatile pRS232TxOut~~#define RS232_BAUD_19200 ((16666666/19200/ ~~Buffered Transmit Pointer Tail~~16)-1) // 8-bit divisor value to set 19200 baud ~~extern int DoRS232Cmds~~#define RS232_BAUD_9600 ((16666666/9600/ ~~Enables~~16)-1) /~~disables KFLOP Command processor~~ / 8-bit divisor value toset 9600 baud</~~from RS232~~span> #define RS232_BAUD_4800 ((16666666/4800/16)-1) // 8-bit divisor value to set 4800 baud

~~char RS232_GetChar(~~voidInitRS232(int baud); </~~/ Get Internally Buffered (1000 chars) RS232 received Data~~ span> void ~~RS232_PutChar~~EnableRS232Cmds(~~char c~~int baud); </~~/ Put Internally Buffered (1000 chars) RS232 transmit Data~~span>

extern char * volatile pRS232RecIn; // Buffered Receive Pointer Head extern char *pRS232RecOut; // Buffered Receive Pointer Tail extern char *pRS232TxIn; // Buffered Transmit Pointer Head extern char * volatile pRS232TxOut; // Buffered Transmit Pointer Tail extern int DoRS232Cmds; // Enables/disables KFLOP Command processor to/from RS232

char RS232_GetChar(void); // Get Internally Buffered (1000 chars) RS232 received Data void RS232_PutChar(char c); // Put Internally Buffered (1000 chars) RS232 transmit Data # endif

Moray

edits