826 counters - Revision history

JL: /* Interrupts on IX edges */

2021-12-03T13:46:59Z

Interrupts on IX edges

← Older revision		Revision as of 08:46, 3 December 2021
Line 430:		Line 430:
	}		}

	====~~Interrupts~~ on IX edges====		====Interrupt on IX edges====

	Sometimes it's ~~useful~~ to ~~be able to automatically call~~ a function once per encoder revolution. This is easily done in cases where the encoder ~~sends~~ an Index signal to the counter's IX input. The next example shows how to generate interrupts on every IX rising edge.		Sometimes it's necessary to execute a software function once per encoder revolution. This is easily done in cases where the encoder produces an Index signal which is connected to the counter's IX input. The next example shows how to generate interrupts on every IX rising edge.

	// ~~Interrupt upon~~ rising edges ~~on IX input~~.		// Trigger snapshots on rising IX edges.

	uint bd = 0; // board number		uint bd = 0; // board number
Line 444:		Line 444:
	S826_CounterStateWrite(bd, ch, 1); // Start tracking encoder		S826_CounterStateWrite(bd, ch, 1); // Start tracking encoder
	// Repeat forever:		// Repeat forever:
	while (S826_CounterSnapshotRead(bd, ch, &counts, &tstamp, &reason, S826_WAIT_INFINITE) == S826_ERR_OK) { // Wait for next ~~Index~~ pulse		while (S826_CounterSnapshotRead(bd, ch, &counts, &tstamp, &reason, S826_WAIT_INFINITE) == S826_ERR_OK) { // Wait for next IX pulse
	ProcessIndexPulse(); // TODO: HANDLE INTERRUPT		ProcessIndexPulse(); // TODO: HANDLE INTERRUPT
	}		}

JL: /* Interrupts on IX edges */

2021-12-02T22:15:37Z

Interrupts on IX edges

← Older revision		Revision as of 17:15, 2 December 2021
Line 434:		Line 434:
	Sometimes it's useful to be able to automatically call a function once per encoder revolution. This is easily done in cases where the encoder sends an Index signal to the counter's IX input. The next example shows how to generate interrupts on every IX rising edge.		Sometimes it's useful to be able to automatically call a function once per encoder revolution. This is easily done in cases where the encoder sends an Index signal to the counter's IX input. The next example shows how to generate interrupts on every IX rising edge.

	// Interrupt upon rising edges on ~~counter's Index~~ input.		// Interrupt upon rising edges on IX input.

	uint bd = 0; // board number		uint bd = 0; // board number
Line 441:		Line 441:

	S826_CounterModeWrite(bd, ch, S826_CM_K_QUADX4); // Configure counter		S826_CounterModeWrite(bd, ch, S826_CM_K_QUADX4); // Configure counter
	S826_CounterSnapshotConfigWrite(bd, ch, S826_SS_ALL_IXRISE, S826_BITWRITE); // ~~Enable snapshots~~ upon ~~index~~ rising edges		S826_CounterSnapshotConfigWrite(bd, ch, S826_SS_ALL_IXRISE, S826_BITWRITE); // Snapshot upon IX rising edges
	S826_CounterStateWrite(bd, ch, 1); // Start tracking encoder		S826_CounterStateWrite(bd, ch, 1); // Start tracking encoder
	// Repeat forever:		// Repeat forever:

JL: /* Using interrupts with encoders */ +section: Interrupts on IX edges

2021-12-02T22:13:25Z

Using interrupts with encoders: +section: Interrupts on IX edges

@@ Line 428: / Line 428: @@
     default:
       printf("Error detected: errcode=%d", errcode);
+  }

JL: /* Output pulse every N encoder pulses */

2021-11-03T13:05:26Z

Output pulse every N encoder pulses

