KFLOP C Programs - Revision history

TK: C Program Size and Stack Limitations updated for Kogna

2025-01-13T17:31:43Z

C Program Size and Stack Limitations updated for Kogna

TK: /* Axis Homing and Indexing */ fix typo

2024-11-09T17:17:42Z

‎Axis Homing and Indexing: fix typo

TK: Data/Motion Capture with a C Program

2021-03-15T23:33:13Z

Data/Motion Capture with a C Program

TK: /* C Variables */

2020-01-06T21:46:43Z

‎C Variables

SZ: /* C Curly Brackets { } */

2018-12-21T21:49:35Z

‎C Curly Brackets { }

SZ: /* Common C Programming Mistakes */

2018-12-21T21:42:18Z

‎Common C Programming Mistakes

TK: Axis Homing and Indexing

2018-11-29T22:07:11Z

Axis Homing and Indexing

TK: Common C Programming Mistakes

2018-09-22T16:23:53Z

Common C Programming Mistakes

TK: /* C Program Size and Stack Limitations */

2018-08-09T17:26:57Z

‎C Program Size and Stack Limitations

SZ: /* C Functions (Subroutines) */

2017-11-13T21:56:18Z

‎C Functions (Subroutines)

@@ Line 393: / Line 393: @@
 ==C Program Size and Stack Limitations==
-Each of the first 6 User Thread Memory Spaces are limited to 64KBytes (65536 Bytes).  Thread 7 is larger and limited to 5x64KBytes (327680Bytes).
+Each of the first 6 User Thread Memory Spaces in KFLOP are limited to 64KBytes (65536 bytes).  Kogna's Thread Spaces are 256KBytes (262,144Bytes).  Thread 7 in KFLOP is larger and limited to 5x64KBytes (327680 bytes).  Kogna's Thread 7 is 1MByte (1,048,576 bytes).
 If subsequent Threads are unused it is permitted to overflow into their Thread Spaces.  For example, if Threads #2 and #3 are not used is permissible to load a program of size 3 x 64KBytes (196608 bytes) into Thread #1.  If you later want to use Threads #2 or #3 then Thread #1 should be halted before using them.

← Older revision		Revision as of 17:17, 9 November 2024
Line 435:		Line 435:


