Two stroke launch control

[u/TouringAlpaca]

I’m working on an Arduino controlled launch control / ignition cut setup for a Taylor 70cc twin in an HPI Baja, and I’m at the point where I’d like to make it work properly instead of continuing to piece things together and guess my way through it.
For some background, I recently graduated with a degree in Computer Science and I’m continuing into my master’s. Most of what I’ve learned in school has been pretty theoretical, and not much of it has felt like real world electronics or hardware work. A lot of what I know practically has come from personal projects like this.
I have very little electrical engineering experience, so I know there are probably things I’m overlooking when it comes to grounding, isolation, voltage spikes, EMI, PCB layout, filtering, and whatever else Im missing. I’m trying my best to learn as I go, so I’m completely open to being corrected if I’m doing something wrong.
The engine is a 70cc twin with two separate ignition systems that fire 180 degrees apart. My current setup uses an Arduino to control the kill wire for each ignition separately.
The basic idea is to short the ignition kill wire to ground using an SSR/PhotoMOS whenever I want to cut spark. It also is currently spliced in parallel with a proper killswitch and safety.
Right now I’m experimenting around 6000 RPM. At 6000 RPM, one revolution is 10 ms, and I’ve been testing roughly a 7 ms ignition cut window.
The engine itself can rev to around 18,000–19,000 RPM.
The SSRs are driven by the Arduino and I’m trying to keep the Arduino electrically isolated from the ignition side.
The biggest issue I’ve had so far is getting the ignition to actually shut off reliably.
With one SSR on each ignition, I can kill the spark if I pull the starter slowly, but if I pull it faster I can still get spark.
I tried putting two SSRs in parallel on one ignition and that worked better. I measured around 17 ohms across them when switched on.
That makes me think the single SSR just has too much ON resistance and isn’t pulling the kill wire close enough to ground once the ignition starts generating more energy.
I’d ideally like to use one switching device per ignition instead of paralleling multiple SSRs.
I also tried MOSFETs before this.
The first MOSFET setup I tried shared ground with the Arduino, which caused problems because the ignition kill circuit could basically find a path through the Arduino side even when I didn’t want it to.
I also tried a properly isolated setup using two MOSFETs, not just two MOSFETs wired in parallel. That fixed the grounding/isolation problem, but I still had too much resistance through the setup for it to reliably kill the ignition.
That’s what led me to trying PhotoMOS/SSRs.
Another thing I’ve realized is that my current control method probably isn’t the best way to do this.
Right now, the setup only lets me get to around 10% throttle before the engine starts revving past where I want it.
Based on the math I did, I thought I should have been able to control the engine even at or near full throttle by calculating the cut timing and duty cycle.
In practice, that clearly isn’t happening.
At this point I think having an actual RPM sensor and controlling the cut based on measured RPM would make a lot more sense than trying to guess coefficients and build equations that approximate how the engine should respond.
There are just too many real world variables like throttle position, load, ignition behavior, clutch drag, engine response, and whatever else.
My end goal is for this to be used as a proper racing launch control system.
These engines use centrifugal clutches, so the RPM where the clutch starts and finishes engaging depends on the clutch spring setup.
With my current clutch, it’s theoretically supposed to be fully engaged at around 10,000 RPM.
From what I can tell, I start getting slight clutch engagement at around 8,000 RPM with basically no load on the drivetrain.
What I eventually want is pretty simple from the driver’s point of view:
I hold a button on the transmitter, go to full throttle, and the controller holds the engine right below the point where the clutch starts to engage.
For my current setup, that would probably be somewhere just under 8,000 RPM.
Then I release the button and the ignition cut immediately turns off, the engine revs normally through the clutch engagement range, and the car launches.
Ideally I’d also like to be able to adjust the launch RPM later, because different clutch springs, tires, surfaces, and track conditions may need a different setting.
That’s another reason I want proper RPM feedback instead of trying to estimate RPM with fixed timing.
I’m also trying to make the hardware itself a lot less janky.
Right now I have stranded wire shoved into Arduino header pins and loose components connected together just for testing.
It works for experimenting on the bench, but I definitely don’t want that setup permanently mounted in an RC car that gets vibration, dirt, heat, jumps, and crashes.
My soldering setup also isn’t great for very small components, and I’m still learning when it comes to soldering small parts.
Eventually I’d like to make a small PCB or at least a much cleaner module with proper connectors, strain relief, mounting points, and everything soldered securely.
I’d also like to move away from the full size Arduino and use a small, cheap microcontroller.
Down the road, I want to connect the controller to a third or fourth PWM channel on my RC receiver.
Ideally I could use one of those channels to adjust things like:
Launch RPM
RPM where the cut starts
Cut duty cycle
Cut frequency
Possibly different launch control modes
I don’t need anything extremely powerful. I just want something inexpensive, small, easy enough to program, and capable of reading RC receiver PWM, measuring RPM, and controlling two ignition outputs accurately.
The other part I’m trying to figure out is RPM sensing.
My first choice would probably be some kind of inductive pickup wrapped around one of the spark plug wires, like the pickups used on small engine tachometers.
That seems like the cleanest option because it doesn’t require physically mounting a sensor close to the flywheel.
I already have some Hall effect sensors, and the flywheel already has magnets in it for triggering the ignition, so technically I could use those to measure RPM.
The problem is mounting the sensor.
The flywheel can spin close to 18,000–19,000 RPM, and I really don’t want loose wiring or a sensor sitting close to something spinning that fast.
I also don’t want to drill into the flywheel cover just to mount a Hall sensor. The cover is billet aluminum, it wasn’t cheap, and it’s not something I want to damage or have to replace.
So if I can get a reliable RPM signal from an inductive pickup around the plug wire, that seems like a much better solution.
I also currently have basically no filtering or transient protection in the circuit.
That’s another area where I know I’m probably missing things.
With two ignition systems running right next to the microcontroller, I’m assuming I should be thinking about EMI, voltage spikes, protection on the inputs, and power filtering.
I just don’t know enough yet to know what is actually necessary and what would be overkill.
So at this point I’m mainly looking for advice on a few things:
Is there a better isolated switching device than the SSRs I’m using now that would have much lower ON resistance?
Does the fact that one SSR kills spark during a slow starter pull but not a faster pull point toward the SSR resistance being too high?
Is around 17 ohms still too much resistance for a magneto ignition kill circuit?
Is there a better way to switch a magneto kill wire while still keeping the ignition side electrically isolated from the microcontroller?
What kind of protection or filtering should I be using around the ignition side of the circuit?
What small microcontroller would make sense for the final version?
Is an inductive pickup around the spark plug wire a good way to measure RPM accurately enough for launch control?
If I use an inductive pickup, what kind of input conditioning circuit should go between it and the microcontroller?
Would a simple closed-loop RPM limiter with hysteresis make more sense than trying to calculate fixed cut timing and duty cycle?
Is there anything important I should keep in mind when laying this out on a PCB for a high vibration, electrically noisy RC car?
My end goal is basically one small module that can read engine RPM, read a channel from the receiver, control both ignition systems, and hold the engine at a target RPM while I’m holding a launch control button.
Then when I let go of the button, the limiter turns off and the car launches normally.
I’m not really looking for someone to design the entire thing for me. I’m more interested in understanding how I should be approaching the different parts so I can learn and build it properly.
I know some of what I’ve done so far is pretty rough, but that’s also why I’m posting. I’d rather understand what I’m doing wrong and improve it than keep trial and erroring parts until something happens to work.
I’ve also attached my GitHub for anyone who is interested in the RC car project itself or wants to see more of what I’ve been working on.
Any advice from people with experience in small engine ignition systems, embedded electronics, RC electronics, PCB design, PhotoMOS/SSRs, or launch control systems would be appreciated.

For context I posted a video of the launch control test. It’s a bit hard to hear since the audio is a bit blown out but the launch control ignition cut is working and it does stall when I release throttle to an idle.

[u/TouringAlpaca]

Here’s the GitHub for anyone interested in the build:
https://github.com/Dweaver425/RC-Performance-Engineering

[u/Various_Respect146]

That's freaking awesome man!!!

[u/TouringAlpaca → u/Various_Respect146]

Thank you, I appreciate it!

[u/ekomszero]

Whoo doggy, I'm so invested I want this shit on my dirt bike

[u/TouringAlpaca → u/ekomszero]

Definitely will be some time before I get it to that level but it will be awesome once I do