rusEFI
The most advanced open source ECU
Loading...
Searching...
No Matches
Functions
trigger_mazda.cpp File Reference

Detailed Description

Date
Feb 18, 2014
Author
Andrey Belomutskiy, (c) 2012-2020

This file is part of rusEfi - see http://rusefi.com

rusEfi is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version.

rusEfi is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Definition in file trigger_mazda.cpp.

Functions

void initializeMazdaMiataNaShape (TriggerWaveform *s)
 
void initializeMazdaMiataNb2Crank (TriggerWaveform *s)
 
static void addNBCrankTooth (TriggerWaveform *s, angle_t angle)
 
static void initializeMazdaMiataNb1ShapeWithOffset (TriggerWaveform *s, float offset)
 
void initializeMazdaMiataVVtTestShape (TriggerWaveform *s)
 
void configureMazdaProtegeSOHC (TriggerWaveform *s)
 
void configureMazdaProtegeLx (TriggerWaveform *s)
 
void initializeMazdaMiataVVtCamShape (TriggerWaveform *s)
 
void initializeMazdaSkyactivCam (TriggerWaveform *s)
 
void initializeMazdaLCam (TriggerWaveform *s)
 

Function Documentation

◆ addNBCrankTooth()

static void addNBCrankTooth ( TriggerWaveform *  s,
angle_t  angle 
)
static

Definition at line 81 of file trigger_mazda.cpp.

81 {
82 s->addToothRiseFall(angle / 2 + 2, 2, TriggerWheel::T_SECONDARY);
83}
TriggerWaveform::addToothRiseFall
void addToothRiseFall(angle_t angle, angle_t width=10, TriggerWheel const channelIndex=TriggerWheel::T_PRIMARY)
Definition trigger_structure.cpp:256
TriggerWheel::T_SECONDARY
@ T_SECONDARY

Referenced by initializeMazdaMiataNb1ShapeWithOffset().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ configureMazdaProtegeLx()

void configureMazdaProtegeLx ( TriggerWaveform *  s)

based on https://svn.code.sf.net/p/rusefi/code/trunk/misc/logs/1993_escort_gt/MAIN_rfi_report_2015-02-01%2017_39.csv

Definition at line 138 of file trigger_mazda.cpp.

