FreeEMS  0.2.0-SNAPSHOT-285-g028e24c
MitsiAndMazda-CAS-4and1.c
Go to the documentation of this file.
1 /* FreeEMS - the open source engine management system
2  *
3  * Copyright 2011-2013 Fred Cooke
4  *
5  * This file is part of the FreeEMS project.
6  *
7  * FreeEMS software is free software: you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation, either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * FreeEMS software is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with any FreeEMS software. If not, see http://www.gnu.org/licenses/
19  *
20  * We ask that if you make any changes to this file you email them upstream to
21  * us at admin(at)diyefi(dot)org or, even better, fork the code on github.com!
22  *
23  * Thank you for choosing FreeEMS to run your engine!
24  */
25 
26 
27 #define DECODER_IMPLEMENTATION_C
28 
29 #include "inc/MitsiAndMazda-CAS-4and1.h"
30 
31 void decoderInitPreliminary(){} // This decoder works with the defaults
32 void perDecoderReset(){
33  unknownLeadingEdges = 0;
34 }
35 
36 
37 /** @file
38  *
39  * @ingroup interruptHandlers
40  * @ingroup enginePositionRPMDecoders
41  *
42  * @brief Reads Mitsi 4 and 1 CAS units
43  *
44  * Two interrupts share state and cross communicate to
45  * find and maintain sync and position information.
46  *
47  * Development thread: http://forum.diyefi.org/viewtopic.php?f=56&t=1078
48  */
49 
50 
51 void PrimaryRPMISR(){
52  /* Clear the interrupt flag for this input compare channel */
53  TFLG = 0x01;
54  DEBUG_TURN_PIN_ON(DECODER_BENCHMARKS, BIT0, PORTB);
55 
56  /* Save all relevant available data here */
57  edgeTimeStamp = TC0; /* Save the edge time stamp */
58  unsigned char PTITCurrentState = PTIT; /* Save the values on port T regardless of the state of DDRT */
59 
60  KeyUserDebugs.primaryTeethSeen++;
61 
62  /* Install the low word */
63  timeStamp.timeShorts[1] = edgeTimeStamp;
64  /* Find out what our timer value means and put it in the high word */
65  if(TFLGOF && !(edgeTimeStamp & 0x8000)){ /* see 10.3.5 paragraph 4 of 68hc11 ref manual for details */
66  timeStamp.timeShorts[0] = timerExtensionClock + 1;
67  }else{
68  timeStamp.timeShorts[0] = timerExtensionClock;
69  }
70  unsigned long thisEventTimeStamp = timeStamp.timeLong;
71 
72  unsigned long thisInterEventPeriod = 0;
73  if(KeyUserDebugs.decoderFlags & LAST_TIMESTAMP_VALID){
74  thisInterEventPeriod = thisEventTimeStamp - lastEventTimeStamp;
75  }
76 
77  // Pins 0, 2, 4 and 7 - no need to check for numbers, just always do on rising edge and only in primary isr
78  // Always sample in this ISR
79  sampleEachADC(ADCBuffers);
80  Counters.syncedADCreadings++;
81 
82  // Set flag to say calc required
83  coreStatusA |= CALC_FUEL_IGN;
84 
85  // Reset the clock for reading timeout
86  Clocks.timeoutADCreadingClock = 0;
87 
88  // Determine the correct event based on post transition state
89  unsigned char correctEvent = 0;
90  if(PTITCurrentState & 0x01){
91  if(!(PTITCurrentState & 0x02)){
92  correctEvent = 8;
93  }
94  }else{
95  if(PTITCurrentState & 0x02){
96  unknownLeadingEdges++;
97  if(unknownLeadingEdges == 3){
98  correctEvent = 4;
99  }
100  }else{
101  correctEvent = 7;
102  unknownLeadingEdges = 0;
103  }
104  }
105 
106  unsigned char lastEvent = 0;
107  if(KeyUserDebugs.decoderFlags & CAM_SYNC){
108  lastEvent = KeyUserDebugs.currentEvent;
109  KeyUserDebugs.currentEvent++;
110  if(KeyUserDebugs.currentEvent == numberOfRealEvents){
111  KeyUserDebugs.currentEvent = 0;
112  }
113 
114  // ...and, if known, check that it's correct
115  if(correctEvent != 0){
116  if(KeyUserDebugs.currentEvent != correctEvent){
117  resetToNonRunningState(STATE_MISMATCH_IN_PRIMARY_RPM_ISR);
118  return;
119  }else if(!(KeyUserDebugs.decoderFlags & OK_TO_SCHEDULE)){
120  SET_SYNC_LEVEL_TO(CAM_SYNC);
121  } // Else do nothing, we're running!
122  }
123  }else if(correctEvent != 0){
124  KeyUserDebugs.currentEvent = correctEvent;
125  lastEvent = KeyUserDebugs.currentEvent - 1;
126  SET_SYNC_LEVEL_TO(CAM_SYNC);
127  }
128 
129  unsigned short thisTicksPerDegree = 0;
130  if(KeyUserDebugs.decoderFlags & CAM_SYNC){
131  unsigned short thisAngle = 0;
132  if(KeyUserDebugs.currentEvent == 0){
133  thisAngle = eventAngles[KeyUserDebugs.currentEvent] + totalEventAngleRange - eventAngles[lastEvent] ; // Optimisable... leave readable for now! :-p J/K learn from this...
134  }else{
135  thisAngle = eventAngles[KeyUserDebugs.currentEvent] - eventAngles[lastEvent];
136  }
137 
138  thisTicksPerDegree = (unsigned short)((ticks_per_degree_multiplier * thisInterEventPeriod) / thisAngle); // with current scale range for 60/12000rpm is largest ticks per degree = 3472, smallest = 17 with largish error
139 
140  if(KeyUserDebugs.decoderFlags & LAST_PERIOD_VALID){
141  unsigned short ratioBetweenThisAndLast = (unsigned short)(((unsigned long)lastTicksPerDegree * 1000) / thisTicksPerDegree);
142  KeyUserDebugs.inputEventTimeTolerance = ratioBetweenThisAndLast;
143  if(ratioBetweenThisAndLast > fixedConfigs2.decoderSettings.decelerationInputEventTimeTolerance){
144  resetToNonRunningState(PRIMARY_EVENT_ARRIVED_TOO_LATE);
145  return;
146  }else if(ratioBetweenThisAndLast < fixedConfigs2.decoderSettings.accelerationInputEventTimeTolerance){
147  resetToNonRunningState(PRIMARY_EVENT_ARRIVED_TOO_EARLY);
148  return;
149  }else{
150  if(PTITCurrentState & 0x01){
151  // TODO Calculate RPM from last primaryLeadingEdgeTimeStamp
152  }else{
153  // TODO Calculate RPM from last primaryTrailingEdgeTimeStamp
154  }
155  }
156  }/*else*/ if(KeyUserDebugs.decoderFlags & LAST_TIMESTAMP_VALID){ // TODO temp for testing just do rpm this way, fill above out later.
157  *ticksPerDegreeRecord = thisTicksPerDegree;
158  }
159  }
160 
161  SCHEDULE_ECT_OUTPUTS();
162 
163  OUTPUT_COARSE_BBS();
164 
165  if(KeyUserDebugs.decoderFlags & LAST_TIMESTAMP_VALID){
166  lastTicksPerDegree = thisTicksPerDegree;
167  KeyUserDebugs.decoderFlags |= LAST_PERIOD_VALID;
168  }
169  // Always
170  lastEventTimeStamp = thisEventTimeStamp;
171  KeyUserDebugs.decoderFlags |= LAST_TIMESTAMP_VALID;
172 
173  DEBUG_TURN_PIN_OFF(DECODER_BENCHMARKS, NBIT0, PORTB);
174 }
175 
176 
177 void SecondaryRPMISR(){
178  // Reads the inner slot on the disk.
179 
180  /* Clear the interrupt flag for this input compare channel */
181  TFLG = 0x02;
182  DEBUG_TURN_PIN_ON(DECODER_BENCHMARKS, BIT1, PORTB);
183 
184  /* Save all relevant available data here */
185  edgeTimeStamp = TC1; /* Save the timestamp */
186  unsigned char PTITCurrentState = PTIT; /* Save the values on port T regardless of the state of DDRT */
187 
188  KeyUserDebugs.secondaryTeethSeen++;
189  // remember that this is both edges, though... 8 per cycle, 4 per rev for the outter wheel, 2/1 for this wheel.
190 
191  /* Install the low word */
192  timeStamp.timeShorts[1] = edgeTimeStamp;
193  /* Find out what our timer value means and put it in the high word */
194  if(TFLGOF && !(edgeTimeStamp & 0x8000)){ /* see 10.3.5 paragraph 4 of 68hc11 ref manual for details */
195  timeStamp.timeShorts[0] = timerExtensionClock + 1;
196  }else{
197  timeStamp.timeShorts[0] = timerExtensionClock;
198  }
199  unsigned long thisEventTimeStamp = timeStamp.timeLong;
200 
201  unsigned long thisInterEventPeriod = 0;
202  if(KeyUserDebugs.decoderFlags & LAST_TIMESTAMP_VALID){
203  thisInterEventPeriod = thisEventTimeStamp - lastEventTimeStamp;
204  }
205 
206  // Determine the correct event based on post transition state (and toggle debug pins)
207  unsigned char correctEvent;
208  if(PTITCurrentState & 0x02){
209  correctEvent = 9;
210  }else{
211  correctEvent = 6;
212  }
213 
214  // Only sample if not synced, cleans up readings.
215  if(!(KeyUserDebugs.decoderFlags & CAM_SYNC)){
216  sampleEachADC(ADCBuffers);
217  Counters.syncedADCreadings++;
218 
219  // Set flag to say calc required
220  coreStatusA |= CALC_FUEL_IGN;
221 
222  // Reset the clock for reading timeout
223  Clocks.timeoutADCreadingClock = 0;
224  }
225 
226  unsigned char lastEvent = 0;
227  if(KeyUserDebugs.decoderFlags & CAM_SYNC){
228  lastEvent = KeyUserDebugs.currentEvent;
229  KeyUserDebugs.currentEvent++;
230 
231  // ...and check that it's correct
232  if(KeyUserDebugs.currentEvent != correctEvent){
233  resetToNonRunningState(STATE_MISMATCH_IN_SECONDARY_RPM_ISR);
234  return;
235  }else if(!(KeyUserDebugs.decoderFlags & OK_TO_SCHEDULE)){
236  SET_SYNC_LEVEL_TO(CAM_SYNC);
237  } // Else do nothing, we're running!
238  }else{ // If not synced, sync, as in this ISR we always know where we are.
239  KeyUserDebugs.currentEvent = correctEvent;
240  lastEvent = KeyUserDebugs.currentEvent - 1;
241  SET_SYNC_LEVEL_TO(CAM_SYNC);
242  }
243 
244  unsigned short thisTicksPerDegree = 0;
245  if(KeyUserDebugs.decoderFlags & CAM_SYNC){
246  unsigned short thisAngle = eventAngles[KeyUserDebugs.currentEvent] - eventAngles[lastEvent];
247 
248  thisTicksPerDegree = (unsigned short)((ticks_per_degree_multiplier * thisInterEventPeriod) / thisAngle); // with current scale range for 60/12000rpm is largest ticks per degree = 3472, smallest = 17 with largish error
249 
250  if(KeyUserDebugs.decoderFlags & LAST_PERIOD_VALID){
251  unsigned short ratioBetweenThisAndLast = (unsigned short)(((unsigned long)lastTicksPerDegree * 1000) / thisTicksPerDegree);
252  KeyUserDebugs.inputEventTimeTolerance = ratioBetweenThisAndLast;
253  if(ratioBetweenThisAndLast > fixedConfigs2.decoderSettings.decelerationInputEventTimeTolerance){
254  resetToNonRunningState(SECONDARY_EVENT_ARRIVED_TOO_LATE);
255  return;
256  }else if(ratioBetweenThisAndLast < fixedConfigs2.decoderSettings.accelerationInputEventTimeTolerance){
257  resetToNonRunningState(SECONDARY_EVENT_ARRIVED_TOO_EARLY);
258  return;
259  }
260  }/*else*/ if(KeyUserDebugs.decoderFlags & LAST_TIMESTAMP_VALID){
261  *ticksPerDegreeRecord = thisTicksPerDegree;
262  }
263  }
264 
265  SCHEDULE_ECT_OUTPUTS();
266 
267  OUTPUT_COARSE_BBS();
268 
269  if(KeyUserDebugs.decoderFlags & LAST_TIMESTAMP_VALID){
270  lastTicksPerDegree = thisTicksPerDegree;
271  KeyUserDebugs.decoderFlags |= LAST_PERIOD_VALID;
272  }
273  // Always
274  lastEventTimeStamp = thisEventTimeStamp;
275  KeyUserDebugs.decoderFlags |= LAST_TIMESTAMP_VALID;
276 
277  DEBUG_TURN_PIN_OFF(DECODER_BENCHMARKS, NBIT1, PORTB);
278 }
Generated on Sat Jun 6 2015 07:41:33 for FreeEMS by   doxygen 1.8.1.2