SerialWombatPython/SerialWombatSimulatedQuadEnc.py at main · BroadwellConsultingInc/SerialWombatPython · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
import SerialWombat
from SerialWombatPin import SerialWombatPin
#from SerialWombat import SW_LE32
#from enum import IntEnum
import time
import SW18B_UnitTest_globals
#include <stdint.h>
#include "SerialWombat.h"


SIMQE_IDLE = 0,
SIMQE_1ST_TRANSITION_1ST_PIN_COMPLETED =1 ,
SIMQE_1ST_TRANSITION_2ND_PIN_COMPLETED = 2,
SIMQE_2ND_TRANSITION_1ST_PIN_COMPLETED = 3,
SIMQE_2ND_TRANSITION_2ND_PIN_COMPLETED = 4,
SIMQE_2ND_TRANSITION_COMPLETED = 4


"""! \brief A class for testing SerialWombatQuadEnc inputs.

This class uses digital IO calls to simulate the output of a quadrature encoder.  This is used to unit test
the SerialWombatQuadEnc class.  All processing occurs on the Arduino side.  This class does not currently
wrap a pin mode on the Serial Wombat chip.  See the Unit Test example sketch for usage.

"""
class SerialWombatSimulatedQuadEnc:
	def __init__(self, serialWombat0, serialWombat1, _pin0, _pin1, _openDrain, _doubleTransition):

		self.doubleTransition = False
		self.state = SIMQE_IDLE

		self.currentPosition = 0
		self.targetPosition = 0
		self.delayAfterFirstPinFirstTransition_mS = 20
		self.delayAfterSecondPinFirstTransition_mS = 20
		self.delayAfterFirstPinSecondTransition_mS = 20
		self.delayAfterSecondPinSecondTransition_mS = 20
		self.openDrain = True
		self.lastTransitionTime_millis = 0

		self.pin0State = True
		self.pin1State = True
		self.pin0 = _pin0
		self.pin1 = _pin1
		self.openDrain = _openDrain
		self.doubleTransition = _doubleTransition

		self.sw0 = serialWombat0
		self.sw1 = serialWombat1

		self.millisStart = SW18B_UnitTest_globals.ticks_ms()
		self.initialize()


	def millis(self):
		return(int(SW18B_UnitTest_globals.ticks_ms() - self.millisStart))
	def bothPinsHigh(self):
		self.pin0High()
		self.pin1High()

	def togglePin0(self):
		if (self.pin0State):
			self.pin0Low()
		else:
			self.pin0High()

	def togglePin1(self):
		if (self.pin1State):
			self.pin1Low()
		else:
			self.pin1High()

	def pin0High(self):
		self.sw0.digitalWrite(self.pin0, 1)
		self.pin0State = True

	def pin1High(self):
		self.sw1.digitalWrite(self.pin1, 1)
		self.pin1State = True


	def pin0Low(self):
		self.sw0.digitalWrite(self.pin0, 0)
		self.pin0State = False

	def pin1Low(self):
		self.sw1.digitalWrite(self.pin1, 0)
		self.pin1State = False

	def service(self):
		if (self.currentPosition != self.targetPosition):
			if (self.state == SIMQE_IDLE):
				if (self.currentPosition != self.targetPosition):
					self.lastTransitionTime_millis = self.millis()
					if (self.currentPosition < self.targetPosition):
						self.togglePin0()
					else :
						self.togglePin1()
					self.state = SIMQE_1ST_TRANSITION_1ST_PIN_COMPLETED

			if (self.state == SIMQE_1ST_TRANSITION_1ST_PIN_COMPLETED):
				if (self.millis() > self.lastTransitionTime_millis + self.delayAfterFirstPinFirstTransition_mS):
					self.lastTransitionTime_millis = self.millis()
					if (self.currentPosition < self.targetPosition):
						self.togglePin1()
						if (not self.doubleTransition):
							self.currentPosition += 1
					else:
						self.togglePin0()
						if (not self.doubleTransition):
							self.currentPosition -= 1


					self.state = SIMQE_1ST_TRANSITION_2ND_PIN_COMPLETED

			if (self.state == SIMQE_1ST_TRANSITION_2ND_PIN_COMPLETED):
				if (self.millis() > self.lastTransitionTime_millis + self.delayAfterFirstPinSecondTransition_mS):
					if (self.doubleTransition):
						self.lastTransitionTime_millis = self.millis()
						if (self.currentPosition < self.targetPosition):
							self.togglePin0()
						else:
							self.togglePin1()

							self.state = SIMQE_2ND_TRANSITION_2ND_PIN_COMPLETED
					else:
						self.state = SIMQE_IDLE
			if (self.state == SIMQE_2ND_TRANSITION_1ST_PIN_COMPLETED):
				if (self.millis() > self.lastTransitionTime_millis + self.delayAfterSecondPinFirstTransition_mS):
					self.lastTransitionTime_millis = self.millis()
					if (self.currentPosition < self.targetPosition):
						self.togglePin1()
						self.currentPosition += 1
					else:
						self.togglePin0()
						self.currentPosition -= 1

					self.state = SIMQE_1ST_TRANSITION_2ND_PIN_COMPLETED

			if (self.state == SIMQE_2ND_TRANSITION_2ND_PIN_COMPLETED):
				if (self.millis() > self.lastTransitionTime_millis + self.delayAfterFirstPinSecondTransition_mS):
						self.state = SIMQE_IDLE
		return (self.state == SIMQE_IDLE)


	def initialize(self):
			self.sw0.pinMode(self.pin0, 1, False, self.openDrain)
			self.sw1.pinMode(self.pin1, 1, False, self.openDrain)
			self.bothPinsHigh()
			self.currentPosition = 0
			self.targetPosition = 0
			self.lastTransitionTime_millis = 0