138 {
139 s->initialize(FOUR_STROKE_CAM_SENSOR, SyncEdge::RiseOnly);
140 s->isSecondWheelCam = true;
141 /**
142 * based on https://svn.code.sf.net/p/rusefi/code/trunk/misc/logs/1993_escort_gt/MAIN_rfi_report_2015-02-01%2017_39.csv
143 */
144 s->addEvent720(95.329254, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
145
146 s->addEvent720(95.329254 + 14.876692, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
147 s->addEvent720(178.022811, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
148
149 s->addEvent720(95.329254 + 137.119154, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
150
151 s->addEvent720(95.329254 + 192.378308, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
152 s->addEvent720(356.885672, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
153
154 s->addEvent720(95.329254 + 373.060597, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
155 s->addEvent720(538.832438, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
156
157 s->addEvent720(720-69.32097, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
158 s->addEvent720(720, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
159
160 s->tdcPosition = 137.119154;
161 s->isSynchronizationNeeded = false;
162}
TriggerWaveform::initialize
void initialize(operation_mode_e operationMode, SyncEdge syncEdge)
Definition trigger_structure.cpp:65
TriggerWaveform::addEvent720
void addEvent720(angle_t angle, TriggerValue const state, TriggerWheel const channelIndex=TriggerWheel::T_PRIMARY)
Definition trigger_structure.cpp:246
FOUR_STROKE_CAM_SENSOR
@ FOUR_STROKE_CAM_SENSOR
Definition rusefi_enums.h:275
TriggerWheel::T_PRIMARY
@ T_PRIMARY
TriggerValue::RISE
@ RISE
TriggerValue::FALL
@ FALL
SyncEdge::RiseOnly
@ RiseOnly

Referenced by TriggerWaveform::initializeTriggerWaveform().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ configureMazdaProtegeSOHC()

void configureMazdaProtegeSOHC ( TriggerWaveform *  s)

Definition at line 120 of file trigger_mazda.cpp.

120 {
121 s->initialize(FOUR_STROKE_CAM_SENSOR, SyncEdge::Both);
122
123 float z = 0.093;
124 float a = 90;
125 s->addToothRiseFall(a, z * 360);
126
127 a += 90;
128 s->addToothRiseFall(a, z * 360);
129 a += 90;
130 s->addToothRiseFall(a, z * 360);
131 a += 90;
132 s->addToothRiseFall(a, z * 360);
133
134 s->isSynchronizationNeeded = false;
135 s->shapeWithoutTdc = true;
136}
SyncEdge::Both
@ Both

Referenced by TriggerWaveform::initializeTriggerWaveform().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ initializeMazdaLCam()

void initializeMazdaLCam ( TriggerWaveform *  s)

Definition at line 204 of file trigger_mazda.cpp.

204 {
205 s->initialize(FOUR_STROKE_CAM_SENSOR, SyncEdge::RiseOnly);
206
207 // 6 teeth:
208 // 0, 60, 90, 150, 180, 270
209 // Tooth at 0 is just before #1 TDC
210
211 // 60
212 s->addEvent360(50, TriggerValue::RISE);
213 s->addEvent360(60, TriggerValue::FALL);
214
215 // 90
216 s->addEvent360(80, TriggerValue::RISE);
217 s->addEvent360(90, TriggerValue::FALL);
218
219 // 150
220 s->addEvent360(140, TriggerValue::RISE);
221 s->addEvent360(150, TriggerValue::FALL);
222
223 // 180
224 s->addEvent360(170, TriggerValue::RISE);
225 s->addEvent360(180, TriggerValue::FALL);
226
227 // 270
228 s->addEvent360(260, TriggerValue::RISE);
229 s->addEvent360(270, TriggerValue::FALL);
230
231 // 0 (aka 360)
232 s->addEvent360(350, TriggerValue::RISE);
233 s->addEvent360(360, TriggerValue::FALL);
234
235 s->setTriggerSynchronizationGap3(0, 0.32, 0.8);
236 s->setTriggerSynchronizationGap3(1, 1.5, 2.5);
237 s->setTriggerSynchronizationGap3(2, 0.32, 0.8);
238}
TriggerWaveform::addEvent360
void addEvent360(angle_t angle, TriggerValue const state, TriggerWheel const channelIndex=TriggerWheel::T_PRIMARY)
Definition trigger_structure.cpp:250
TriggerWaveform::setTriggerSynchronizationGap3
void setTriggerSynchronizationGap3(int index, float syncRatioFrom, float syncRatioTo)
Definition trigger_structure.cpp:371

Referenced by TriggerWaveform::initializeTriggerWaveform().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ initializeMazdaMiataNaShape()

void initializeMazdaMiataNaShape ( TriggerWaveform *  s)

http://rusefi.com/forum/viewtopic.php?f=3&t=729&p=12983#p12983

Definition at line 27 of file trigger_mazda.cpp.

27 {
28 s->initialize(FOUR_STROKE_CAM_SENSOR, SyncEdge::Both);
29 s->isSecondWheelCam = true;
30
31 // nominal gap is 0.325
32 s->setTriggerSynchronizationGap2(0.1, 0.5);
33 // nominal gap is ~1.52
34 s->setSecondTriggerSynchronizationGap2(0.5, 2.3);
35
36 s->tdcPosition = 5.181;
37
38 /**
39 * http://rusefi.com/forum/viewtopic.php?f=3&t=729&p=12983#p12983
40 */
41 s->addEvent720(52.960405, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
42 s->addEvent720(122.635956, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
43
44 s->addEvent720(216.897031, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
45 s->addEvent720(232.640068, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
46 s->addEvent720(288.819688, TriggerValue::FALL, TriggerWheel::T_PRIMARY); // <-- This edge is the sync point
47 s->addEvent720(302.646323, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
48
49 s->addEvent720(412.448056, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
50 s->addEvent720(482.816719, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
51
52 s->addEvent720(577.035495, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
53 s->addEvent720(592.878113, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
54 s->addEvent720(662.899708, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
55 s->addEvent720(720.0f, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
56 s->useOnlyPrimaryForSync = true;
57}
TriggerWaveform::setSecondTriggerSynchronizationGap2
void setSecondTriggerSynchronizationGap2(float syncRatioFrom, float syncRatioTo)
Definition trigger_structure.cpp:431
TriggerWaveform::setTriggerSynchronizationGap2
void setTriggerSynchronizationGap2(float syncRatioFrom, float syncRatioTo)
Definition trigger_structure.cpp:367

Referenced by TriggerWaveform::initializeTriggerWaveform().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ initializeMazdaMiataNb1ShapeWithOffset()

static void initializeMazdaMiataNb1ShapeWithOffset ( TriggerWaveform *  s,
float  offset 
)
static

cam sensor is primary, crank sensor is secondary

Definition at line 85 of file trigger_mazda.cpp.

85 {
86 s->initialize(FOUR_STROKE_CAM_SENSOR, SyncEdge::Fall);
87 s->setTriggerSynchronizationGap3(0, 0.065, 0.17f);
88 s->useOnlyPrimaryForSync = true;
89
90 s->tdcPosition = 276;
91
92 /**
93 * cam sensor is primary, crank sensor is secondary
94 */
95 s->addEvent720(20.0f, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
96
97 addNBCrankTooth(s, offset + 66.0f);
98 addNBCrankTooth(s, offset + 66.0f + NB_CRANK_MAGIC);
99 addNBCrankTooth(s, offset + 66.0f + 180);
100 addNBCrankTooth(s, offset + 66.0f + 180 + NB_CRANK_MAGIC);
101
102 s->addEvent720(340.0f, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
103 s->addEvent720(360.0f, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
104
105 s->addEvent720(380.0f, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
106 s->addEvent720(400.0f, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
107
108 addNBCrankTooth(s, offset + 66.0f + 360);
109 addNBCrankTooth(s, offset + 66.0f + 360 + NB_CRANK_MAGIC);
110 addNBCrankTooth(s, offset + 66.0f + 540);
111 addNBCrankTooth(s, offset + 66.0f + 540 + NB_CRANK_MAGIC);
112
113 s->addEvent720(720.0f, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
114}
SyncEdge::Fall
@ Fall
addNBCrankTooth
static void addNBCrankTooth(TriggerWaveform *s, angle_t angle)
Definition trigger_mazda.cpp:81
offset
uint16_t offset
Definition tunerstudio.h:0

Referenced by initializeMazdaMiataVVtTestShape().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ initializeMazdaMiataNb2Crank()

void initializeMazdaMiataNb2Crank ( TriggerWaveform *  s)

Note how we use 0..180 range while defining FOUR_STROKE_SYMMETRICAL_CRANK_SENSOR trigger Note that only half of the physical wheel is defined here!

Definition at line 60 of file trigger_mazda.cpp.

60 {
61 /**
62 * Note how we use 0..180 range while defining FOUR_STROKE_SYMMETRICAL_CRANK_SENSOR trigger
63 * Note that only half of the physical wheel is defined here!
64 */
65 s->initialize(FOUR_STROKE_SYMMETRICAL_CRANK_SENSOR, SyncEdge::RiseOnly);
66
67 s->tdcPosition = 60 + 655;
68
69 // Nominal gap 70/110 = 0.636
70 s->setTriggerSynchronizationGap2(0.35f, 1.15f);
71 // Nominal gap 110/70 = 1.571
72 s->setSecondTriggerSynchronizationGap2(0.8f, 1.8f);
73
74 // todo: NB2 fronts are inverted comparing to NB1, life is not perfect :(
75 s->addEventAngle(180.0f - NB_CRANK_MAGIC - 4, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
76 s->addEventAngle(180.0f - NB_CRANK_MAGIC, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
77 s->addEventAngle(180.0f - 4, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
78 s->addEventAngle(180.0f, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
79}
TriggerWaveform::addEventAngle
void addEventAngle(angle_t angle, TriggerValue const state, TriggerWheel const channelIndex=TriggerWheel::T_PRIMARY)
Definition trigger_structure.cpp:266
FOUR_STROKE_SYMMETRICAL_CRANK_SENSOR
@ FOUR_STROKE_SYMMETRICAL_CRANK_SENSOR
Definition rusefi_enums.h:285

Referenced by TriggerWaveform::initializeTriggerWaveform().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ initializeMazdaMiataVVtCamShape()

void initializeMazdaMiataVVtCamShape ( TriggerWaveform *  s)

TT_VVT_MIATA_NB2 if you unplug crank sensor you can start & run your engine on just this cam decoder trigger offset "-90" seems to be doing the job

same decoder is used for VVT processing

Definition at line 164 of file trigger_mazda.cpp.

164 {
165 s->initialize(FOUR_STROKE_CAM_SENSOR, SyncEdge::RiseOnly);
166
167 // Nominal gap is 8.92
168 s->setTriggerSynchronizationGap2(6, 20);
169 // Nominal gap is 0.128
170 s->setSecondTriggerSynchronizationGap2(0.04f, 0.2f);
171
172 s->addEvent720(325, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
173 s->addEvent720(360, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
174
175 s->addEvent720(641, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
176 s->addEvent720(679, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
177
178 s->addEvent720(700, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
179 s->addEvent720(720, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
180}

Referenced by TriggerWaveform::initializeTriggerWaveform().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ initializeMazdaMiataVVtTestShape()

void initializeMazdaMiataVVtTestShape ( TriggerWaveform *  s)

Definition at line 116 of file trigger_mazda.cpp.

116 {
117 initializeMazdaMiataNb1ShapeWithOffset(s, -22);
118}
initializeMazdaMiataNb1ShapeWithOffset
static void initializeMazdaMiataNb1ShapeWithOffset(TriggerWaveform *s, float offset)
Definition trigger_mazda.cpp:85

Referenced by TriggerWaveform::initializeTriggerWaveform().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ initializeMazdaSkyactivCam()

void initializeMazdaSkyactivCam ( TriggerWaveform *  s)

Definition at line 184 of file trigger_mazda.cpp.

184 {
185 s->initialize(FOUR_STROKE_CAM_SENSOR, SyncEdge::RiseOnly);
186
187 int wide = 20;
188 int narrow = 10;
189
190 s->addToothRiseFall(70, wide);
191 s->addToothRiseFall(90, narrow);
192
193 s->addToothRiseFall(160, wide);
194 s->addToothRiseFall(180, narrow);
195
196 s->addToothRiseFall(270, wide);
197 s->addToothRiseFall(360, wide);
198
199 s->setTriggerSynchronizationGap(0.43);
200 s->setSecondTriggerSynchronizationGap(0.78);
201 s->setThirdTriggerSynchronizationGap(1.12); // 3rd gap is not required but let's have it for some resiliency
202}
TriggerWaveform::setSecondTriggerSynchronizationGap
void setSecondTriggerSynchronizationGap(float syncRatio)
Definition trigger_structure.cpp:427
TriggerWaveform::setTriggerSynchronizationGap
void setTriggerSynchronizationGap(float syncRatio)
Definition trigger_structure.cpp:423
TriggerWaveform::setThirdTriggerSynchronizationGap
void setThirdTriggerSynchronizationGap(float syncRatio)
Definition trigger_structure.cpp:435

Referenced by TriggerWaveform::initializeTriggerWaveform().

Here is the call graph for this function:
Here is the caller graph for this function:

Go to the source code of this file.

Generated on Sat Sep 27 2025 00:10:09 for rusEFI by doxygen 1.9.8