−	KFLOP User C Programs are given [http://dynomotion.com/Help/Multitasking.htm CPU Time Slices] to execute so they are guaranteed to execute on a periodic basis. With only 1 User Thread running they are guaranteed to execute every 180us. So any index pulse longer that this time period will never be missed. Also with a proximity sensor the change in state will be guaranteed to be detected ~~withing~~ this time period.	+	KFLOP User C Programs are given [http://dynomotion.com/Help/Multitasking.htm CPU Time Slices] to execute so they are guaranteed to execute on a periodic basis. With only 1 User Thread running they are guaranteed to execute every 180us. So any index pulse longer that this time period will never be missed. Also with a proximity sensor the change in state will be guaranteed to be detected within this time period.

	==Gather Buffer==		==Gather Buffer==

@@ Line 238: / Line 238: @@
 ===<span id="Simple_DiskReadWrite.c_example" class="mw-headline">Simple DiskReadWrite.c example</span>===
 include "KMotionDef.h"<br /><br />main()<br />{<br />    FILE *f;<br />    char s[256];<br />    double a=123.456,b=999.999,c=0.001;<br />    double x=0,y=0,z=0;<br />    int result;<br />    <br />    // write 3 comma separated values to a disk file<br />    f=fopen("c:\\Temp\\KFlopData.txt","wt");<br />    fprintf(s,"%f,%f,%f\n",a,b,c);<br />    fclose(f);<br />    <br />    // read them back in<br />    f=fopen("c:\\Temp\\KFlopData.txt","rt");<br />    if (!f)<br />    {<br />        printf("Unable to open file\n");<br />        return;<br />    }<br />    <br />    // read a line and convert 3 doubles<br />    result=fscanf(f,"%lf,%lf,%lf",&x,&y,&z);<br />    fclose(f);<br />    <br />    printf("# values converted = %d, x=%f, y=%f, z=%f\n",result,x,y,z);<br />}
@@ Line 276: / Line 369: @@
 int    PC_comm[N_PC_COMM_PERSIST];// 8 persist Variables constantly uploaded to send misc commands/data to PC
 ==Threads and KMotion.exec C Programs Screen==

← Older revision		Revision as of 21:46, 6 January 2020
Line 84:		Line 84:

	.		.
		+
		+	===<span id="C Variables" class="mw-headline">C Variables</span>===
		+	C Programs can declare and use various types of variables. Variables are used to store information. A variable '''must be declared''' to tell the compiler what type it is '''before''' it can be used.
		+
		+
		+	3 common types of variables are:
		+
		+	'''int''' - 32 bit signed integer (whole numbers only)
		+
		+	'''float''' - 32 bit floating point number (~7 digits of precision)
		+
		+	'''double''' - 64 bit floating point number (~16 digits of precision)
		+
		+
		+	Variables can be declared to be '''local''' or '''global'''. "Local" variables are declared inside of any function (including main). Their "scope" is limited to the function they are declared within. They are allocated into stack memory and are created when the function is entered and discarded when the function exits.
		+
		+
		+	The Add function below declares a local variable c as an integer.
		+
		+	<pre class="brush:c">// Example to add 2 integer numbers
		+	void Add(int a, int b)
		+	{
		+	int c; // declare a local integer variable
		+
		+	c = a + b; // add the integer numbers
		+	printf("sum = %d\n", c); // print the sum
		+	}</pre>
		+
		+	"Global" variables are declared outside of any function usually toward the beginning of the program after any included files. Their "scope" is the entire C Program. They are allocated into static memory and are created when the Program begins and discarded when the Program exits.
		+
		+
		+	The code below declares a global integer variable c outside the Add Function
		+
		+	<pre class="brush:c">int c; // declare a global integer variable
		+
		+	// Example to add 2 integer numbers
		+	void Add(int a, int b)
		+	{
		+	c = a + b; // add the integer numbers
		+	printf("sum = %d\n", c); // print the sum
		+	}</pre>
		+
		+	The advantage of Local variables is that the same name can be used in different functions for different purposes without conflict.
		+
		+	The advantage of Global variables is that the value persists for the life of the program and the scope of the entire program and so its value can be read/written from multiple functions or multiple executions of the same function.
		+
		+

	===<span id="C Functions" class="mw-headline">C Functions (Subroutines)</span>===		===<span id="C Functions" class="mw-headline">C Functions (Subroutines)</span>===

@@ Line 81: / Line 81: @@
 }</pre>
-−
+.
-−
-−
 ===<span id="C Functions" class="mw-headline">C Functions (Subroutines)</span>===

← Older revision		Revision as of 21:42, 21 December 2018
Line 382:		Line 382:


−	Note ~~we are working on a new code Validation tool (using splint.exe) that will analyze code, detect no useful purpose, and provide warnings~~ in ~~these types of cases. Look for it in the next~~ Version 4.35.	+	'''Note:''' You can use our Code Validator in our latest Test Version 4.35a. See detailed [http://www.dynomotion.com/Help/ProgramScreen/ShowContextMenu.htm help] or our [https://www.youtube.com/watch?v=N2KSdYuag1U Validate C Programs video].

← Older revision		Revision as of 22:07, 29 November 2018
Line 267:		Line 267:

	Each User Thread Stack is located in precious single cycle (5ns) internal memory and is 2 KBytes in length. Care should be used to limit stack usage. Overflowing the stack will likely cause KFLOP to crash. Local variables (defined within functions) and passed function parameters reside on the stack. Large variables should be defined as Global Variables or in the 8 MByte [http://www.dynomotion.com/wiki/index.php?title=KFLOP_C_Programs#Gather_Buffer Gather Buffer]		Each User Thread Stack is located in precious single cycle (5ns) internal memory and is 2 KBytes in length. Care should be used to limit stack usage. Overflowing the stack will likely cause KFLOP to crash. Local variables (defined within functions) and passed function parameters reside on the stack. Large variables should be defined as Global Variables or in the 8 MByte [http://www.dynomotion.com/wiki/index.php?title=KFLOP_C_Programs#Gather_Buffer Gather Buffer]
		+
		+	==Axis Homing and Indexing==
		+	KFLOP doesn't provide any built in mechanism for homing. Instead a homing sequence can be performed in any manner desired using a KFLOP C Program. A number of examples are included. A typical sequence might be to:
		+
		+	# Jog in some direction
		+	# wait for an input to change
		+	# stop
		+	# wait until fully stopped
		+	# Zero
		+
		+	For standard homing the example function '''SimpleHomeIndexFunction.c''' can be used. The example moves to a proximity sensor, optionally reverses to an Index Pulse, moves a fixed distance, then zeros the Axis. Specify -1 for the Index Bit number if no Index pulse exists or is not desired to be used. Below is an example call to the Function showing the parameters to be specified:
		+
		+	<pre class="brush:c"> result = SimpleHomeIndexFunction(2, // axis number to home
		+	1000.0, // speed to move toward home
		+	-1, // direction to move toward home (+1 or -1)
		+	138, // limit bit number to watch for
		+	0, // limit polarity to wait for (1 or 0)
		+	100.0, // speed to move while searching for index
		+	-1, // index bit number to watch for (use -1 for none)
		+	1, // index polarity to wait for (1 or 0)
		+	5000); // amount to move inside limits
		+	</pre>
		+
		+	The example '''SimpleHomeIndexFunctionTest.c''' shows an example of homing 3 axes sequentially.
		+
		+	Note that because homing is all performed in software any IO bits can be used. Some of the documentation lists IO bits to be used but these are only suggestions.
		+
		+
		+	Index pulses from encoders are typically differential signals. The differential index pulse signal can be connected to any unused A or B differential input. Or one of the + or - differential signals can be connected to a single ended digital input. Note that KFLOP's 3.3V inputs should not be driven hard (> 10ma) above 3.8V. Most 5V differential drivers do not do this.
		+
		+
		+	KFLOP User C Programs are given [http://dynomotion.com/Help/Multitasking.htm CPU Time Slices] to execute so they are guaranteed to execute on a periodic basis. With only 1 User Thread running they are guaranteed to execute every 180us. So any index pulse longer that this time period will never be missed. Also with a proximity sensor the change in state will be guaranteed to be detected withing this time period.

	==Gather Buffer==		==Gather Buffer==

← Older revision		Revision as of 16:23, 22 September 2018
Line 329:		Line 329:
	}		}
	</pre>		</pre>
		+
		+	==Common C Programming Mistakes==
		+	A common programming mistake is to forget to add the '()' for a function call. It might not be obvious why this isn't flagged as an error. In some programming languages such as Basic a subroutine with no parameters can be called by coding the name with no parenthesis. In C the name of a function represents the address of the function. Adding the () is required to make a function call to that address.
		+
		+	Furthermore in C any valid expression is allowed. For example:
		+
		+	2+2;
		+
		+	is a valid C expression. The compiler computes 4 and does nothing with it (sometimes computing things have side effects and therefore have purpose).
		+
		+
		+	2;
		+
		+	is a valid C expression. The compiler computes 2 and does nothing with it.
		+
		+
		+	ClearStopImmediately;
		+
		+	is a valid expression. The compiler computes the address of the function ClearStopImmediately and does nothing with it.
		+
		+
		+	Note we are working on a new code Validation tool (using splint.exe) that will analyze code, detect no useful purpose, and provide warnings in these types of cases. Look for it in the next Version 4.35.

← Older revision		Revision as of 17:26, 9 August 2018
Line 258:		Line 258:
	Each of the first 6 User Thread Memory Spaces are limited to 64KBytes (65536 Bytes). Thread 7 is larger and limited to 5x64KBytes (327680Bytes).		Each of the first 6 User Thread Memory Spaces are limited to 64KBytes (65536 Bytes). Thread 7 is larger and limited to 5x64KBytes (327680Bytes).

−	If subsequent Threads are unused it is ~~possible~~ to overflow into their Thread Spaces.	+	If subsequent Threads are unused it is permitted to overflow into their Thread Spaces. For example, if Threads #2 and #3 are not used is permissible to load a program of size 3 x 64KBytes (196608 bytes) into Thread #1. If you later want to use Threads #2 or #3 then Thread #1 should be halted before using them.

@@ Line 120: / Line 120: @@
 Below is a program with duplicated code. It performs the same 3 similar operations on 3 different axes to Enable, Move, and Wait an Axis. Notice the same operations are performed each time with only two differences: the Axis and the distance moved. So by using a function with two parameters we can replace the 3 instructions with a single function call. The first parameter is which Axis which is an integer value. The second parameter is the distance to move which is a double precision value.
-<pre class="brush:c">include "KMotionDef.h"
+<pre class="brush:c">#include "KMotionDef.h"
 main()
+{
@@ Line 138: / Line 138: @@
 Now declaring a function named EnableMoveWait with 2 parameters (and void return value) we can simplify the C Program, lessen the number of total instructions in the program, and most importantly guarantee that the exact same operations are performed for each axis.
-<pre class="brush:c">include "KMotionDef.h"
+<pre class="brush:c">#include "KMotionDef.h"
 // define function to Enable, Move, and wait with two parameters
@@ Line 157: / Line 157: @@
 It is often desirable to place the functions toward the end of file with the main starting point of the program toward the beginning. This tends to make the program more readable and logical. This is not necessary but more a personal preference. Because the C Compiler only reads the program one time from beginning to end it is good to place at the beginning a description of any Functions that exist in the program. The allows the compiler to know the names of any functions and what parameter and return value types they have before they are used in the program. It is critical that the parameters passed in the call to the function are the exact correct number and type that are defined to be used by the function itself. So to inform the compiler of what function to expect a "function prototype" is specified. This is exactly the same as the function declaration itself except with no body of instructions. It consists of only one line followed by a semicolon to indicate it is only a prototype and not the entire function. See the Program below that has the function moved below the main function and with a function prototype at the beginning:
-<pre class="brush:c">include "KMotionDef.h"
+<pre class="brush:c">#include "KMotionDef.h"
 // define function prototype of function to expect later