← Older revision		Revision as of 08:05, 3 November 2021
Line 594:		Line 594:
	Note that the pulse width will always be 20 ns regardless of how long the counts remain at the target value. Consequently, an external pull-up must be added to the DIO to speed up its rising edge as explained in [[826#Using external pull-up resistors\|Using external pull-up resistors]]. If a longer pulse is needed, a second counter can be used to stretch counter0's output pulse as shown in [[826#Programmable pulse width\|Programmable pulse width]].		Note that the pulse width will always be 20 ns regardless of how long the counts remain at the target value. Consequently, an external pull-up must be added to the DIO to speed up its rising edge as explained in [[826#Using external pull-up resistors\|Using external pull-up resistors]]. If a longer pulse is needed, a second counter can be used to stretch counter0's output pulse as shown in [[826#Programmable pulse width\|Programmable pulse width]].

	If it isn't necessary to track encoder position then it's recommended to use the simpler method shown in [[826#Without tracking\|Without tracking]].		If it isn't necessary to track encoder position then it's recommended to use the simpler method shown in [[826 counters#Without tracking\|Without tracking]].

	// Output a 20 ns pulse every 20000 encoder counts while tracking position ----------		// Output a 20 ns pulse every 20000 encoder counts while tracking position ----------

JL: /* Missed index pulses */

2021-08-31T16:12:50Z

Missed index pulses

← Older revision		Revision as of 11:12, 31 August 2021
Line 990:		Line 990:
	:''Why do I occasionally miss index pulses?''		:''Why do I occasionally miss index pulses?''

	Pulses on the IX input will be properly detected if they conform to the signal timing ~~and voltage~~ specifications. To resolve this problem, check the following:		Pulses on the IX input will be properly detected if they conform to the input signal voltage and timing specifications. The minimum pulse width is 20 ns by default, but will be longer if the counter's programmable noise filter is activated.
	* View the IX input signals with an oscilloscope. Verify that the pulse duration is greater than 20 ns, and that the ~~signal~~ voltage transitions between valid logic levels.
	* Make sure the IX noise filter is disabled. When the IX filter is enabled, the filter will reject index pulses that are too short. The IX noise filter is disabled by default at power-up. If previously enabled by software, the noise filter can be disabled by calling <code>S826_CounterFilterWrite</code>.		To resolve this problem, check the following:
			* View the IX input signals with an oscilloscope. Verify that the pulse duration is greater than 20 ns, and that the voltage transitions between valid logic levels.
			* Make sure the IX noise filter is disabled. When the IX filter is enabled, the filter will reject index pulses that are too short. The IX noise filter is disabled by default at power-up. If previously enabled by software, the noise filter can be disabled by calling <code>S826_CounterFilterWrite()</code>.

	===Encoder maximum frequency===		===Encoder maximum frequency===

JL: /* Encoder maximum frequency */ +new section: Missed index pulses

2021-08-31T15:59:30Z

Encoder maximum frequency: +new section: Missed index pulses

← Older revision		Revision as of 10:59, 31 August 2021
Line 985:		Line 985:
	\| (S826_SSRMASK_MATCH0 << 16), // disable subsequent Match0 snapshots upon Match0		\| (S826_SSRMASK_MATCH0 << 16), // disable subsequent Match0 snapshots upon Match0
	S826_BITWRITE); // disable all other snapshot triggers		S826_BITWRITE); // disable all other snapshot triggers

			===Missed index pulses===

			:''Why do I occasionally miss index pulses?''

			Pulses on the IX input will be properly detected if they conform to the signal timing and voltage specifications. To resolve this problem, check the following:
			* View the IX input signals with an oscilloscope. Verify that the pulse duration is greater than 20 ns, and that the signal voltage transitions between valid logic levels.
			* Make sure the IX noise filter is disabled. When the IX filter is enabled, the filter will reject index pulses that are too short. The IX noise filter is disabled by default at power-up. If previously enabled by software, the noise filter can be disabled by calling <code>S826_CounterFilterWrite</code>.

	===Encoder maximum frequency===		===Encoder maximum frequency===

JL: /* Serial data capture (asynchronous) */

2021-04-05T18:58:23Z

Serial data capture (asynchronous)

← Older revision		Revision as of 13:58, 5 April 2021
Line 1,296:		Line 1,296:

	For maximum efficiency, consider using a dedicated thread to read the FIFO. This eliminates polling and makes the application event-driven because the thread can wait in <code>S826_CounterSnapshotRead()</code> for the next snapshot without wasting CPU time. Also, this decouples the timing of serial data acquisition from other tasks, thereby greatly simplifying overall software development and maintenance. If fast processing of the serial data is required, raise the thread priority to an appropriately high level.		For maximum efficiency, consider using a dedicated thread to read the FIFO. This eliminates polling and makes the application event-driven because the thread can wait in <code>S826_CounterSnapshotRead()</code> for the next snapshot without wasting CPU time. Also, this decouples the timing of serial data acquisition from other tasks, thereby greatly simplifying overall software development and maintenance. If fast processing of the serial data is required, raise the thread priority to an appropriately high level.

			For some example code, see [[826 example: async capture]].

	===Serial data capture (synchronous)===		===Serial data capture (synchronous)===

JL: /* Connector pinouts */

2021-01-29T16:28:56Z

Connector pinouts

← Older revision		Revision as of 11:28, 29 January 2021
Line 5:		Line 5:
	==Connector pinouts==		==Connector pinouts==

	<gallery heights=~~350px~~ widths=180px perrow=3>		<gallery heights=250px widths=180px perrow=3>
	File:826 pinout J4.gif		File:826 pinout J4.gif
	File:826 pinout J5.gif		File:826 pinout J5.gif

JL: /* Interfacing touch-trigger probes */

2021-01-29T16:19:34Z

Interfacing touch-trigger probes

← Older revision		Revision as of 11:19, 29 January 2021
Line 748:		Line 748:
	Touch-trigger probes (such as those made by Renishaw, Tormach, Marposs, etc.) are commonly used in CNC machine tools and coordinate measuring machines (CMMs). In a typical application, three or more incremental encoders monitor the position of a probe relative to a workpiece as the probe or workpiece is moved. The probe will output a digital signal when its stylus contacts the workpiece. When this happens, the stylus location must be determined by sampling all of the encoder counters.		Touch-trigger probes (such as those made by Renishaw, Tormach, Marposs, etc.) are commonly used in CNC machine tools and coordinate measuring machines (CMMs). In a typical application, three or more incremental encoders monitor the position of a probe relative to a workpiece as the probe or workpiece is moved. The probe will output a digital signal when its stylus contacts the workpiece. When this happens, the stylus location must be determined by sampling all of the encoder counters.

	At lower ~~traverse~~ speeds and in cases where moderate accuracy is acceptable, a probe-triggered interrupt service routine (ISR) can be used to sequentially sample the counters. This is feasible because ~~ISR overhead and~~ ISR-~~induced~~ measurement errors (due to trigger latency and sampling skew) are negligible in such cases. However, these ~~issues become~~ significant when high accuracy and throughput is required. Consequently, in high-performance machines a hardware mechanism is needed that will simultaneously sample all counters with very low trigger latency.		At lower speeds and in cases where moderate accuracy is acceptable, a probe-triggered interrupt service routine (ISR) can be used to sequentially sample the counters. This is feasible because ISR-related measurement errors (due to trigger latency and sampling skew) are negligible in such cases. However, these errors can be significant when high accuracy and throughput is required. Consequently, in high-performance machines a hardware mechanism is needed that will simultaneously sample all counters with very low trigger latency.

	====High-performance measurement====		====High-performance measurement====

JL: /* Interfacing touch-trigger probes */

2021-01-29T16:15:10Z

Interfacing touch-trigger probes

← Older revision		Revision as of 11:15, 29 January 2021
Line 746:		Line 746:

	[[File:TouchProbe.jpg\|thumb\|A touch-trigger probe]]		[[File:TouchProbe.jpg\|thumb\|A touch-trigger probe]]
	Touch-trigger probes (such as those made by Renishaw, Tormach, Marposs, etc.) are commonly used in CNC machine tools and coordinate measuring machines (CMMs). In a typical application, three or more incremental encoders monitor the position of a probe ~~as it moves~~ relative to a workpiece. The probe will output a digital signal when its stylus contacts the workpiece. When this happens, the stylus location must be determined by sampling all of the encoder counters.		Touch-trigger probes (such as those made by Renishaw, Tormach, Marposs, etc.) are commonly used in CNC machine tools and coordinate measuring machines (CMMs). In a typical application, three or more incremental encoders monitor the position of a probe relative to a workpiece as the probe or workpiece is moved. The probe will output a digital signal when its stylus contacts the workpiece. When this happens, the stylus location must be determined by sampling all of the encoder counters.

	At lower traverse speeds and in cases where moderate accuracy is acceptable, a probe-triggered interrupt service routine (ISR) can be used to sequentially sample the counters. This is feasible because ISR overhead and ISR-induced measurement errors (due to trigger latency and sampling skew) are negligible in such cases. However, these issues become significant when high accuracy and throughput is required. Consequently, in high-performance machines a hardware mechanism is needed that will simultaneously sample all counters with very low trigger latency.		At lower traverse speeds and in cases where moderate accuracy is acceptable, a probe-triggered interrupt service routine (ISR) can be used to sequentially sample the counters. This is feasible because ISR overhead and ISR-induced measurement errors (due to trigger latency and sampling skew) are negligible in such cases. However, these issues become significant when high accuracy and throughput is required. Consequently, in high-performance machines a hardware mechanism is needed that will simultaneously sample all counters with very low trigger latency.