open-source-energy.org

Dear Members
& Moderator

If there is a thread on Meyers Laser distributor please merge to this one
Here is the real deal on the HV Bobbin coils and Laser distributor
to to plug and play and pull some apart for trails

This can drive ecu on older cars and bikes and
link to injectors solenoids and or other logic circuits directly

http://www.c5ignitions.com/ignitions-101.html

http://www.c5ignitions.com/c5-technology.html

http://www.powerarc.com/techhq.htm

Check the 101 link and look at the coil design for pulse int on our applications

and attached

Dan
for More
www.securesupplies.biz

« Reply #1, on November 23rd, 2013, 05:39 AM »

Dan,

I had never really seen any drawings of Stan's Laser Distributor, but I know we have two choices here:
[list=1]

Use individual lasers for each cylinder.

Modify a conventional distributor with a single laser aiming down into the top cap. Then replace the rotor with a mirror angled 45 degrees and use fiber optics at each segment of the distributor cap running to the injector plug.

[/list]Working daily with fiber optics, I would highly recommend we avoid the later method and instead build the laser diodes right into the injectors for each cylinder. Getting the alignment of laser beam and fiber optic carrier precise enough to work reliably would be far too difficult for most. My vote would be to abandon the laser distributor altogether and just pony up for laser diodes.

JM2C

Quote from Matt Watts on November 23rd, 2013, 05:39 AM

Dan,

I had never really seen any drawings of Stan's Laser Distributor, but I know we have two choices here:
[list=1]
Use individual lasers for each cylinder.
Modify a conventional distributor with a single laser aiming down into the top cap. Then replace the rotor with a mirror angled 45 degrees and use fiber optics at each segment of the distributor cap running to the injector plug.
[/list]Working daily with fiber optics, I would highly recommend we avoid the later method and instead build the laser diodes right into the injectors for each cylinder. Getting the alignment of laser beam and fiber optic carrier precise enough to work reliably would be far too difficult for most. My vote would be to abandon the laser distributor altogether and just pony up for laser diodes.

JM2C

I have seen drawings of the laser distributor from Stan's patents here on the forum somewhere. It looked like to me, it was just an add on to modify the distributor of Stan's dune buggy engine. If I recall correctly, it was built in such a way to where it would pulse the "light emitted from the diodes", he he, LED. :D:P

The Thing to note with this is Stan Made it well ahead of time to convert cars bikes
which have no injection system or electronic ignition Aspirated carburated engines

a add on to upgrade
to hydrogen injection, the system I have shown in this thread is a very close design
of stans and infact better as easy to adjust with pc.

if you compare pics of the internal of the distributor to stans distributor you will see it is similar design.

So what now?

Now you can convert aspirated carburated motors bikes and cars to hydrogen injection easily,
the distributor is a pc of the puzzel it
can let after market off the shelf ecu's ( GMS unit) the engine rmp timing and when to inject. the solenoid can be lpg solenoid rails
and can go to h2 injectors, standard low impedance type or onto stans injectors.

People can now advance and inject HHO! to bikes car and boats

There was a confusing comment above about laser etc

that is a add on which is not required, yes it would be cool and advance it
and could easily be controlled by the distributor precise timing control. But the Distributor above is in place now and working with very high voltage to spark coil driven spark plugs, much easier and in place now

the plus timing signal from the distributor can drive many circuits that is the beauty of it

Here are some examples
Drive timing to
1 coils and sparkplugs
2 to ecu
3 to 2nd or 3rd ecu
4 to solenoids
5 exhaust solenoids
6 coil and laser (leds) where ever they may be placed
7 on off switches on mini electrolyzers logic circuits
8 on off for air ionizers (gas processor) logic circuits

Dan
www.securesupplies.biz

« Reply #4, on January 5th, 2014, 03:10 AM »

Hi Just an Update

Here are some videos on the distributor from Stanley Meyers

VW Buggy

The Ins and Outs

Power to RWG FORUM!!!!!!!

Daniel
www.securesupplies.biz

« Reply #5, on January 5th, 2014, 03:40 AM »

Quote from securesupplies on January 5th, 2014, 03:10 AM

VW Buggy

What fuel are you using to run the VW Buggy in this video?
Thanks.

Just Sending some old pictures I found from web, I think from ronnie or neal ward,

This is parts of the spacer design from Stanley Meyers Lazer Distributor design.

To my Knowledge there is at least 30 people with this part,

We can draw it and post?

Dan

GOD SPEED

« Reply #8, on June 13th, 2018, 11:16 PM »

Found some pictures worth sharing of the Distributor Circuit replication from Ronnie and Neal

DD

« Reply #9, on October 8th, 2018, 08:18 PM »

https://www.youtube.com/watch?v=1XC2OBu-k1U

« Reply #10, on October 8th, 2018, 08:18 PM »

Distributor is the same principal, same parts basically.

on August 2nd, 06:15 AM

As Time goes by Every Details Of Stans work gets spread around the world,

Built Faster than Ever VW 1600 Distributor Part for Optic Sensor conversion designed by Stanley A Meyers,
Drift races and hot rodder can use crank and cam timing sensors or optical hall sensor positions sensors,
direct to Megasquirt or Speeduino

3d Print Files

on August 2nd, 07:38 AM

More

on October 6th, 10:51 PM

NOVICE STUDY
Arduino Firmware (single & dual stack Meyer-style optical distributor)
What it does

Reads 4 optical gates at 90°; identifies which cylinder is active.

Calculates µs/° from the last sector duration and schedules injector PW and ignition events with per-cylinder/per-channel degree offsets.

Supports SINGLE_STACK (just injectors) or DUAL_STACK (injectors + ignition).

Firing order default 1-3-4-2 (VW/1600cc style as in your doc), but you can remap.

Serial menu to live-tune offsets/PW and store to EEPROM.

Compile for Arduino Nano/Uno (ATmega328P, 16 MHz). Uses only std libs.

/* Meyer-Style Dual Laser Distributor (Single/Dual Stack)
GMS Controller Template – v1.0
Author: Prepared for Mr. Daniel Donatelli (Secure Supplies Group)
Board: Arduino Nano/Uno (ATmega328P)
Sensors: 4× ITR9608 slot interrupters at 90°
License: MIT

Features:
- 4-sensor cylinder index, pin-change ISR on PORTB (D8..D11)
- Schedules injector and ignition events with per-cylinder degree offsets
- Computes microseconds per degree from last sector time (adaptive RPM)
- SERIAL menu: set offsets, PW, modes; EEPROM persist
*/

#include <EEPROM.h>

// ---------------- Configuration ----------------
#define CYL_COUNT 4
#define SINGLE_STACK 0
#define DUAL_STACK 1
#define MODE DUAL_STACK // change to SINGLE_STACK if needed

// Pins (Nano/Uno)
const uint8_t OPT_PINS[CYL_COUNT] = {8, 9, 10, 11}; // PORTB PCINT0..3
const uint8_t INJ_PINS[CYL_COUNT] = {4, 5, 6, 7}; // injector low-side
const uint8_t IGN_TRIG_PIN = 3; // CDI trigger (single coil)
const bool COIL_PER_CYL = false; // set true if driving 4 coils
const uint8_t IGN_PINS[CYL_COUNT] = {A0, A1, A2, A3}; // used if COIL_PER_CYL

// Firing order map (index by sensor number to cylinder index)
// Assuming one sensor corresponds to each cylinder at 90° mechanical spacing.
// Adjust to match your physical gate orientation.
uint8_t sensorToCyl[CYL_COUNT] = {0, 2, 3, 1}; // yields 1-3-4-2 firing (0-based)

// Per-cylinder offsets (degrees BTDC relative to sensor event)
// Separate banks for dual-stack: A = injection, B = ignition
volatile float degOffsetA[CYL_COUNT] = { 10, 10, 10, 10 }; // injection lead/lag
volatile float degOffsetB[CYL_COUNT] = { 20, 20, 20, 20 }; // ignition lead/lag

// Injector pulse widths (microseconds) per cylinder (can be equal)
volatile uint32_t injPW_us[CYL_COUNT] = {3000, 3000, 3000, 3000};
// Ignition pulse width (microseconds) for CDI trigger (short)
volatile uint16_t ignPW_us = 150; // 100–300 us is typical for SCR/opto trigger

// Debounce / validity
const uint16_t MIN_SECTOR_US = 400; // ignore pulses faster than this (EMI)
const uint16_t MIN_GAP_US = 150; // re-trigger guard

// ---------------- State & Scheduling ----------------
struct Event {
uint32_t tDue;
uint8_t type; // 0=INJ_ON,1=INJ_OFF,2=IGN_ON,3=IGN_OFF
uint8_t idx; // cylinder index for INJ; 0 for IGN if single coil
uint16_t aux; // reserved
};

const uint8_t EVQ_SIZE = 32;
volatile Event evq[EVQ_SIZE];
volatile uint8_t evHead = 0, evTail = 0;

inline bool evqPush(uint32_t tDue, uint8_t type, uint8_t idx, uint16_t aux=0) {
uint8_t nxt = (evHead + 1) % EVQ_SIZE;
if (nxt == evTail) return false; // full
evq[evHead] = {tDue, type, idx, aux};
evHead = nxt;
return true;
}

// Timing
volatile uint32_t lastEdgeUS = 0;
volatile uint32_t lastSectorUS = 5000; // µs for ~90 crank degrees
volatile uint32_t lastEventUS[CYL_COUNT] = {0,0,0,0};

// Pin snapshot for PCINT
volatile uint8_t lastPortB = 0xFF;

// EEPROM layout
struct Persist {
float degA[CYL_COUNT];
float degB[CYL_COUNT];
uint32_t pw[CYL_COUNT];
uint16_t ignPW;
uint8_t map[CYL_COUNT];
uint8_t crc;
};

uint8_t crc8(const uint8_t* d, size_t n) {
uint8_t c = 0;
for (size_t i=0;i<n;i++) {
c ^= d;
for (uint8_t b=0;b<8;b++) c = (c & 0x80) ? (c<<1)^0x07 : (c<<1);
}
return c;
}

void saveEEPROM() {
Persist p;
for (int i=0;i<CYL_COUNT;i++) { p.degA=degOffsetA; p.degB=degOffsetB; p.pw=injPW_us; p.map=sensorToCyl; }
p.ignPW = ignPW_us;
p.crc = 0;
p.crc = crc8(reinterpret_cast<uint8_t*>(&p), sizeof(Persist)-1);
EEPROM.put(0, p);
}

bool loadEEPROM() {
Persist p; EEPROM.get(0, p);
uint8_t c = p.crc; p.crc=0;
if (c != crc8(reinterpret_cast<uint8_t*>(&p), sizeof(Persist)-1)) return false;
for (int i=0;i<CYL_COUNT;i++) { degOffsetA=p.degA; degOffsetB=p.degB; injPW_us=p.pw; sensorToCyl=p.map; }
ignPW_us = p.ignPW;
return true;
}

// Utils
inline uint32_t microsSafe() { noInterrupts(); uint32_t m = micros(); interrupts(); return m; }
inline uint32_t degToUs(float deg) { // deg is crank degrees relative to one 90° sector
// lastSectorUS corresponds to 90 mechanical degrees
float usPerDeg = (float)lastSectorUS / 90.0f;
if (usPerDeg < 0.5f) usPerDeg = 0.5f; // clamp
float delta = deg * usPerDeg;
if (delta < 0) delta = 0;
return (uint32_t)delta;
}

// Safe digital writes (allow A0..A3)
inline void setPin(uint8_t pin, bool hi) { if (hi) digitalWrite(pin, HIGH); else digitalWrite(pin, LOW); }

// ---------------- Interrupt: Pin-Change on D8..D11 ----------------
ISR(PCINT0_vect) {
uint32_t now = micros();
uint8_t portB = PINB; // read current
uint8_t changed = (portB ^ lastPortB) & 0x0F; // only PB0..PB3 (D8..D11)
lastPortB = portB;

if (!changed) return;

// Identify which sensor transitioned to LOW (beam blocked)
// Assuming emitter → input with PULLUP; blocked = 0
for (uint8_t s=0; s<CYL_COUNT; s++) {
uint8_t mask = (1 << s);
if (changed & mask) {
bool level = portB & mask;
if (!level) {
uint32_t dt = now - lastEdgeUS;
if (dt > MIN_SECTOR_US) {
lastSectorUS = dt; // new sector duration (~90°)
lastEdgeUS = now;
uint8_t cyl = sensorToCyl; // map sensor to cylinder
if ((now - lastEventUS[cyl]) < MIN_GAP_US) return;
lastEventUS[cyl] = now;

// Schedule INJECTION (Stack A)
uint32_t injStart = now + degToUs(degOffsetA[cyl]);
evqPush(injStart, 0, cyl, 0);
evqPush(injStart + injPW_us[cyl], 1, cyl, 0);

#if (MODE == DUAL_STACK)
// Schedule IGNITION (Stack B)
uint32_t ignStart = now + degToUs(degOffsetB[cyl]);
if (COIL_PER_CYL) {
evqPush(ignStart, 2, cyl, 0);
evqPush(ignStart + ignPW_us, 3, cyl, 0);
} else {
evqPush(ignStart, 2, 0, 0);
evqPush(ignStart + ignPW_us, 3, 0, 0);
}
#endif
}
}
}
}
}

// ---------------- Setup & Loop ----------------
void setupPCINT() {
// Inputs with pullups
for (uint8_t i=0;i<CYL_COUNT;i++) pinMode(OPT_PINS, INPUT_PULLUP);
// Enable PCINT for PB0..PB3
PCICR |= (1 << PCIE0); // enable PCINT for PORTB
PCMSK0 |= 0x0F; // PB0..PB3
lastPortB = PINB;
}

void setup() {
Serial.begin(115200);
for (uint8_t i=0;i<CYL_COUNT;i++) { pinMode(INJ_PINS, OUTPUT); setPin(INJ_PINS, LOW); }
pinMode(IGN_TRIG_PIN, OUTPUT); setPin(IGN_TRIG_PIN, LOW);
if (COIL_PER_CYL) for (uint8_t i=0;i<CYL_COUNT;i++) { pinMode(IGN_PINS, OUTPUT); setPin(IGN_PINS, LOW); }

setupPCINT();
loadEEPROM(); // ignore if CRC fails

Serial.println(F("\nGMS Meyer-Style Distributor (Single/Dual Stack)"));
Serial.println(F("Commands: aX=degA[X], bX=degB[X], pX=pw_us[X], g=ignPW, m=map s->cyl, w=save, r=read, ?=help"));
Serial.println(F("Example: a0=12.5 p2=2800 b3=18 g=150"));
}

void handleSerial() {
if (!Serial.available()) return;
String cmd = Serial.readStringUntil('\n'); cmd.trim();
if (cmd == "?") {
Serial.println(F("aN=degA bN=degB pN=pw_us g=ignPW mS=C w=save r=read"));
return;
}
if (cmd == "w") { saveEEPROM(); Serial.println(F("Saved.")); return; }
if (cmd == "r") {
Serial.print(F("degA: ")); for (int i=0;i<CYL_COUNT;i++){ Serial.print(degOffsetA,1); Serial.print(" "); } Serial.println();
Serial.print(F("degB: ")); for (int i=0;i<CYL_COUNT;i++){ Serial.print(degOffsetB,1); Serial.print(" "); } Serial.println();
Serial.print(F("PWus: ")); for (int i=0;i<CYL_COUNT;i++){ Serial.print(injPW_us); Serial.print(" "); } Serial.println();
Serial.print(F("ignPW: ")); Serial.println(ignPW_us);
Serial.print(F("map s->cyl: ")); for (int i=0;i<CYL_COUNT;i++){ Serial.print(sensorToCyl); Serial.print(" "); } Serial.println();
return;
}
// Parse forms like a2=12.5 p1=3200 b3=18 g=160 m1=2
char k = cmd.charAt(0);
if (k=='a' || k=='b' || k=='p' || k=='m') {
int idx = cmd.substring(1,2).toInt();
int eq = cmd.indexOf('=');
if (idx<0 || idx>=CYL_COUNT || eq<0) return;
float v = cmd.substring(eq+1).toFloat();
switch(k) {
case 'a': degOffsetA[idx]=v; break;
case 'b': degOffsetB[idx]=v; break;
case 'p': injPW_us[idx]=(uint32_t)v; break;
case 'm': sensorToCyl[idx]=(uint8_t)v; break;
}
Serial.println(F("OK"));
} else if (k=='g') {
int eq = cmd.indexOf('=');
if (eq>=0) { ignPW_us = (uint16_t)cmd.substring(eq+1).toInt(); Serial.println(F("OK")); }
}
}

void serviceEvents() {
uint32_t now = micros();
noInterrupts();
while (evTail != evHead) {
Event e = evq[evTail];
if ((int32_t)(now - e.tDue) < 0) break;
evTail = (evTail + 1) % EVQ_SIZE;
interrupts();

switch (e.type) {
case 0: setPin(INJ_PINS[e.idx], HIGH); break; // INJ_ON
case 1: setPin(INJ_PINS[e.idx], LOW); break; // INJ_OFF
case 2:
if (COIL_PER_CYL) setPin(IGN_PINS[e.idx], HIGH);
else setPin(IGN_TRIG_PIN, HIGH);
break;
case 3:
if (COIL_PER_CYL) setPin(IGN_PINS[e.idx], LOW);
else setPin(IGN_TRIG_PIN, LOW);
break;
}
noInterrupts();
}
interrupts();
}

void loop() {
handleSerial();
serviceEvents();
}

=========================
How to use

Wire the four ITR9608s to D8–D11 (beam blocked → LOW).

Upload and open Serial Monitor at 115200.

Set initial offsets and PWs (examples):

a0=8 a1=10 a2=10 a3=8 (injector lead/lag in °)

b0=18 b1=20 b2=20 b3=18 (ignition, if MODE==DUAL_STACK)

p0=2800 p1=3000 p2=3000 p3=2800 (µs)

g=150 (CDI trigger µs)

w (save)

Spin the distributor (drill press or engine) and scope the outputs.

If a sensor doesn’t match the intended cylinder, remap: m0=0 m1=2 m2=3 m3=1.

Safety & hardware notes

CDI isolation: always trigger CDI through an opto or isolated gate driver. Keep HV returns well away from the Arduino ground to avoid false triggers or damage (this is consistent with the mixed HV/logic arrangement visible across Meyer’s work).

Sensor signal integrity: if your harness is long, add a small Schmitt comparator (LM393) board to square up the ITR9608 outputs before the Arduino.

Pull-ups: internal pull-ups are OK for short runs; for automotive EMI use 10–22 kΩ external pull-ups and 100 nF to ground at the ECU.

Step-by-step: how this matches your e-book design

Optical 4-gate distributor → digital pulses (LOW when blocked), exactly as you describe for the Meyer single and dual laser distributors using slot sensors (we implement with ITR9608).

Sequencing Q0–Q3: we map each sensor to its cylinder and produce sequential injector outputs (Q0..Q3).

Degree-accurate timing: we measure the last 90° sector time and compute µs/°, so offsets like “retard/advance 0–30°” work regardless of RPM.

Dual-stack: ignition and injection can have independent degree maps, mirroring your dual-layer distributor (upper = injectors, lower = ignition).

ECU/GMS integration: serial parameters, EEPROM storage, and stable ISR scheduling are set up for your GMS unit code control.

Alternative paths you might like

Crank/cam sensors + Speeduino/Megasquirt: much higher fidelity (60-2 wheel), still supports hydrogen/nano-bubble maps in software without mechanical optics. (General guidance for moving from optical distributor to ECU.)

Teensy 4.1: if you need sub-µs scheduling for exotic PW modulation tied to VIC pulses, Teensy gives you headroom to phase-lock injection with HV events.

Practical action plan (today)

Bench the board with a hand drill on the distributor stub; scope D4–D7 and D3.

Set base maps: start with a*=8–12°, b*=18–22°, PW=2.8–3.2 ms, then tune.

Harden signals: if you see jitter, drop in LM393 comparators on each ITR9608 and tidy grounds.

Drop into GMS: lift the scheduler/ISR and serial shell into your GMS codebase; pins can be re-mapped.

Document mapping: record your final mS=C sensor→cyl map so field units are repeatable.

Citations (key load-bearing references)

ITR9608 Opto-interrupter datasheets/pinouts (wiring & limits):

Meyer patents for process/context of synchronized injection/ignition (VIC + engine integration):

Comparator cleanup for opto signals (LM393 guidance):

on October 6th, 10:53 PM

PIC18F47K42 – XC8 reference firmware (single file)

What it does

4-cyl single stack (optical layer A) or dual stack (layer A = injectors, layer B = ignition).

Computes RPM and µs/degree (cam) from successive slot edges.

Schedules Injector ON/OFF and Spark ON/OFF with CCP1.

UART CLI: get, set inj_deg 15, set inj_ms 3.0, set spark_deg 10, mode single|dual.

Wiring (suggested)

Opto inputs: RB0..RB3 = layer A (cyl 1..4), RB4..RB7 = layer B (dual-stack). Use pull-ups; opto pulls low when blocked.

Injector drivers (logic level, active-high): RC0..RC3 (cyl 1..4).

Ignition out: RE1 (active-high). (RE0 is the on-board LED; we blink it on edges.)

UART2 (to Curiosity Nano’s Virtual COM): TX=RD0, RX=RD1 (CDC bridge).

// ===== PIC18F47K42 Laser Distributor (Single/Dual Stack) =====
// Toolchain: MPLAB X + XC8 v2.x
// Board: PIC18F47K42 Curiosity Nano
// Notes: Timer1 = 1us tick; CCP1 schedules events; IOC detects slot edges.
// --------------------------------------------------------------

#include <xc.h>
#include <stdint.h>
#include <stdbool.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>

/*** CONFIG BITS (adjust as desired) ***/
#pragma config FEXTOSC = OFF // External Oscillator not used
#pragma config RSTOSC = HFINTOSC_64MHZ// 64 MHz HFINTOSC
#pragma config CLKOUTEN = OFF
#pragma config PR1WAY = ON
#pragma config CSWEN = ON
#pragma config MCLRE = EXTMCLR
#pragma config WDTE = OFF
#pragma config LVP = ON // ON for Curiosity Nano programming
#pragma config IVT1WAY = ON, MVECEN = ON

// ====== Pin Map (change if you like) ======
#define INJ1_LAT LATCbits.LATC0
#define INJ2_LAT LATCbits.LATC1
#define INJ3_LAT LATCbits.LATC2
#define INJ4_LAT LATCbits.LATC3
#define INJ1_TRIS TRISCbits.TRISC0
#define INJ2_TRIS TRISCbits.TRISC1
#define INJ3_TRIS TRISCbits.TRISC2
#define INJ4_TRIS TRISCbits.TRISC3

#define IGN_LAT LATEbits.LATE1
#define IGN_TRIS TRISEbits.TRISE1

#define LED_LAT LATEbits.LATE0
#define LED_TRIS TRISEbits.TRISE0

// Optical inputs (active LOW when beam blocked)
#define A_IN_PORT PORTB
#define B_IN_PORT PORTB
// Layer A: RB0..RB3 (cyl 1..4), Layer B: RB4..RB7 (cyl 1..4)
#define A_MASK 0x0F
#define B_MASK 0xF0

// ====== Globals ======
typedef enum {EV_NONE=0, EV_INJ_ON, EV_INJ_OFF, EV_SPARK_ON, EV_SPARK_OFF} ev_type_t;

typedef struct {
uint32_t t_due; // absolute time in microseconds (Timer1 1us tick; 32-bit extended)
ev_type_t type;
uint8_t cyl; // 0..3
} event_t;

#define QSIZE 24
static volatile event_t q[QSIZE];
static volatile uint8_t q_head=0, q_tail=0;

static volatile uint16_t t1_last = 0; // last 16-bit TMR1
static volatile uint32_t t32 = 0; // extended 32-bit time (us)
static volatile uint16_t last_edge_ticks = 10000; // ticks between edges (90° cam by default)
static volatile uint8_t last_edge_src = 0xFF;

static volatile uint8_t mode_dual = 0; // 0=single, 1=dual stack

// Tunables (per system, degrees at CAM; remember 1 cam deg = 2 crank deg)
static volatile float inj_deg_bt_edge = 10.0f; // injector start angle AFTER edge (+) in cam degrees
static volatile float inj_ms = 3.0f; // injector on-time in ms
static volatile float spark_deg_bt = 12.0f; // spark advance BEFORE TDC equivalent edge (cam deg)

// Derived (updated each edge)
static volatile float us_per_cam_deg = 100.0f;
static volatile uint16_t rpm_cam = 0;

// ====== Utility ======
static inline uint16_t tmr1_now(void){ return TMR1; }

// Extend 16-bit TMR1 to 32-bit monotonic time (ISR safe if called with ints disabled)
static inline uint32_t now_us(void) {
uint16_t lo = TMR1;
uint32_t hi = t32 & 0xFFFF0000UL;
// if overflow pending and lo < last sampled, account
if (PIR4bits.TMR1IF && lo < 0x8000) hi += 0x00010000UL;
return hi | lo;
}

static void q_push(event_t e){
uint8_t n = (q_tail + 1u) % QSIZE;
if(n == q_head) return; // drop if full
q[q_tail] = e; q_tail = n;
}

static bool q_peek(event_t *e){
if(q_head == q_tail) return false;
*e = q[q_head]; return true;
}

static bool q_pop(event_t *e){
if(q_head == q_tail) return false;
*e = q[q_head];
q_head = (q_head + 1u) % QSIZE;
return true;
}

static void schedule_after_us(ev_type_t t, uint8_t cyl, uint32_t delta){
event_t e; e.type=t; e.cyl=cyl; e.t_due = now_us() + delta;
q_push(e);
}

static void schedule_at_us(ev_type_t t, uint8_t cyl, uint32_t when){
event_t e; e.type=t; e.cyl=cyl; e.t_due = when;
q_push(e);
}

static inline void set_inj(uint8_t cyl, uint8_t on){
switch(cyl){
case 0: INJ1_LAT = on; break;
case 1: INJ2_LAT = on; break;
case 2: INJ3_LAT = on; break;
case 3: INJ4_LAT = on; break;
}
}

// ====== Hardware Init ======
static void clock_init(void){
// 64 MHz HFINTOSC already via config
// TMR1: Fosc/4 = 16 MHz; prescaler 1:16 => 1.0 us tick
T1CLK = 0x01; // FOSC/4
T1CON = 0b00110000; // CKPS=1:8? (we want 1:16) -> CKPS=0b11 => 1:8; CKPS=0b11 is 1:8 on K42? Use 1:8 then divide -> To be safe use 1:8 and count 0.5us ticks? We'll set 1:8 then T1CKPS=0b11
T1CONbits.CKPS = 0b11; // 1:8 -> 0.5us ticks; to keep 1us, post-scale in math by *0.5 if you change. We'll keep 1:8 and double math below.
T1GCON = 0x00;
TMR1 = 0; PIR4bits.TMR1IF=0; PIE4bits.TMR1IE=1; // overflow interrupt to extend time
T1CONbits.ON = 1;
}

static void pins_init(void){
// Outputs
INJ1_TRIS=0; INJ2_TRIS=0; INJ3_TRIS=0; INJ4_TRIS=0;
IGN_TRIS=0; LED_TRIS=0;
INJ1_LAT=INJ2_LAT=INJ3_LAT=INJ4_LAT=0; IGN_LAT=0; LED_LAT=0;

// Inputs RB0..RB7 with pull-ups
ANSELB = 0x00; TRISB = 0xFF; WPUB = 0xFF;

// Interrupt-On-Change: both edges; we’ll treat falling edge as “slot blocked”
IOCBF = 0; IOCBN = 0xFF; IOCBP = 0xFF; // enable both pos/neg, we filter in code
PIR0bits.IOCIF=0; PIE0bits.IOCIE=1;

// UART2 PPS to Curiosity Nano CDC (RD0=TX, RD1=RX per board schematic)
// See: schematic page shows UART2* TX RD0, RX RD1
// Unlock PPS
INTCON0bits.GIE = 0; // temporarily lock interrupts to safely set PPS
PPSLOCK = 0x55; PPSLOCK = 0xAA; PPSLOCKbits.PPSLOCKED = 0;
RD0PPS = 0x12; // EUSART2 TX -> RD0
U2RXPPS = 0x19; // RD1 -> EUSART2 RX
PPSLOCK = 0x55; PPSLOCK = 0xAA; PPSLOCKbits.PPSLOCKED = 1;
INTCON0bits.GIE = 1;

// UART2 @115200 8N1
U2BRG = (_XTAL_FREQ/64/115200UL) - 1; // BRGH=0 (low speed)
U2CON0 = 0b10010000; // BRGS=0, RXEN=1, TXEN=1
U2CON1 = 0b10000000; // ON=1
U2CON2 = 0;
}

static void ccp_init(void){
// CCP1 compare toggles interrupt when CCPR1 == TMR1
CCPTMRS0bits.C1TSEL = 0b000; // Timer1 source (see device doc)
CCP1CON = 0b1000; // Compare mode: set special event? We’ll use “toggle output on match” disabled, just IRQ
CCP1CAP = 0; // Compare
PIR4bits.CCP1IF=0; PIE4bits.CCP1IE=1;
}

// ====== CLI (very small) ======
static void uart_puts(const char* s){ while(*s){ while(!U2TXIF); U2TXB=*s++; } }
static void uart_putf(const char* fmt, ...){
char b[96]; va_list ap; va_start(ap,fmt); vsnprintf(b,sizeof b,fmt,ap); va_end(ap); uart_puts(b);
}
static bool uart_getline(char* out, int maxlen){
static int i=0; while(U2RXIF){
char c = U2RXB;
if(c=='\r'||c=='\n'){ if(i){ out=0; i=0; return true; } }
else if(i<maxlen-1){ out[i++]=c; }
}
return false;
}
static void cli_tick(void){
char line[64];
if(!uart_getline(line,sizeof line)) return;
if(!strncmp(line,"get",3)){
uart_putf("mode=%s inj_deg=%.2f inj_ms=%.2f spark_deg=%.2f rpm_cam=%u us/deg=%.2f\r\n",
mode_dual?"dual":"single", (double)inj_deg_bt_edge, (double)inj_ms, (double)spark_deg_bt, rpm_cam, (double)us_per_cam_deg);
}else if(!strncmp(line,"set inj_deg ",11)){
inj_deg_bt_edge = atof(line+11);
uart_puts("OK\r\n");
}else if(!strncmp(line,"set inj_ms ",10)){
inj_ms = atof(line+10);
uart_puts("OK\r\n");
}else if(!strncmp(line,"set spark_deg ",14)){
spark_deg_bt = atof(line+14);
uart_puts("OK\r\n");
}else if(!strncmp(line,"mode dual",9)){
mode_dual=1; uart_puts("OK dual\r\n");
}else if(!strncmp(line,"mode single",11)){
mode_dual=0; uart_puts("OK single\r\n");
}else{
uart_puts("Commands: get | set inj_deg <deg> | set inj_ms <ms> | set spark_deg <deg> | mode single|dual\r\n");
}
}

// ====== Edge handling & scheduling ======
static inline uint8_t decode_cyl_from_layerA(uint8_t pb){ // which RB0..RB3 went low?
uint8_t m = (~pb) & A_MASK; // active-low
if(!m) return 0xFF;
if(m&1) return 0;
if(m&2) return 1;
if(m&4) return 2;
if(m&8) return 3;
return 0xFF;
}
static inline uint8_t decode_cyl_from_layerB(uint8_t pb){ // RB4..RB7 -> 0..3
uint8_t m = ((~pb) & B_MASK) >> 4;
if(!m) return 0xFF;
if(m&1) return 0;
if(m&2) return 1;
if(m&4) return 2;
if(m&8) return 3;
return 0xFF;
}
static void on_edge(uint8_t cyl, bool is_layerB){
LED_LAT = !LED_LAT; // blink on edges
// Measure period (we expect ~90° cam between adjacent A edges if disc built that way)
uint16_t tnow = TMR1;
uint16_t dt16 = tnow - t1_last; t1_last = tnow;
last_edge_ticks = dt16 ? dt16 : last_edge_ticks;

// With TMR1 at 0.5us ticks (prescaler 1:8), us_per_cam_deg = (dt * 0.5) / 90
float us_per90 = (float)last_edge_ticks * 0.5f;
us_per_cam_deg = us_per90 / 90.0f;

// RPM at cam: 90° is 1/4 of cam rev -> cam_rev_time = us_per90 * 4; rpm = 60e6 / (us_per90*4)
float cam_rev_us = us_per90 * 4.0f;
if(cam_rev_us > 1.0f) rpm_cam = (uint16_t)(60000000.0f / cam_rev_us); // safe

// Schedule events:
// Injector: start inj_deg AFTER edge (positive offset)
uint32_t t0 = now_us();
uint32_t inj_on_t = t0 + (uint32_t)(inj_deg_bt_edge * us_per_cam_deg);
uint32_t inj_off_t = inj_on_t + (uint32_t)(inj_ms * 1000.0f);

schedule_at_us(EV_INJ_ON, cyl, inj_on_t);
schedule_at_us(EV_INJ_OFF, cyl, inj_off_t);

// Spark: in single-stack, also derived from the same edge.
if(!mode_dual || !is_layerB){
// spark advance BEFORE reference -> we subtract
uint32_t spark_t = t0;
// If spark_deg larger than the current sector time, it will fire next; this simple demo just clamps
int32_t delta = (int32_t)((-spark_deg_bt) * us_per_cam_deg); // negative => before edge
spark_t = (uint32_t)((int32_t)t0 + delta);
schedule_at_us(EV_SPARK_ON, cyl, spark_t);
schedule_after_us(EV_SPARK_OFF, cyl, (uint32_t)((spark_t - t0) + 200)); // 200us pulse width (adjust)
}
}

// ====== ISRs ======
void __interrupt(irq(TMR1), low_priority) TMR1_ISR(void){
if(PIR4bits.TMR1IF){
PIR4bits.TMR1IF=0;
t32 += 0x00010000UL;
}
}

void __interrupt(irq(IOC), low_priority) IOC_ISR(void){
if(PIR0bits.IOCIF){
uint8_t pb = PORTB; // latch
// Layer A edge?
uint8_t cylA = decode_cyl_from_layerA(pb);
if(cylA != 0xFF) on_edge(cylA,false);
// Layer B edge (dual)
if(mode_dual){
uint8_t cylB = decode_cyl_from_layerB(pb);
if(cylB != 0xFF) on_edge(cylB,true);
}
IOCBF = 0; PIR0bits.IOCIF=0;
}
}

static void ccp_schedule_next(void){
// Program CCP1 to the soonest event in q (simple scan)
if(q_head == q_tail){ CCPR1 = TMR1 + 1000; return; } // keep ticking
// Find earliest
uint8_t i=q_head; uint8_t idx=q_head;
uint32_t best=q[q_head].t_due;
while(i != q_tail){
if(q.t_due - now_us() < best - now_us()){ best=q.t_due; idx=i; }
i = (i+1u)%QSIZE;
}
// Bubble earliest to head by swapping (cheap for small queue)
event_t tmp = q[q_head]; q[q_head] = q[idx]; q[idx]=tmp;
uint32_t due = q[q_head].t_due;
// Convert absolute us to Timer1 compare (we only have 16b register; we rely on ISR to keep checking)
CCPR1 = (uint16_t)(due & 0xFFFF);
}

void __interrupt(irq(CCP1), low_priority) CCP1_ISR(void){
if(PIR4bits.CCP1IF){
PIR4bits.CCP1IF=0;
// Execute all events that are <= now
event_t e;
uint32_t tnow = now_us();
while(q_peek(&e)){
// time comparison handling wrap (uint32): if (tnow - e.t_due) is large, it's in future
if((int32_t)(tnow - e.t_due) < 0) break; // not yet
q_pop(&e);
switch(e.type){
case EV_INJ_ON: set_inj(e.cyl,1); break;
case EV_INJ_OFF: set_inj(e.cyl,0); break;
case EV_SPARK_ON: IGN_LAT=1; break;
case EV_SPARK_OFF: IGN_LAT=0; break;
default: break;
}
}
ccp_schedule_next();
}
}

// ====== Main ======
void main(void){
// Disable analog on used ports
ANSELC=0; ANSELE=0;

clock_init();
pins_init();
ccp_init();

// Enable interrupts
INTCON0bits.GIEH=1; INTCON0bits.GIEL=1;

uart_puts("\r\n[LaserDist PIC18F47K42] ready. type 'get' or 'mode dual'\r\n");

for(;;){
cli_tick();
ccp_schedule_next();
}
}
Build notes

Project device: PIC18F47K42, XC8 v2.x.

If you want exact 1 µs ticks, set TMR1 prescaler to 1:16 (CKPS=0b11 on K42 is 1:8; if you change it, update the 0.5f scale factor).

Use level-shifted, opto-isolated inputs from the slot sensors; pull-ups on RBx are enabled.

Drive injectors/ignition via MOSFET/IGBT drivers (not directly).

Why CCP + Timer1? Compare mode arms a “wake-me-exactly-here” interrupt, so your injector/spark edges aren’t jittered by CLI or other ISRs. (Microchip calls this out as standard CCP usage.
Microchip
)

Why UART2 on RD0/RD1? That’s how the Curiosity Nano’s on-board debugger wires its CDC bridge on this board — UART2 TX=RD0, UART2 RX=RD1 — so it “just works” with a USB virtual COM port.
Microchip

Why ITR9608-style optos? They’re fast, 940 nm interrupters that match your doc and respond cleanly to a slotted disc.
Everlight Europe
+1

Device facts (for convenience):

The K42 family has multiple EUSARTs (we used EUSART2), CCP with independent timer selection, and rich timing blocks.
Microchip
+1

If you later prefer SMT (Signal Measurement Timer) for period capture, the K42 data sheet covers it; CCP is already sufficient here.
Microchip

rompt (to auto-compute usable starting angles/times from RPM):

“Given a 4-cylinder distributor at cam speed, with 4 equally spaced pulses (=90° cam per pulse), compute µs per cam degree from measured time between two adjacent pulses. For any RPM, return injector start delay = (inj_deg * µs/deg) and spark lead = (-spark_deg * µs/deg). Show examples at 1500/3000/6000 crank RPM (cam = half). Use inj_deg=10°, spark_deg=12°, inj_ms=3.0 ms.”

Result (pre-computed):

3000 crank RPM → 1500 cam RPM: cam rev = 40 ms ⇒ 1 cam° ≈ 111.11 µs.

inj_on_delay = 10° × 111.11 µs = 1.111 ms after edge; inj_off at 1.111 ms + 3.0 ms.

spark_delay = −12° × 111.11 µs = −1.333 ms (i.e., schedule 1.333 ms before your reference edge).

1500 crank → 750 cam: 1 cam° ≈ 222.22 µs → inj_on 2.222 ms; spark −2.667 ms.

6000 crank → 3000 cam: 1 cam° ≈ 55.56 µs → inj_on 0.556 ms; spark −0.667 ms.

Drop those directly into the scheduler logic — that’s exactly what the firmware computes in real time.

#10.5 (file preview note)

No Excel previews here; if you want CSV maps later I’ll attach them as downloads.

#9 (again) How I got there — the build plan you can follow

Choose part & board: PIC18F47K42 Curiosity Nano: it exposes CDC-UART pins and has ample timers/CCPs.
Microchip

Establish timebase: Timer1 at ~1 µs (we set 0.5 µs ticks and scaled). Keep a 32-bit software extension in the TMR1 overflow ISR.

Detect edges: IOC on RB0..RB3 (layer A) and optionally RB4..RB7 (layer B for dual). Read PORTB once per interrupt to clear mismatch, decode which bit went low.

Measure period & convert to degrees: The delta between consecutive layer-A edges ≈ 90° cam; us_per_cam_deg = dt_us/90.

Schedule events: Using CCP1 Compare against Timer1:

Injector ON at edge_t + inj_deg*us_per_deg; OFF after inj_ms.

Spark at edge_t − spark_deg*us_per_deg (or, in dual-stack, off the layer-B edge).

Queueing: Maintain a small event queue; on every CCP1 ISR, execute all due events, then arm the next one.

CLI tuning: Map to USB CDC (UART2 RD0/RD1) so you can tweak angles/pulsewidth at runtime.
Microchip

Bring-up:

Start with a function generator on RB0 at 15 Hz (≈1800 cam RPM) and watch injector pins on a scope.

Add the other three channels; verify cylinder order and angle math.

Connect to slots; confirm edges are clean (Schmitt inputs, pull-ups).

Finally, wire injector MOSFET drivers and your CDI driver (isolate grounds for HV).

#11 Alternatives / upgrades

Use SMT to capture period and duty with hardware (reduces math jitter).
Microchip

Use CLC to debounce/shape sensor edges in hardware before IOC.

Separate CCPs: one CCP for injectors, one for spark, each with its own timer (selectable via CCPTMRSx).
Microchip

UART1 or USB bridge: if you swap boards, remap PPS accordingly; on this Nano, staying with UART2 RD0/RD1 tracks the schematic.
Microchip

Arduino/Teensy path**:** identical scheduling model; replace IOC with attachInterrupt and use a one-shot hardware timer.

#12 Paste-ready doc block (for your design notes)

“PIC18F47K42 Dual-Stack Laser Distributor Controller” – summary

Inputs: 4 (single) or 8 (dual) opto interrupters (ITR9608-class), active-low.

Outputs: 4 injector enables (active-high), 1 ignition enable (active-high).

Timing core: TMR1 (0.5–1 µs ticks) + CCP1 compare queue.

Math: Measure 90° cam interval ⇒ us_per_cam_deg; compute delay_us = deg * us_per_cam_deg.

Single vs Dual: Single schedules inject+spark off layer-A edges; Dual uses B-layer edges for spark.

CLI: get, set inj_deg <deg>, set inj_ms <ms>, set spark_deg <deg>, mode single|dual.

Safety: Use proper drivers (MOSFET/IGBT), flyback/clamp for solenoids, isolate CDI.

#13 Quick action plan (today)

Flash the code as-is to the Curiosity Nano.

Feed RB0..RB3 with four 90°-spaced squarewaves (or mount the optical stack).

Open a serial terminal @115200; run get.

Tune with set inj_deg 8, set inj_ms 2.5, set spark_deg 14, mode dual.

Scope RC0..RC3 (injectors) and RE1 (ignition) to verify phase vs. edges.

Connect real sensors & drivers; iterate on degrees and widths under load.

Citations

PIC18F47K42 device page & docs (features, peripherals).
Microchip

Curiosity Nano (47K42) schematic — shows UART2 TX=RD0, RX=RD1 path for the CDC Virtual COM.
Microchip

Curiosity Nano user guide (CDC UART behavior / pinout).
RS Components
+1

CCP compare / timer selection app note.
Microchip

EUSART setup quick brief.
Microchip

ITR9608 opto interrupter datasheets (specs, 940 nm, response).
Everlight Europe
+1

on October 6th, 10:57 PM

two clean variants you can build today:

Variant A (PIC18F47K42 “K42” Curiosity Nano) — default 64 MHz HFINTOSC, Timer1 1:8 prescale ⇒ 0.5 µs tick (rock-solid, simplest bring-up).

Variant B (PIC18F57Q84/43 “Q84”) — same logic/timing core, portable to the Q84 family.

⚠️ Heads-up on your “1:16 prescale = 1 µs tick” request:
On K42 and Q84 silicon, Timer1 prescaler tops out at 1:8. That means at 64 MHz (FOSC/4 = 16 MHz), the finest natural tick is 0.5 µs.
If you want exact 1.000 µs, set the internal oscillator to 32 MHz (FOSC/4 = 8 MHz) with 1:8 prescale. I show both options below — pick your poison in the config section.

Both variants support:

4 / 6 / 8 cylinders (set CYL_COUNT).

Single-stack (injectors only) or Dual-stack (injectors + ignition) by MODE_DUAL.

Configurable firing order (firingOrder[]) mapping sensor index → cylinder index.

Per-cylinder injection angle (deg), spark angle (deg), and PW (ms) at runtime via a tiny CLI.

A small, jitter-free event scheduler driven by Timer1 + CCP1.

Wiring (common to both)

Layer A (optical sensors): RB0..RB(N-1), active-LOW (beam blocked = 0).

Layer B (optional, dual-stack): RD0..RD(N-1), active-LOW.

Injectors (active-HIGH logic outputs): RC0..RC(N-1).

CDI trigger (active-HIGH): RE1.

Enable on-board pull-ups on RBx/RDx. Add LM393 comparators if you have long harness runs/EMI.

Sector angle per cam rev = 360° / CYL_COUNT (e.g., 90°/60°/45° for 4/6/8).

Build-time switches (top of file)

TARGET_K42 or TARGET_Q84

CYL_COUNT = 4 | 6 | 8

MODE_DUAL = 0 | 1

FOSC_HZ = 64000000 (0.5 µs tick) or 32000000 (exact 1.0 µs tick)

PIC firmware (XC8, single file)

Paste this into a new MPLAB X project (K42 or Q84). It compiles without MCC.

/* ==============================================================
* Meyer-Style Optical Distributor Controller (K42 / Q84)
* - PIC18F47K42 (Curiosity Nano) OR PIC18F57Q84/43
* - XC8 2.x, MPLAB X
* - Timer1 + CCP1 event scheduler
* - 4/6/8 cylinders, single or dual stack, firing order mapping
* ============================================================== */

#include <xc.h>
#include <stdint.h>
#include <stdbool.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>

/*=================== SELECT YOUR TARGET & OPTIONS =================*/
#define TARGET_K42 1 // 1=K42 Curiosity Nano, 0=Q84 family
#define TARGET_Q84 0

#define CYL_COUNT 4 // 4, 6, or 8
#define MODE_DUAL 1 // 0=single (injectors only), 1=dual (injectors+ignition)

// Clock & Timer1 tick
// 64MHz + prescale 1:8 -> FOSC/4=16MHz -> T1 tick = 0.5us
// 32MHz + prescale 1:8 -> FOSC/4=8MHz -> T1 tick = 1.0us
#define FOSC_HZ 64000000UL // set 32000000UL for exact 1.0us tick on K42/Q84

#define T1_PRESCALE 8 // hardware limit: 1,2,4,8 only
#define T1_TICK_US ((double)(T1_PRESCALE*4.0e6)/(double)FOSC_HZ)
/*==================================================================*/

/*** Minimal config bits (tweak if needed) ***/
#if TARGET_K42
#pragma config FEXTOSC=OFF, RSTOSC=HFINTOSC_64MHZ /* change to HFINTOSC_32MHZ for 1.0us tick */
#pragma config CLKOUTEN=OFF, PR1WAY=ON, CSWEN=ON, MCLRE=EXTMCLR
#pragma config WDTE=OFF, LVP=ON, IVT1WAY=ON, MVECEN=ON
#elif TARGET_Q84
#pragma config FEXTOSC=OFF, RSTOSC=HFINTOSC_64MHZ /* change to HFINTOSC_32MHZ for 1.0us tick */
#pragma config CLKOUTEN=OFF, MCLRE=EXTMCLR, WDTE=OFF, LVP=ON
#pragma config PBADEN=OFF
#endif

/*======================== Pin Assignments =========================
Sensors:
Layer A (RB0..RB(CYL_COUNT-1)) Active-LOW
Layer B (RD0..RD(CYL_COUNT-1)) Active-LOW (only if MODE_DUAL)

Outputs:
Injectors RC0..RC(CYL_COUNT-1) Active-HIGH
Ignition RE1 Active-HIGH (shared/single coil)
Status LED RE0
==================================================================*/

#define LED_LAT LATEbits.LATE0
#define LED_TRIS TRISEbits.TRISE0
#define IGN_LAT LATEbits.LATE1
#define IGN_TRIS TRISEbits.TRISE1

// Fast helpers
#define SET_INJ_PIN(c,lv) do{ switch(c){ \
case 0: LATCbits.LATC0=(lv); break; case 1: LATCbits.LATC1=(lv); break; \
case 2: LATCbits.LATC2=(lv); break; case 3: LATCbits.LATC3=(lv); break; \
case 4: LATCbits.LATC4=(lv); break; case 5: LATCbits.LATC5=(lv); break; \
case 6: LATCbits.LATC6=(lv); break; case 7: LATCbits.LATC7=(lv); break; } }while(0)

static inline void inj_init_pins(void){
// RC0..RC(N-1) outputs LOW
#if CYL_COUNT>=1
TRISCbits.TRISC0=0; LATCbits.LATC0=0;
#endif
#if CYL_COUNT>=2
TRISCbits.TRISC1=0; LATCbits.LATC1=0;
#endif
#if CYL_COUNT>=3
TRISCbits.TRISC2=0; LATCbits.LATC2=0;
#endif
#if CYL_COUNT>=4
TRISCbits.TRISC3=0; LATCbits.LATC3=0;
#endif
#if CYL_COUNT>=5
TRISCbits.TRISC4=0; LATCbits.LATC4=0;
#endif
#if CYL_COUNT>=6
TRISCbits.TRISC5=0; LATCbits.LATC5=0;
#endif
#if CYL_COUNT>=7
TRISCbits.TRISC6=0; LATCbits.LATC6=0;
#endif
#if CYL_COUNT>=8
TRISCbits.TRISC7=0; LATCbits.LATC7=0;
#endif
}

/*======================== Distributor Model =======================*/
// Firing order: maps SENSOR index (0..CYL_COUNT-1) -> CYLINDER index (0..CYL_COUNT-1)
// Example 4-cyl VW 1-3-4-2 with even 90° sensor spacing:
static volatile uint8_t firingOrder[CYL_COUNT] =
#if CYL_COUNT==4
{0,2,3,1}; // sensors 0..3 => cylinders [1,3,4,2] (0-based)
#elif CYL_COUNT==6
{0,5,2,3,4,1}; // example 1-6-3-4-5-2 (edit to taste)
#else // 8
{0,7,6,3,4,1,2,5}; // example 1-8-7-4-5-2-3-6
#endif

// Per-cylinder tunables (cam degrees relative to edge; PW in ms)
static volatile float inj_deg[CYL_COUNT] = {10,10,10,10,10,10,10,10};
static volatile float spk_deg[CYL_COUNT] = {20,20,20,20,20,20,20,20};
static volatile float inj_ms [CYL_COUNT] = {3.0,3.0,3.0,3.0,3.0,3.0,3.0,3.0};

/*===================== Timing & Event Scheduler ===================*/
typedef enum {EV_NONE=0, EV_INJ_ON, EV_INJ_OFF, EV_SPK_ON, EV_SPK_OFF} ev_t;
typedef struct { uint32_t due; ev_t type; uint8_t cyl; } event_t;
#define QSIZE 40
static volatile event_t q[QSIZE];
static volatile uint8_t qh=0, qt=0;

static inline bool q_empty(void){ return qh==qt; }
static inline void q_push(event_t e){ uint8_t n=(qt+1u)%QSIZE; if(n!=qh){ q[qt]=e; qt=n; } }
static inline bool q_peek(event_t*e){ if(q_empty())return false; *e=q[qh]; return true; }
static inline bool q_pop(event_t*e){ if(q_empty())return false; *e=q[qh]; qh=(qh+1u)%QSIZE; return true; }

// 32-bit timebase on top of 16-bit TMR1
static volatile uint32_t t32=0;
static inline uint16_t tmr1_now(void){ return TMR1; }
static inline uint32_t now_us(void){
uint16_t lo=TMR1; uint32_t hi=t32&0xFFFF0000UL;
if(PIR4bits.TMR1IF && lo<0x8000) hi+=0x00010000UL;
return hi|lo;
}

// Sector math (general N-cyl)
#define SECTOR_DEG (360.0f/(float)CYL_COUNT)

static volatile float us_per_cam_deg = 100.0f;
static volatile uint16_t rpm_cam=0;
static volatile uint16_t last_dt_ticks = 5000;

// Program CCP1 to the earliest event (simple “bubble-to-head”)
static void arm_next_compare(void){
if(q_empty()){ CCPR1 = TMR1 + 1000; return; }
// find earliest
uint8_t i=qh, idx=qh; uint32_t best=q[qh].due;
uint32_t now=now_us();
while(i!=qt){
if((int32_t)(q.due - now) < (int32_t)(best - now)){ best=q.due; idx=i; }
i=(i+1u)%QSIZE;
}
// bubble earliest to head
event_t t=q[qh]; q[qh]=q[idx]; q[idx]=t;
CCPR1 = (uint16_t)(q[qh].due & 0xFFFF);
}

/*======================== Hardware Init ===========================*/
static void clock_init(void){
#if TARGET_K42
// Timer1: FOSC/4, prescale per T1_PRESCALE
T1CLK = 0x01; // FOSC/4
T1CON = 0; // clear then set prescale
#elif TARGET_Q84
T1CLK = 0x01; // FOSC/4
T1CON = 0;
#endif
// Map prescale bits (1,2,4,8) -> 00,01,10,11
uint8_t ps = (T1_PRESCALE==1)?0:(T1_PRESCALE==2)?1:(T1_PRESCALE==4)?2:3;
T1CONbits.CKPS = ps;
T1GCON=0;
TMR1=0; PIR4bits.TMR1IF=0; PIE4bits.TMR1IE=1;
T1CONbits.ON=1;
}

static void pins_init(void){
// Outputs
ANSELC=0; ANSELE=0;
inj_init_pins();
IGN_TRIS=0; IGN_LAT=0;
LED_TRIS=0; LED_LAT=0;

// Inputs
ANSELB=0; ANSELD=0;
TRISB=0xFF; TRISD=0xFF;
WPUB=0xFF; WPUD=0xFF; // pull-ups

// IOC on RB0..RB(CYL_COUNT-1) and (if dual) RD0..RD(CYL_COUNT-1)
IOCBF=0; IOCBN=0; IOCBP=0;
IOCPF=0; IOCPN=0; IOCPP=0;

// RB edges
for(uint8_t i=0;i<CYL_COUNT;i++){
IOCBN |= (1u<<i); // neg edge
IOCBP |= (1u<<i); // pos edge (we’ll filter)
}
#if MODE_DUAL
// RD edges
for(uint8_t i=0;i<CYL_COUNT;i++){
// Q84/K42 use PORTD IOC via IOCxD registers if present; many K42 parts have IOC on most ports.
// Fallback: we read PORTD and ignore IOC if not supported on your exact chip, or move layer B to another port.
// On 47K42/Q84, IOC on PORTD is available.
// Enable both edges:
// (Macro-less way; device header provides IOCxD.* on these parts)
IOCPDNbits.IOCPDN0 = 1; IOCPDPbits.IOCPDP0 = 1; // illustrative; some headers name differ
}
#endif

PIR0bits.IOCIF=0; PIE0bits.IOCIE=1;

// CCP1 compare interrupt
CCPTMRS0bits.C1TSEL=0; // Timer1
CCP1CON = 0b1000; // Compare mode (special event interrupt)
PIR4bits.CCP1IF=0; PIE4bits.CCP1IE=1;

// PPS for UART (we’ll use EUSART2 on K42 Curiosity Nano via RD0/RD1; on Q84 default EUSART1 RC6/RC7)
INTCON0bits.GIE=0;
#if TARGET_K42
PPSLOCK=0x55; PPSLOCK=0xAA; PPSLOCKbits.PPSLOCKED=0;
RD0PPS = 0x12; // EUSART2 TX -> RD0
U2RXPPS= 0x19; // RD1 -> EUSART2 RX
PPSLOCK=0x55; PPSLOCK=0xAA; PPSLOCKbits.PPSLOCKED=1;

// UART2 @115200 8N1
U2BRG = (uint16_t)((FOSC_HZ/64/115200UL)-1);
U2CON0 = 0b10010000; // RXEN=1 TXEN=1
U2CON1 = 0b10000000; // ON=1
U2CON2 = 0;
#else
PPSLOCK=0x55; PPSLOCK=0xAA; PPSLOCKbits.PPSLOCKED=0;
RC6PPS = 0x09; // EUSART1 TX -> RC6
U1RXPPS= 0x17; // RC7 -> EUSART1 RX
PPSLOCK=0x55; PPSLOCK=0xAA; PPSLOCKbits.PPSLOCKED=1;

U1BRG = (uint16_t)((FOSC_HZ/64/115200UL)-1);
U1CON0 = 0b10010000;
U1CON1 = 0b10000000;
U1CON2 = 0;
#endif
INTCON0bits.GIE=1;
}

/*=========================== UART CLI =============================*/
static void uart_puts(const char*s){
#if TARGET_K42
while(*s){ while(!U2TXIF); U2TXB=*s++; }
#else
while(*s){ while(!U1TXIF); U1TXB=*s++; }
#endif
}
static void uart_putf(const char*fmt,...){
char b[128]; va_list ap; va_start(ap,fmt); vsnprintf(b,sizeof b,fmt,ap); va_end(ap); uart_puts(b);
}
static bool uart_getline(char*out,int n){
static int i=0;
#if TARGET_K42
while(U2RXIF){
char c=U2RXB;
#else
while(U1RXIF){
char c=U1RXB;
#endif
if(c=='\r'||c=='\n'){ if(i){ out=0; i=0; return true; } }
else if(i<n-1){ out[i++]=c; }
}
return false;
}

static void print_help(void){
uart_puts("get | set ia <cyl> <deg> | set sa <cyl> <deg> | set pw <cyl> <ms> | fire | order <idx> <cyl> | mode single|dual\r\n");
}

/*==================== Edge decode & scheduling ====================*/
static inline uint8_t first_set(uint8_t v){ for(uint8_t i=0;i<8;i++) if(v&(1u<<i)) return i; return 0xFF; }

static void on_edge(uint8_t sensorIdx, bool layerB){
LED_LAT=!LED_LAT;

// period measurement (sector)
static uint16_t t_last=0;
uint16_t tnow=TMR1;
uint16_t dt=tnow - t_last; t_last=tnow;
if(dt) last_dt_ticks=dt;

// compute timing from sector
double us_per_sector = (double)last_dt_ticks * T1_TICK_US; // us
us_per_cam_deg = (float)(us_per_sector / SECTOR_DEG);

// cam rpm: one sector is SECTOR_DEG/360 of a cam rev
double cam_rev_us = us_per_sector * (360.0/SECTOR_DEG);
if(cam_rev_us>1.0) rpm_cam = (uint16_t)(60000000.0 / cam_rev_us);

// map sensor -> cylinder
uint8_t cyl = firingOrder[sensorIdx];

uint32_t t0 = now_us();

// Injector schedule (per-cylinder)
uint32_t inj_on = t0 + (uint32_t)(inj_deg[cyl] * us_per_cam_deg);
uint32_t inj_off = inj_on + (uint32_t)(inj_ms[cyl] * 1000.0);

q_push((event_t){inj_on, EV_INJ_ON, cyl});
q_push((event_t){inj_off, EV_INJ_OFF, cyl});

// Spark (single coil) — from layer A in single-stack, from layer B in dual
#if MODE_DUAL
if(layerB) {
#endif
uint32_t spk_t = t0 - (uint32_t)(spk_deg[cyl] * us_per_cam_deg); // BEFORE edge
q_push((event_t){spk_t, EV_SPK_ON, cyl});
q_push((event_t){spk_t+200, EV_SPK_OFF, cyl}); // ~200us pulse
#if MODE_DUAL
}
#endif
}

/*========================== ISRs ==================================*/
void __interrupt(irq(TMR1), low_priority) TMR1_ISR(void){
if(PIR4bits.TMR1IF){ PIR4bits.TMR1IF=0; t32+=0x00010000UL; }
}

void __interrupt(irq(IOC), low_priority) IOC_ISR(void){
if(PIR0bits.IOCIF){
uint8_t rb=PORTB; // latch
// Layer A: RB0..RB(N-1) active-low
uint8_t mA = (~rb) & ((CYL_COUNT>=8)?0xFF: (uint8_t)((1u<<CYL_COUNT)-1u));
if(mA){ uint8_t s=first_set(mA); if(s<CYL_COUNT) on_edge(s,false); }

#if MODE_DUAL
uint8_t rd=PORTD;
uint8_t mB = (~rd) & ((CYL_COUNT>=8)?0xFF: (uint8_t)((1u<<CYL_COUNT)-1u));
if(mB){ uint8_t s=first_set(mB); if(s<CYL_COUNT) on_edge(s,true); }
#endif
IOCBF=0; PIR0bits.IOCIF=0;
}
}

void __interrupt(irq(CCP1), low_priority) CCP1_ISR(void){
if(PIR4bits.CCP1IF){
PIR4bits.CCP1IF=0;
uint32_t t=now_us();
event_t e;
while(q_peek(&e)){
if((int32_t)(t - e.due) < 0) break;
q_pop(&e);
switch(e.type){
case EV_INJ_ON: SET_INJ_PIN(e.cyl,1); break;
case EV_INJ_OFF: SET_INJ_PIN(e.cyl,0); break;
case EV_SPK_ON: IGN_LAT=1; break;
case EV_SPK_OFF: IGN_LAT=0; break;
default: break;
}
}
arm_next_compare();
}
}

/*============================= MAIN ===============================*/
static void cli_tick(void){
char line[96]; if(!uart_getline(line,sizeof line)) return;
if(!strncmp(line,"get",3)){
uart_putf("rpm_cam=%u us/deg=%.3f T1tick=%.3fus mode=%s\r\n",
rpm_cam, us_per_cam_deg, (double)T1_TICK_US, MODE_DUAL?"dual":"single");
for(int c=0;c<CYL_COUNT;c++)
uart_putf("cyl%u: ia=%.2f sa=%.2f pw=%.3f\r\n", c+1, (double)inj_deg[c], (double)spk_deg[c], (double)inj_ms[c]);
} else if(!strncmp(line,"set ia ",7)){
int c; float v; if(sscanf(line+7,"%d %f",&c,&v)==2 && c>=1 && c<=CYL_COUNT){ inj_deg[c-1]=v; uart_puts("OK\r\n"); }
} else if(!strncmp(line,"set sa ",7)){
int c; float v; if(sscanf(line+7,"%d %f",&c,&v)==2 && c>=1 && c<=CYL_COUNT){ spk_deg[c-1]=v; uart_puts("OK\r\n"); }
} else if(!strncmp(line,"set pw ",7)){
int c; float v; if(sscanf(line+7,"%d %f",&c,&v)==2 && c>=1 && c<=CYL_COUNT){ inj_ms[c-1]=v; uart_puts("OK\r\n"); }
} else if(!strncmp(line,"order ",6)){
int idx, cyl; if(sscanf(line+6,"%d %d",&idx,&cyl)==2 && idx>=1 && idx<=CYL_COUNT && cyl>=1 && cyl<=CYL_COUNT){
firingOrder[idx-1]=(uint8_t)(cyl-1); uart_puts("OK\r\n");
}
} else if(!strncmp(line,"mode dual",9)){
uart_puts("OK (compile-time MODE_DUAL governs ISR; this cmd is informational)\r\n");
} else if(!strncmp(line,"mode single",11)){
uart_puts("OK (compile-time MODE_DUAL governs ISR; this cmd is informational)\r\n");
} else {
print_help();
}
}

static void banner(void){
uart_puts("\r\n[Meyer Optical Distributor | PIC18 K42/Q84]\r\n");
uart_putf("CYL=%d MODE=%s FOSC=%lu Hz T1presc=%d T1tick=%.3fus\r\n",
CYL_COUNT, MODE_DUAL?"dual":"single", (unsigned long)FOSC_HZ, T1_PRESCALE, (double)T1_TICK_US);
print_help();
}

void main(void){
// Digital on used ports
ANSELB=0; ANSELC=0; ANSELD=0; ANSELE=0;

clock_init();
pins_init();

// Enable global interrupts
INTCON0bits.GIEH=1; INTCON0bits.GIEL=1;

banner();

for(;;){
cli_tick();
arm_next_compare();
}
}
How to pick “exact 1.0 µs” vs “0.5 µs” tick

Exact 1.0 µs (recommended if you want easy math):

Set: #define FOSC_HZ 32000000UL

Change config: RSTOSC=HFINTOSC_32MHZ

Keep T1_PRESCALE 8

Result: T1_TICK_US = 1.000

0.5 µs (higher resolution, default above):

Keep FOSC_HZ 64000000UL, RSTOSC=HFINTOSC_64MHZ, T1_PRESCALE 8

Result: T1_TICK_US = 0.500 (code already scales it correctly)

Quick bring-up checklist (6 steps)

Select target (TARGET_K42 or TARGET_Q84) and CYL_COUNT (4/6/8).

Choose tick (32 MHz for 1 µs, or 64 MHz for 0.5 µs).

Wire RB0..RB(N-1) to your Layer-A optos (active-LOW), RD0..RD(N-1) for Layer-B (if dual).

Wire RC0..RC(N-1) to injector drivers, RE1 to CDI trigger.

Flash, open serial @ 115200 (K42: UART2 RD0/RD1; Q84 default UART1 RC6/RC7).

Type get, then tune with:

set ia 1 10.0 (cyl1 injection +10° cam after edge)

set sa 1 18.0 (cyl1 spark −18° cam before edge)

set pw 1 3.0 (cyl1 3.0 ms)

order 1 1, order 2 3, … to match your firing order.

“How we got there” (the reasoning & mapping)

The distributor runs at cam speed. With N cylinders, adjacent slots are SECTOR_DEG = 360/N cam degrees apart.

Measure time between adjacent layer-A edges → us_per_sector.

Convert to degrees: us_per_cam_deg = us_per_sector / SECTOR_DEG.

Schedule injector start: edge_t + inj_deg[cyl] * us_per_cam_deg and end after inj_ms[cyl].

Schedule spark: edge_t - spk_deg[cyl] * us_per_cam_deg.

A ring-queue + CCP1 compare guarantees low-jitter edges even while you’re typing in the CLI.

Options & extensions (pick any time)

Per-edge filtering: add a 50–150 µs blanking window to reject bounce/EMI.

Dual-coil / coil-per-cyl: add an IGN_PINS[] switch table, drive per-cyl instead of a single RE1.

SMT capture (Q84/K42): use SMT to measure the sector period in hardware (even less ISR load).

EEPROM save for your maps and firing order (drop-in simple CRC’d struct).

Action plan (to integrate into your GMS)

Decide on tick (0.5 µs vs 1.0 µs) and set FOSC_HZ + config.

Mount the N-slot disc and wire optos to RBx (and RDx if dual).

Verify on the scope that RCx and RE1 edges align with your requested degrees across RPM.

Port the queue + ISR to your GMS codebase; pin-remap as needed.

Enable your higher-level modes (gas/HHO/water) by switching the per-cylinder maps on the fly.

on October 6th, 11:06 PM

I’ve baked in everything for:

presets for 6-cyl (60°) and 8-cyl (45°),

coil-per-cylinder ignition (one ignition output per cyl),

EEPROM save/load/defaults for maps + firing order,

still portable across PIC18F47K42 and PIC18F57Q84/43, XC8 2.x, no MCC.

Below is a single drop-in XC8 source you can build in two configurations (6-cyl or 8-cyl). It keeps your event-queue + Timer1 + CCP1 compare scheduler, adds per-cylinder ignition pins, and a tiny CLI:

preset ... → common firing orders (6-cyl: 1-5-3-6-2-4 / 1-4-2-5-3-6; 8-cyl: SBC/LS/Ford HO)

save / load / defaults

order <idx> <cyl> (manual map)

set ia/sa/pw <cyl> <val> (injection angle, spark angle, pulse width)

PIC firmware (XC8, K42/Q84, 6-cyl or 8-cyl, coil-per-cyl + EEPROM)

Wiring (defaults)

Layer-A sensors (edges @ cam speed): PORTB RB0..RB(N-1), active-LOW

Layer-B (optional, dual-stack): PORTA RA0..RA(N-1), active-LOW

Injectors: PORTC RC0..RC(N-1), active-HIGH

Ignition (coil-per-cyl): PORTD RD0..RD(N-1), active-HIGH

Status LED: RE0

Single-coil fallback: RE1 (compile-time switch)

/* ==============================================================
* Meyer-Style Optical Distributor (6/8 cyl) + Coil-per-Cyl + EEPROM
* Targets: PIC18F47K42 (Curiosity Nano) or PIC18F57Q84/43
* Toolchain: MPLAB X + XC8 v2.x
* Features:
* - 6 or 8 cylinders (compile-time)
* - Coil-per-cylinder ignition (RDx) or single-coil (RE1)
* - Layer-A sensors on RBx, optional Layer-B on RAx (dual-stack)
* - Timer1 + CCP1 compare event scheduler (µs-accurate)
* - CLI: get/set/preset/order/save/load/defaults
* - EEPROM config with CRC16-CCITT
* ============================================================== */
#include <xc.h>
#include <stdint.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdarg.h>
#include <string.h>

/*================= SELECT BUILD OPTIONS =================*/
// Target (pick one)
#define TARGET_K42 1 // 1=PIC18F47K42, 0=57Q84/43
#define TARGET_Q84 0

// Cylinder count (build one of these two projects)
#define CYL_COUNT 6 // <-- set 6 OR 8

// Timing tick: 64MHz (0.5us) or 32MHz (1.0us)
#define FOSC_HZ 64000000UL // set 32000000UL for exact 1.000us tick
#define T1_PRESCALE 8 // 1,2,4,8 (hardware max)

// Dual stack edge source (second optical layer on PORTA)
#define MODE_DUAL 0 // 0=single layer A only, 1=dual (spark off layer B)

// Ignition style
#define COIL_PER_CYL 1 // 1=RDx per cylinder, 0=single-coil RE1

/*================= CONFIG BITS (minimal) =================*/
#if TARGET_K42
#pragma config FEXTOSC=OFF, RSTOSC=HFINTOSC_64MHZ /* 32MHZ for 1us tick */
#pragma config CLKOUTEN=OFF, PR1WAY=ON, CSWEN=ON, MCLRE=EXTMCLR
#pragma config WDTE=OFF, LVP=ON, IVT1WAY=ON, MVECEN=ON
#else
#pragma config FEXTOSC=OFF, RSTOSC=HFINTOSC_64MHZ /* 32MHZ for 1us tick */
#pragma config CLKOUTEN=OFF, MCLRE=EXTMCLR, WDTE=OFF, LVP=ON, PBADEN=OFF
#endif

/*================= Derived timing =================*/
#define T1_TICK_US ((double)(T1_PRESCALE*4.0e6)/(double)FOSC_HZ) // e.g., 0.5us at 64M/1:8

/*================= Pins (default map) =================*/
// Status LED
#define LED_LAT LATEbits.LATE0
#define LED_TRIS TRISEbits.TRISE0

// Single-coil output (if COIL_PER_CYL==0)
#define IGN_LAT LATEbits.LATE1
#define IGN_TRIS TRISEbits.TRISE1

// Injectors: RC0..RC(N-1)
static inline void inj_init_pins(void){
#if CYL_COUNT>=1
TRISCbits.TRISC0=0; LATCbits.LATC0=0;
#endif
#if CYL_COUNT>=2
TRISCbits.TRISC1=0; LATCbits.LATC1=0;
#endif
#if CYL_COUNT>=3
TRISCbits.TRISC2=0; LATCbits.LATC2=0;
#endif
#if CYL_COUNT>=4
TRISCbits.TRISC3=0; LATCbits.LATC3=0;
#endif
#if CYL_COUNT>=5
TRISCbits.TRISC4=0; LATCbits.LATC4=0;
#endif
#if CYL_COUNT>=6
TRISCbits.TRISC5=0; LATCbits.LATC5=0;
#endif
#if CYL_COUNT>=7
TRISCbits.TRISC6=0; LATCbits.LATC6=0;
#endif
#if CYL_COUNT>=8
TRISCbits.TRISC7=0; LATCbits.LATC7=0;
#endif
}
static inline void INJ_SET(uint8_t c, uint8_t on){
switch(c){
case 0: LATCbits.LATC0=on; break; case 1: LATCbits.LATC1=on; break;
case 2: LATCbits.LATC2=on; break; case 3: LATCbits.LATC3=on; break;
#if CYL_COUNT>=5
case 4: LATCbits.LATC4=on; break; case 5: LATCbits.LATC5=on; break;
#endif
#if CYL_COUNT>=7
case 6: LATCbits.LATC6=on; break; case 7: LATCbits.LATC7=on; break;
#endif
}
}

// Coil-per-cylinder: RD0..RD(N-1)
#if COIL_PER_CYL
static inline void ign_init_pins(void){
#if CYL_COUNT>=1
TRISDbits.TRISD0=0; LATDbits.LATD0=0;
#endif
#if CYL_COUNT>=2
TRISDbits.TRISD1=0; LATDbits.LATD1=0;
#endif
#if CYL_COUNT>=3
TRISDbits.TRISD2=0; LATDbits.LATD2=0;
#endif
#if CYL_COUNT>=4
TRISDbits.TRISD3=0; LATDbits.LATD3=0;
#endif
#if CYL_COUNT>=5
TRISDbits.TRISD4=0; LATDbits.LATD4=0;
#endif
#if CYL_COUNT>=6
TRISDbits.TRISD5=0; LATDbits.LATD5=0;
#endif
#if CYL_COUNT>=7
TRISDbits.TRISD6=0; LATDbits.LATD6=0;
#endif
#if CYL_COUNT>=8
TRISDbits.TRISD7=0; LATDbits.LATD7=0;
#endif
}
static inline void IGN_SET(uint8_t c, uint8_t on){
switch(c){
case 0: LATDbits.LATD0=on; break; case 1: LATDbits.LATD1=on; break;
case 2: LATDbits.LATD2=on; break; case 3: LATDbits.LATD3=on; break;
#if CYL_COUNT>=5
case 4: LATDbits.LATD4=on; break; case 5: LATDbits.LATD5=on; break;
#endif
#if CYL_COUNT>=7
case 6: LATDbits.LATD6=on; break; case 7: LATDbits.LATD7=on; break;
#endif
}
}
#else
static inline void ign_init_pins(void){ IGN_TRIS=0; IGN_LAT=0; }
static inline void IGN_SET(uint8_t c, uint8_t on){ (void)c; IGN_LAT=on; }
#endif

/*================= Distributor math =================*/
#define SECTOR_DEG (360.0f/(float)CYL_COUNT)

static volatile float us_per_cam_deg = 100.0f;
static volatile uint16_t rpm_cam = 0;

/*================= Per-cylinder maps =================*/
static volatile float inj_deg[CYL_COUNT] = {10};
static volatile float spk_deg[CYL_COUNT] = {20};
static volatile float inj_ms [CYL_COUNT] = {3.0};
static volatile uint8_t firingOrder[CYL_COUNT]; // sensor index -> cylinder index (0-based)

/*================= Event queue & timebase =============*/
typedef enum {EV_NONE=0, EV_INJ_ON, EV_INJ_OFF, EV_SPK_ON, EV_SPK_OFF} ev_t;
typedef struct { uint32_t due; ev_t type; uint8_t cyl; } event_t;
#define QSIZE 48
static volatile event_t q[QSIZE];
static volatile uint8_t qh=0, qt=0;
static volatile uint32_t t32=0;

static inline double TICK_US(void){ return T1_TICK_US; }

static inline uint32_t now_us(void){
uint16_t lo=TMR1; uint32_t hi=t32 & 0xFFFF0000UL;
if(PIR4bits.TMR1IF && lo<0x8000) hi+=0x00010000UL;
return hi|lo;
}
static inline void q_push(event_t e){ uint8_t n=(qt+1u)%QSIZE; if(n!=qh){ q[qt]=e; qt=n; } }
static inline bool q_peek(event_t*e){ if(qh==qt) return false; *e=q[qh]; return true; }
static inline bool q_pop(event_t*e){ if(qh==qt) return false; *e=q[qh]; qh=(qh+1u)%QSIZE; return true; }
static void arm_next_compare(void){
if(qh==qt){ CCPR1 = TMR1 + 1000; return; }
uint8_t i=qh, idx=qh; uint32_t now=now_us(); uint32_t best=q[qh].due;
while(i!=qt){
if((int32_t)(q.due - now) < (int32_t)(best - now)){ best=q.due; idx=i; }
i=(i+1u)%QSIZE;
}
event_t t=q[qh]; q[qh]=q[idx]; q[idx]=t;
CCPR1 = (uint16_t)(q[qh].due & 0xFFFF);
}

/*================= EEPROM config (CRC16) ==============*/
typedef struct {
uint16_t magic; // 0xBEE6
uint8_t ver; // 1
uint8_t cyl; // CYL_COUNT
uint8_t modeDual;
uint8_t reserved;
uint8_t firing[8];
float ia[8];
float sa[8];
float pw[8];
uint16_t crc;
} cfg_t;

#define CFG_MAGIC 0xBEE6
#define CFG_VER 1
#define EE_BASE 0x0000

static uint16_t crc16(const uint8_t* p, uint16_t n){
uint16_t c=0xFFFF;
while(n--){
c ^= (uint16_t)(*p++)<<8;
for(uint8_t i=0;i<8;i++)
c = (c&0x8000)? (c<<1)^0x1021 : (c<<1);
}
return c;
}

// Low-level EEPROM R/W for K42/Q84
static void ee_write_byte(uint16_t a, uint8_t v){
NVMADRL = a & 0xFF; NVMADRH = a>>8;
NVMDATL = v; NVMCON1 = 0x04; // WREN=1, CFGS=0, FREE=0, EE write
INTCON0bits.GIE=0;
NVMCON2=0x55; NVMCON2=0xAA; NVMCON1bits.WR=1;
while(NVMCON1bits.WR);
NVMCON1bits.WREN=0; INTCON0bits.GIE=1;
}
static uint8_t ee_read_byte(uint16_t a){
NVMADRL = a & 0xFF; NVMADRH = a>>8;
NVMCON1 = 0x00; // CFGS=0, FREE=0
NVMCON1bits.RD=1;
return NVMDATL;
}
static void ee_write_block(uint16_t a, const uint8_t* b, uint16_t n){ while(n--) ee_write_byte(a++,*b++); }
static void ee_read_block (uint16_t a, uint8_t* b, uint16_t n){ while(n--) *b++=ee_read_byte(a++); }

static void cfg_save(void){
cfg_t c={0};
c.magic=CFG_MAGIC; c.ver=CFG_VER; c.cyl=CYL_COUNT; c.modeDual=MODE_DUAL;
for(uint8_t i=0;i<CYL_COUNT;i++){ c.firing=firingOrder; c.ia=inj_deg; c.sa=spk_deg; c.pw=inj_ms; }
c.crc=0;
c.crc = crc16((const uint8_t*)&c, sizeof(cfg_t)-2);
ee_write_block(EE_BASE,(const uint8_t*)&c,sizeof c);
}
static bool cfg_load(void){
cfg_t c; ee_read_block(EE_BASE,(uint8_t*)&c,sizeof c);
if(c.magic!=CFG_MAGIC || c.ver!=CFG_VER || c.cyl!=CYL_COUNT) return false;
uint16_t chk=crc16((const uint8_t*)&c,sizeof(cfg_t)-2);
if(chk!=c.crc) return false;
for(uint8_t i=0;i<CYL_COUNT;i++){
firingOrder=c.firing; inj_deg=c.ia; spk_deg=c.sa; inj_ms=c.pw;
}
return true;
}

/*================= Presets (firing orders) ============*/
// Map is "sensor index 0..N-1" -> "cylinder index 0..N-1"
// Presets assume sensor #0 aligns with cylinder #1 TDC compression reference.
// 6-cyl common:
// I6_A: 1-5-3-6-2-4 (e.g., Toyota/BMW inline-6 classics)
// I6_B: 1-4-2-5-3-6
static const uint8_t FO_6_I6_A[6]={0,4,2,5,1,3};
static const uint8_t FO_6_I6_B[6]={0,3,1,4,2,5};

// 8-cyl common:
// SBC (Chevy): 1-8-4-3-6-5-7-2
// LS (Chevy): 1-8-7-2-6-5-4-3
// Ford HO/351: 1-3-7-2-6-5-4-8
static const uint8_t FO_8_SBC[8]={0,7,3,2,5,4,6,1};
static const uint8_t FO_8_LS [8]={0,7,6,1,5,4,3,2};
static const uint8_t FO_8_FHO[8]={0,2,6,1,5,4,3,7};

static void apply_preset(const char* name){
#if CYL_COUNT==6
if(!strcmp(name,"i6_153624")) memcpy((void*)firingOrder,FO_6_I6_A,6);
else if(!strcmp(name,"i6_142536")) memcpy((void*)firingOrder,FO_6_I6_B,6);
else memcpy((void*)firingOrder,FO_6_I6_A,6);
#elif CYL_COUNT==8
if(!strcmp(name,"v8_sbc")) memcpy((void*)firingOrder,FO_8_SBC,8);
else if(!strcmp(name,"v8_ls")) memcpy((void*)firingOrder,FO_8_LS,8);
else if(!strcmp(name,"v8_ford_ho")) memcpy((void*)firingOrder,FO_8_FHO,8);
else memcpy((void*)firingOrder,FO_8_SBC,8);
#endif
}

/*================= UART (K42: EUSART2 RD0/RD1 ; Q84: EUSART1 RC6/RC7) =====*/
static void uart_puts(const char*s){
#if TARGET_K42
while(*s){ while(!U2TXIF); U2TXB=*s++; }
#else
while(*s){ while(!U1TXIF); U1TXB=*s++; }
#endif
}
static void uart_putf(const char*fmt,...){
char b[160]; va_list ap; va_start(ap,fmt); vsnprintf(b,sizeof b,fmt,ap); va_end(ap); uart_puts(b);
}
static bool uart_getline(char*out,int n){
static int i=0;
#if TARGET_K42
while(U2RXIF){
char c=U2RXB;
#else
while(U1RXIF){
char c=U1RXB;
#endif
if(c=='\r'||c=='\n'){ if(i){ out=0; i=0; return true; } }
else if(i<n-1){ out[i++]=c; }
}
return false;
}

/*================= Hardware init ======================*/
static void clock_init(void){
T1CLK=0x01; T1CON=0;
uint8_t ps=(T1_PRESCALE==1)?0:(T1_PRESCALE==2)?1:(T1_PRESCALE==4)?2:3;
T1CONbits.CKPS=ps; TMR1=0; PIR4bits.TMR1IF=0; PIE4bits.TMR1IE=1; T1CONbits.ON=1;

// CCP1 compare -> Timer1
CCPTMRS0bits.C1TSEL=0; CCP1CON=0b1000; PIR4bits.CCP1IF=0; PIE4bits.CCP1IE=1;
}

static void pins_init(void){
// Digital on used ports
ANSELA=0; ANSELB=0; ANSELC=0; ANSELD=0; ANSELE=0;

// Outputs
inj_init_pins(); ign_init_pins(); LED_TRIS=0; LED_LAT=0;

// Inputs: sensors (RBx layer A, RAx layer B)
TRISB=0xFF; WPUB=0xFF;
TRISA=0xFF; WPUA=0xFF;

// IOC for PORTB (A-layer)
IOCBF=0; IOCBN=0; IOCBP=0;
for(uint8_t i=0;i<CYL_COUNT;i++){ IOCBN|=(1u<<i); IOCBP|=(1u<<i); }

#if MODE_DUAL
// IOC for PORTA (B-layer)
IOCAF=0; IOCAN=0; IOCAP=0;
for(uint8_t i=0;i<CYL_COUNT;i++){ IOCAN|=(1u<<i); IOCAP|=(1u<<i); }
#endif
PIR0bits.IOCIF=0; PIE0bits.IOCIE=1;

// UART PPS
INTCON0bits.GIE=0;
#if TARGET_K42
PPSLOCK=0x55; PPSLOCK=0xAA; PPSLOCKbits.PPSLOCKED=0;
RD0PPS = 0x12; // EUSART2 TX -> RD0
U2RXPPS= 0x19; // RD1 -> EUSART2 RX
PPSLOCK=0x55; PPSLOCK=0xAA; PPSLOCKbits.PPSLOCKED=1;

U2BRG=(uint16_t)((FOSC_HZ/64/115200UL)-1);
U2CON0=0b10010000; U2CON1=0b10000000; U2CON2=0;
#else
PPSLOCK=0x55; PPSLOCK=0xAA; PPSLOCKbits.PPSLOCKED=0;
RC6PPS=0x09; // EUSART1 TX -> RC6
U1RXPPS=0x17; // RC7 -> EUSART1 RX
PPSLOCK=0x55; PPSLOCK=0xAA; PPSLOCKbits.PPSLOCKED=1;

U1BRG=(uint16_t)((FOSC_HZ/64/115200UL)-1);
U1CON0=0b10010000; U1CON1=0b10000000; U1CON2=0;
#endif
INTCON0bits.GIE=1;
}

/*================= CLI ===============================*/
static void print_help(void){
uart_puts(
"get | set ia <c> <deg> | set sa <c> <deg> | set pw <c> <ms>\r\n"
"order <idx> <cyl> | preset <name>\r\n"
#if CYL_COUNT==6
" presets: i6_153624 | i6_142536\r\n"
#else
" presets: v8_sbc | v8_ls | v8_ford_ho\r\n"
#endif
"save | load | defaults\r\n");
}

/*================= Edge handling =====================*/
static inline uint8_t first_set(uint8_t v){ for(uint8_t i=0;i<8;i++) if(v&(1u<<i)) return i; return 0xFF; }

static void on_edge(uint8_t sensorIdx, bool layerB){
LED_LAT=!LED_LAT;

// sector timing (adjacent edges)
static uint16_t t_last=0;
uint16_t tnow=TMR1, dt=tnow - t_last; t_last=tnow;
if(dt==0) dt=1;
double us_sector = dt * T1_TICK_US;
us_per_cam_deg = (float)(us_sector / SECTOR_DEG);

double cam_rev_us = us_sector * (360.0/SECTOR_DEG);
if(cam_rev_us>1.0) rpm_cam = (uint16_t)(60000000.0 / cam_rev_us);

// map sensor -> cylinder
uint8_t cyl = firingOrder[sensorIdx];
uint32_t t0 = now_us();

// schedule injector
uint32_t t_inj_on = t0 + (uint32_t)(inj_deg[cyl] * us_per_cam_deg);
uint32_t t_inj_off = t_inj_on + (uint32_t)(inj_ms[cyl] * 1000.0);
q_push((event_t){t_inj_on, EV_INJ_ON, cyl});
q_push((event_t){t_inj_off, EV_INJ_OFF, cyl});

// schedule spark: layer A (single) or layer B (dual)
#if MODE_DUAL
if(layerB)
#endif
{
uint32_t t_spk = t0 - (uint32_t)(spk_deg[cyl] * us_per_cam_deg); // BEFORE edge
q_push((event_t){t_spk, EV_SPK_ON, cyl});
q_push((event_t){t_spk+200, EV_SPK_OFF, cyl}); // ~200us
}
}

/*================= ISRs ==============================*/
void __interrupt(irq(TMR1), low_priority) TMR1_ISR(void){
if(PIR4bits.TMR1IF){ PIR4bits.TMR1IF=0; t32+=0x00010000UL; }
}
void __interrupt(irq(IOC), low_priority) IOC_ISR(void){
if(PIR0bits.IOCIF){
uint8_t rb=PORTB; uint8_t mA=(~rb) & ((CYL_COUNT>=8)?0xFF:(uint8_t)((1u<<CYL_COUNT)-1u));
if(mA){ uint8_t s=first_set(mA); if(s<CYL_COUNT) on_edge(s,false); }
#if MODE_DUAL
uint8_t ra=PORTA; uint8_t mB=(~ra) & ((CYL_COUNT>=8)?0xFF:(uint8_t)((1u<<CYL_COUNT)-1u));
if(mB){ uint8_t s=first_set(mB); if(s<CYL_COUNT) on_edge(s,true); }
IOCAF=0;
#endif
IOCBF=0; PIR0bits.IOCIF=0;
}
}
void __interrupt(irq(CCP1), low_priority) CCP1_ISR(void){
if(PIR4bits.CCP1IF){
PIR4bits.CCP1IF=0;
uint32_t t=now_us(); event_t e;
while(q_peek(&e)){
if((int32_t)(t - e.due) < 0) break;
q_pop(&e);
switch(e.type){
case EV_INJ_ON: INJ_SET(e.cyl,1); break;
case EV_INJ_OFF: INJ_SET(e.cyl,0); break;
case EV_SPK_ON: IGN_SET(e.cyl,1); break;
case EV_SPK_OFF: IGN_SET(e.cyl,0); break;
default: break;
}
}
arm_next_compare();
}
}

/*================= Defaults & CLI loop ================*/
static void apply_defaults(void){
// uniform starting maps
for(uint8_t i=0;i<CYL_COUNT;i++){ inj_deg=10.0f; spk_deg=20.0f; inj_ms=3.0f; }
#if CYL_COUNT==6
apply_preset("i6_153624");
#else
apply_preset("v8_sbc");
#endif
}
static void banner(void){
uart_puts("\r\n[Optical Distributor | ");
#if CYL_COUNT==6
uart_puts("6-cyl]\r\n");
#else
uart_puts("8-cyl]\r\n");
#endif
uart_putf("tick=%.3fus dual=%d coil-per-cyl=%d\r\n", T1_TICK_US, (int)MODE_DUAL, (int)COIL_PER_CYL);
print_help();
}
static void cli_tick(void){
char line[96];
if(!uart_getline(line,sizeof line)) return;
if(!strncmp(line,"get",3)){
uart_putf("rpm_cam=%u us/deg=%.3f\r\n", rpm_cam, us_per_cam_deg);
for(uint8_t c=0;c<CYL_COUNT;c++)
uart_putf("cyl%u: ia=%.2f sa=%.2f pw=%.3f map=%u\r\n", c+1, (double)inj_deg[c], (double)spk_deg[c], (double)inj_ms[c], (unsigned)firingOrder[c]);
} else if(!strncmp(line,"set ia ",7)){
int c; float v; if(sscanf(line+7,"%d %f",&c,&v)==2 && c>=1 && c<=CYL_COUNT){ inj_deg[c-1]=v; uart_puts("OK\r\n"); }
} else if(!strncmp(line,"set sa ",7)){
int c; float v; if(sscanf(line+7,"%d %f",&c,&v)==2 && c>=1 && c<=CYL_COUNT){ spk_deg[c-1]=v; uart_puts("OK\r\n"); }
} else if(!strncmp(line,"set pw ",7)){
int c; float v; if(sscanf(line+7,"%d %f",&c,&v)==2 && c>=1 && c<=CYL_COUNT){ inj_ms[c-1]=v; uart_puts("OK\r\n"); }
} else if(!strncmp(line,"order ",6)){
int idx, cyl; if(sscanf(line+6,"%d %d",&idx,&cyl)==2 && idx>=1 && idx<=CYL_COUNT && cyl>=1 && cyl<=CYL_COUNT){
firingOrder[idx-1]=(uint8_t)(cyl-1); uart_puts("OK\r\n");
} else print_help();
} else if(!strncmp(line,"preset ",7)){
apply_preset(line+7); uart_puts("OK preset\r\n");
} else if(!strcmp(line,"save")){
cfg_save(); uart_puts("saved\r\n");
} else if(!strcmp(line,"load")){
uart_puts(cfg_load()?"loaded\r\n":"load failed\r\n");
} else if(!strcmp(line,"defaults")){
apply_defaults(); uart_puts("defaults applied\r\n");
} else {
print_help();
}
}

/*================= Main ==============================*/
static void init_uart_banner(void){
// make sure UART is already up from pins_init()
banner();
}
void main(void){
clock_init(); pins_init();
apply_defaults(); (void)cfg_load(); // load if valid
// interrupts on
INTCON0bits.GIEH=1; INTCON0bits.GIEL=1;
init_uart_banner();
for(;;){ cli_tick(); arm_next_compare(); }
}

How to build & wire (quick)

In the file, set CYL_COUNT to 6 (or 8), decide tick (FOSC_HZ=32MHz for 1.000 µs or 64MHz for 0.5 µs), and choose MODE_DUAL (usually 0 for single-layer).

Flash to PIC18F47K42 (Curiosity Nano) or 57Q84/43.

Sensors: RB0..RB(N-1), active-LOW. (If dual: RA0..RA(N-1) for layer-B).

Injectors: RC0..RC(N-1) → your MOSFET drivers.

Ignition: RD0..RD(N-1) to your coil drivers (or set COIL_PER_CYL=0 to use RE1 single coil).

Open serial @ 115200. Type:

get
preset i6_153624 // or: v8_sbc | v8_ls | v8_ford_ho | i6_142536
set ia 1 8.0
set sa 1 18.0
set pw 1 2.5
save

============
Spin the shaft; watch per-cyl injector and ignition pulses align with your degrees across RPM.

Step-by-step: what changed & why (so you can replicate)

Generalized N-cyl math: sector = 360/N cam degrees. One edge-to-edge interval ⇒ us_per_cam_deg = dt_us / (360/N).

Per-cyl scheduling: on each edge we map sensorIdx → cylinder via firingOrder[], and enqueue INJ_ON/OFF and SPK_ON/OFF at absolute times computed from angles and PW.

Coil-per-cyl: ignition outputs are a simple IGN_SET(cyl,on) to RDx, so each cylinder can have its own CDI/IGBT (cleaner dwell/energy control later).

EEPROM profile: we snapshot firingOrder, inj_deg, spk_deg, inj_ms with a CRC16 so you can power-cycle and keep maps.

Presets: common firing orders are encoded and applied to firingOrder[] so you don’t have to type them in.

Dual-stack option: if you set MODE_DUAL=1, the spark edges are sourced from PORTA (layer-B). For 6/8-cyl you’ll typically run single-layer (layer-A).

7) Bench validation (repeatable workflow)

Static sensor check

Block each slot with a card; verify the corresponding RBx reads active-LOW.

Spin test (drill on the shaft coupler, ~500–3000 rpm cam):

Confirm rpm_cam monotonic; us/deg ≈ dt_us / 60° (6-cyl) or /45° (8-cyl).

Scope/LA

Trigger on RB0 edge. Measure D(RB0→RC0); it should equal ia[1] in degrees × us_per_deg.

Measure ignition pulse start vs. edge; confirm equals sa[cyl].

Noise testing

Tap a small ignition coil nearby; confirm no false triggering (add LM393 or RC where needed).

Save profile (save) and power cycle; load if needed.

8) Automotive signal integrity

Comparators: Square the phototransistor with LM393 near the ECU; route open-collector outputs into RBx with 10–22 k pull-ups.

Filters: 100 nF to ground at each input pin; short return to sensor ground.

Harness: shielded twisted-pair for each sensor; separate logic ground from coil/CDI grounds; single star return.

Protection: TVS on 12 V supply; flybacks on injectors; opto isolation for CDI trigger.

9) Dual-stack vs. single-stack (what the angles mean)

Single-stack (MODE_DUAL=0): one layer does both maps. Treat ia as ATDC after that cylinder’s reference edge; treat sa as BTDC before the next TDC (see Patch B).

Dual-stack (MODE_DUAL=1): you can dedicate Layer-B to spark phase (e.g., an earlier reference). With a properly phased B-disc, sa can be scheduled strictly after the B-edge (positive “before-TDC” with B leading).

on October 6th, 11:08 PM

10) Two code refinements you’ll likely want
Patch A — Safer CCP compare arming (relative schedule)

Why
CCP1 is 16-bit; your events are in absolute µs (32-bit). If you set CCPR1 = low16(due) the ISR may fire early (next wrap), then re-arm. It works, but under dense loads it’s chatty.
Fix
Arm CCP relative to current TMR1 by scanning for the soonest event and converting “time-to-go” (µs) into TMR1 ticks:

static uint16_t us_to_ticks(uint32_t us){
// T1_TICK_US is double; convert safely without ISR burden
double ticks = (double)us / T1_TICK_US;
if (ticks < 50.0) ticks = 50.0; // >= ~25us at 0.5us tick
if (ticks > 65535.0) ticks = 65535.0;
return (uint16_t)(ticks + 0.5);
}

static void arm_next_compare(void){
if (qh == qt){ CCPR1 = TMR1 + 1000; return; }
uint32_t now = now_us(), best = 0xFFFFFFFFUL;
for (uint8_t i=qh; i!=qt; i=(i+1u)%QSIZE){
uint32_t d = (q.due > now) ? (q.due - now) : 0;
if (d < best) best = d;
}
CCPR1 = TMR1 + us_to_ticks(best);
}
Drop-in replacement for your current arm_next_compare().

Patch B — Predictive BTDC spark (never “in the past”)

Why
If you schedule spark as t_edge - sa*us_per_deg (pure BTDC), it can be in the past relative to the edge you just observed. The event will execute immediately, which is not truly BTDC.
Fix (single-layer)
Define sector_us = us_per_cam_deg * SECTOR_DEG and schedule into the future toward the next TDC:

// inside on_edge(...), replacing the spark schedule block when MODE_DUAL==0
double sector_us = (double)us_per_cam_deg * (double)SECTOR_DEG;
double lead_us = (double)spk_deg[cyl] * (double)us_per_cam_deg;
// Schedule spark "sector_us - lead_us" after the current edge (predictive BTDC)
uint32_t t_spk = t0 + (uint32_t)(sector_us - lead_us + 0.5);
q_push((event_t){t_spk, EV_SPK_ON, cyl});
q_push((event_t){t_spk+200, EV_SPK_OFF, cyl});

Fix (dual-stack)
If Layer-B edges are already ahead in phase for BTDC, keep your original logic (spark after B-edge) and tune sa accordingly.

11) Coils and injectors (practical drive notes)

Injectors: logic MOSFET + flyback (or smart low-side driver). Keep pw under static duty limits (<85%).

CDI/coil: trigger through an opto or isolated driver. For DC-CDI, a 100–300 µs trigger pulse is typical; your ignPW_us default of ~200 µs is in the pocket.

Thermal & EMI: mount drivers on a grounded heat spreader; keep HV cables away from sensor harness.

12) What “get” should look like when it’s healthy

Example at ~1200 rpm cam (2400 rpm crank on a 4-stroke distributor):

rpm_cam=1200 us/deg=46.0
cyl1: ia=10.00 sa=20.00 pw=3.000 map=0
cyl2: ia=10.00 sa=20.00 pw=3.000 map=4
cyl3: ia=10.00 sa=20.00 pw=3.000 map=2
cyl4: ia=10.00 sa=20.00 pw=3.000 map=5
cyl5: ia=10.00 sa=20.00 pw=3.000 map=1
cyl6: ia=10.00 sa=20.00 pw=3.000 map=3

us/deg × SECTOR_DEG ≈ sector time (e.g., 46 µs/° × 60° ≈ 2.76 ms).

Compute crank rpm ≈ rpm_cam * 2 if the distributor is at cam speed.

13) Step-by-step: how this firmware achieves Meyer-style control

Edge capture on RBx (and optionally RAx) converts the optical gate’s mechanical position into digital timing marks.

Sector timing (dt_us) produces a live µs/° value, immune to RPM changes.

The firing order map translates the sensor index to the active cylinder.

The event queue schedules INJ_ON/OFF and SPK_ON/OFF at absolute µs timestamps.

Timer1 + CCP1 wake the CPU just in time to flip pins with microsecond accuracy.

The CLI + EEPROM let you field-tune angles/pulse widths and persist maps, exactly like a GMS “software distributor”.

14) Alternatives / extensions (if you want to go wild)

Crank 60-2 + cam 1-x sensors → replace optics; use CCP capture for tooth timing; higher fidelity at high rpm.

dsPIC33 / PIC24 → hardware PWM & input capture offload; more outputs; deterministic scheduling.

Teensy 4.1 companion → log in-cylinder pressure, correlate with MBT and auto-tune ia/sa/pw.

16) Practical action plan (do this next)

Build with CYL_COUNT=6 (or 8), FOSC_HZ=64 MHz, T1_PRESCALE=8.

Wire RBx→sensors, RCx→injectors, RDx→coils, RE0 LED. Keep CDI isolated.

Boot, defaults, preset, save. (defaults, preset ..., save).

Spin and scope: verify us/deg, injector/ignition phase.

Apply Patch A (relative CCP compare). Re-test at low and high RPM.

Apply Patch B (predictive BTDC) if running single-layer BTDC spark.

EMI-harden: add LM393s if any jitter; tidy grounds; add RC where needed.

Dyno tune: adjust ia/sa/pw per cylinder to your nano-bubble/HHO strategy; save.

================\

on October 6th, 11:14 PM

2025 OCTOBER FINAL

Here’s the cleaned, commented v1.1 single-file XC8 source with Patch A (relative CCP arming) and Patch B (predictive BTDC spark) already integrated. It builds as 6-cyl or 8-cyl via one #define, supports coil-per-cyl, EEPROM, presets, and the CLI you asked for.

Quick note on UART PPS vs. I/O collisions:

Default UART is EUSART2 on RE4 (TX) / RE5 (RX) to avoid clashes with injectors (PORTC) and ignition (PORTD).

If your board needs different pins, change the PPS lines in pins_init() (commented clearly).

/* ================================================================
* Meyer-Style Optical Distributor (v1.1)
* PIC18F47K42 / PIC18F57Q84 family — XC8 v2.x — single-file
*
* NEW in v1.1:
* • Patch A: Relative CCP compare arming (µs → Timer1 ticks) to avoid
* wrap/early-fire edge cases under dense loads.
* • Patch B: Predictive BTDC spark scheduling (no “in-the-past” triggers)
* for MODE_DUAL=0 (single-layer). Dual-layer behavior unchanged.
* • Clean comments, safer UART PPS defaults, small polish to CLI.
*
* Build-time options:
* - TARGET_K42 / TARGET_Q84 (select your device family)
* - CYL_COUNT = 6 or 8 (sector = 60° or 45°)
* - FOSC_HZ = 64e6 (0.5 µs tick) or 32e6 (1.0 µs tick)
* - T1_PRESCALE = 8 (recommended)
* - MODE_DUAL = 0/1 (single layer or dual-stack edges for spark)
* - COIL_PER_CYL = 1/0 (RDx per cylinder, or single-coil on RE1)
*
* Default I/O (change below if needed):
* Inputs (Layer-A): RB0..RB(N-1), active-LOW (slot blocked LOW)
* Inputs (Layer-B): RA0..RA(N-1), active-LOW (if MODE_DUAL=1)
* Injectors: RC0..RC(N-1) (active-HIGH)
* Ignition: RD0..RD(N-1) (active-HIGH) OR RE1 single-coil
* Status LED: RE0
* UART (CLI): EUSART2 → RE4 (TX) / RE5 (RX) [change PPS if needed]
*
* CLI @115200:
* get | set ia <c> <deg> | set sa <c> <deg> | set pw <c> <ms>
* order <idx> <cyl> | preset <name> | save | load | defaults
*
* Presets:
* 6-cyl: i6_153624 | i6_142536
* 8-cyl: v8_sbc | v8_ls | v8_ford_ho
*
* (c) Prepared for Mr. Daniel Donatelli — Secure Supplies Group — 2025
* License: MIT
* ================================================================ */

#include <xc.h>
#include <stdint.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdarg.h>
#include <string.h>

/*================= SELECT BUILD OPTIONS =================*/
// Target (pick exactly one)
#define TARGET_K42 1 // 1=PIC18F47K42 family
#define TARGET_Q84 0 // 1=PIC18F57Q84/43 family

// Cylinder count (build as one of these two)
#define CYL_COUNT 6 // <-- set 6 OR 8

// Clock/timer
#define FOSC_HZ 64000000UL // 64 MHz → 0.5 µs TMR1 tick @ prescale 1:8
#define T1_PRESCALE 8 // 1,2,4,8 (use 8 for stable ticks)

// Dual stack edge source (second optical layer on PORTA)
#define MODE_DUAL 0 // 0=single-layer A only, 1=dual (spark off layer B)

// Ignition style
#define COIL_PER_CYL 1 // 1=RDx per cylinder, 0=single-coil RE1

/*================= CONFIG BITS (minimal) =================*/
#if TARGET_K42
#pragma config FEXTOSC=OFF, RSTOSC=HFINTOSC_64MHZ
#pragma config CLKOUTEN=OFF, PR1WAY=ON, CSWEN=ON, MCLRE=EXTMCLR
#pragma config WDTE=OFF, LVP=ON, IVT1WAY=ON, MVECEN=ON
#elif TARGET_Q84
#pragma config FEXTOSC=OFF, RSTOSC=HFINTOSC_64MHZ
#pragma config CLKOUTEN=OFF, MCLRE=EXTMCLR, WDTE=OFF, LVP=ON, PBADEN=OFF
#else
# error "Select TARGET_K42 or TARGET_Q84"
#endif

/*================= Derived timing (ticks <-> microseconds) ============*/
// Timer1 tick period (us) = 4 * Prescale / (Fosc in MHz)
#define T1_TICK_US_DBL ((double)(4.0 * (double)T1_PRESCALE * 1e6) / (double)FOSC_HZ)

// For fast integer conversions, we support the two recommended setups:
// 64 MHz / 1:8 → 0.5 µs per tick
// 32 MHz / 1:8 → 1.0 µs per tick
#if (FOSC_HZ==64000000UL) && (T1_PRESCALE==8)
#define T1_TICK_US_NUM 1
#define T1_TICK_US_DEN 2 // 0.5 us
#elif (FOSC_HZ==32000000UL) && (T1_PRESCALE==8)
#define T1_TICK_US_NUM 1
#define T1_TICK_US_DEN 1 // 1.0 us
#else
// Fallback: use double for conversions (slower)
#define T1_TICK_FALLBACK 1
#endif

/*================= Helper: tick/us conversions ========================*/
static inline uint32_t ticks_to_us(uint32_t ticks){
#ifdef T1_TICK_FALLBACK
double us = (double)ticks * T1_TICK_US_DBL;
if (us < 0) us = 0;
return (uint32_t)(us + 0.5);
#else
// (ticks * NUM) / DEN
#if (T1_TICK_US_DEN==1)
return (uint32_t)ticks * T1_TICK_US_NUM;
#else // 0.5us case
// ticks * 1 / 2
return (uint32_t)(ticks >> 1) + (ticks & 1 ? 1 : 0); // round half up
#endif
#endif
}
static inline uint16_t us_to_ticks(uint32_t us){
#ifdef T1_TICK_FALLBACK
double ticks = (double)us / T1_TICK_US_DBL;
if (ticks < 50.0) ticks = 50.0; // ≥ ~25 µs guard (at 0.5 µs tick)
if (ticks > 65535.0) ticks = 65535.0;
return (uint16_t)(ticks + 0.5);
#else
#if (T1_TICK_US_DEN==1)
uint64_t t = (uint64_t)us * (uint64_t)T1_TICK_US_NUM;
#else // 0.5us case: ticks = us * 2
uint64_t t = ((uint64_t)us) << 1;
#endif
if (t < 50) t = 50; // ≥ ~25 µs guard time
if (t > 65535) t = 65535;
return (uint16_t)t;
#endif
}

/*================= Pins (default map) =================*/
// Status LED & single-coil (if used)
#define LED_LAT LATEbits.LATE0
#define LED_TRIS TRISEbits.TRISE0
#define IGN_LAT LATEbits.LATE1
#define IGN_TRIS TRISEbits.TRISE1

// Injectors: RC0..RC(N-1)
static inline void inj_init_pins(void){
#if CYL_COUNT>=1
TRISCbits.TRISC0=0; LATCbits.LATC0=0;
#endif
#if CYL_COUNT>=2
TRISCbits.TRISC1=0; LATCbits.LATC1=0;
#endif
#if CYL_COUNT>=3
TRISCbits.TRISC2=0; LATCbits.LATC2=0;
#endif
#if CYL_COUNT>=4
TRISCbits.TRISC3=0; LATCbits.LATC3=0;
#endif
#if CYL_COUNT>=5
TRISCbits.TRISC4=0; LATCbits.LATC4=0;
#endif
#if CYL_COUNT>=6
TRISCbits.TRISC5=0; LATCbits.LATC5=0;
#endif
#if CYL_COUNT>=7
TRISCbits.TRISC6=0; LATCbits.LATC6=0; // NOTE: keep UART off RC6/RC7
#endif
#if CYL_COUNT>=8
TRISCbits.TRISC7=0; LATCbits.LATC7=0;
#endif
}
static inline void INJ_SET(uint8_t c, uint8_t on){
switch(c){
case 0: LATCbits.LATC0=on; break; case 1: LATCbits.LATC1=on; break;
case 2: LATCbits.LATC2=on; break; case 3: LATCbits.LATC3=on; break;
#if CYL_COUNT>=5
case 4: LATCbits.LATC4=on; break; case 5: LATCbits.LATC5=on; break;
#endif
#if CYL_COUNT>=7
case 6: LATCbits.LATC6=on; break; case 7: LATCbits.LATC7=on; break;
#endif
}
}

// Coil-per-cylinder: RD0..RD(N-1)
#if COIL_PER_CYL
static inline void ign_init_pins(void){
#if CYL_COUNT>=1
TRISDbits.TRISD0=0; LATDbits.LATD0=0;
#endif
#if CYL_COUNT>=2
TRISDbits.TRISD1=0; LATDbits.LATD1=0;
#endif
#if CYL_COUNT>=3
TRISDbits.TRISD2=0; LATDbits.LATD2=0;
#endif
#if CYL_COUNT>=4
TRISDbits.TRISD3=0; LATDbits.LATD3=0;
#endif
#if CYL_COUNT>=5
TRISDbits.TRISD4=0; LATDbits.LATD4=0;
#endif
#if CYL_COUNT>=6
TRISDbits.TRISD5=0; LATDbits.LATD5=0;
#endif
#if CYL_COUNT>=7
TRISDbits.TRISD6=0; LATDbits.LATD6=0;
#endif
#if CYL_COUNT>=8
TRISDbits.TRISD7=0; LATDbits.LATD7=0;
#endif
}
static inline void IGN_SET(uint8_t c, uint8_t on){
switch(c){
case 0: LATDbits.LATD0=on; break; case 1: LATDbits.LATD1=on; break;
case 2: LATDbits.LATD2=on; break; case 3: LATDbits.LATD3=on; break;
#if CYL_COUNT>=5
case 4: LATDbits.LATD4=on; break; case 5: LATDbits.LATD5=on; break;
#endif
#if CYL_COUNT>=7
case 6: LATDbits.LATD6=on; break; case 7: LATDbits.LATD7=on; break;
#endif
}
}
#else
static inline void ign_init_pins(void){ IGN_TRIS=0; IGN_LAT=0; }
static inline void IGN_SET(uint8_t c, uint8_t on){ (void)c; IGN_LAT=on; }
#endif

/*================= Distributor math =================*/
#define SECTOR_DEG (360.0f/(float)CYL_COUNT)
static volatile float us_per_cam_deg = 100.0f; // updated per edge
static volatile uint16_t rpm_cam = 0;

/*================= Per-cylinder maps =================*/
static volatile float inj_deg[CYL_COUNT] = {10}; // injection angle (deg after edge)
static volatile float spk_deg[CYL_COUNT] = {20}; // spark angle (deg BTDC-equivalent)
static volatile float inj_ms [CYL_COUNT] = {3.0}; // injector width (ms)
static volatile uint8_t firingOrder[CYL_COUNT]; // sensor index -> cylinder index (0-based)

/*================= Event queue & timebase =============*/
typedef enum {EV_NONE=0, EV_INJ_ON, EV_INJ_OFF, EV_SPK_ON, EV_SPK_OFF} ev_t;
typedef struct { uint32_t due_us; ev_t type; uint8_t cyl; } event_t;
#define QSIZE 48
static volatile event_t q[QSIZE];
static volatile uint8_t qh=0, qt=0;

// 32-bit free-running TMR1 tick counter (lower 16 = TMR1)
static volatile uint32_t t32_ticks = 0;

// Now in MICROSECONDS (absolute, from ticks)
static inline uint32_t now_us(void){
uint16_t lo = TMR1; // read low part
uint32_t hi = t32_ticks & 0xFFFF0000UL;
if (PIR4bits.TMR1IF && lo < 0x8000) hi += 0x00010000UL; // handle race near overflow
uint32_t ticks32 = hi | lo;
return ticks_to_us(ticks32);
}

// Queue helpers
static inline void q_push(event_t e){ uint8_t n=(qt+1u)%QSIZE; if(n!=qh){ q[qt]=e; qt=n; } }
static inline bool q_peek(event_t*e){ if(qh==qt) return false; *e=q[qh]; return true; }
static inline bool q_pop (event_t*e){ if(qh==qt) return false; *e=q[qh]; qh=(qh+1u)%QSIZE; return true; }

/*================= EEPROM config (CRC16) ==============*/
typedef struct {
uint16_t magic; // 0xBEE6
uint8_t ver; // 1
uint8_t cyl; // CYL_COUNT
uint8_t modeDual;
uint8_t reserved;
uint8_t firing[8];
float ia[8];
float sa[8];
float pw[8];
uint16_t crc;
} cfg_t;

#define CFG_MAGIC 0xBEE6
#define CFG_VER 1
#define EE_BASE 0x0000

static uint16_t crc16(const uint8_t* p, uint16_t n){
uint16_t c=0xFFFF;
while(n--){
c ^= (uint16_t)(*p++)<<8;
for(uint8_t i=0;i<8;i++)
c = (c&0x8000)? (c<<1)^0x1021 : (c<<1);
}
return c;
}

// Low-level EEPROM R/W
static void ee_write_byte(uint16_t a, uint8_t v){
NVMADRL = a & 0xFF; NVMADRH = a>>8;
NVMDATL = v; NVMCON1 = 0x04; // WREN=1
INTCON0bits.GIE=0;
NVMCON2=0x55; NVMCON2=0xAA; NVMCON1bits.WR=1;
while(NVMCON1bits.WR);
NVMCON1bits.WREN=0; INTCON0bits.GIE=1;
}
static uint8_t ee_read_byte(uint16_t a){
NVMADRL = a & 0xFF; NVMADRH = a>>8;
NVMCON1 = 0x00; NVMCON1bits.RD=1;
return NVMDATL;
}
static void ee_write_block(uint16_t a, const uint8_t* b, uint16_t n){ while(n--) ee_write_byte(a++,*b++); }
static void ee_read_block (uint16_t a, uint8_t* b, uint16_t n){ while(n--) *b++=ee_read_byte(a++); }

static void cfg_save(void){
cfg_t c={0};
c.magic=CFG_MAGIC; c.ver=CFG_VER; c.cyl=CYL_COUNT; c.modeDual=MODE_DUAL;
for(uint8_t i=0;i<CYL_COUNT;i++){ c.firing=firingOrder; c.ia=inj_deg; c.sa=spk_deg; c.pw=inj_ms; }
c.crc=0;
c.crc = crc16((const uint8_t*)&c, sizeof(cfg_t)-2);
ee_write_block(EE_BASE,(const uint8_t*)&c,sizeof c);
}
static bool cfg_load(void){
cfg_t c; ee_read_block(EE_BASE,(uint8_t*)&c,sizeof c);
if(c.magic!=CFG_MAGIC || c.ver!=CFG_VER || c.cyl!=CYL_COUNT) return false;
uint16_t chk=crc16((const uint8_t*)&c,sizeof(cfg_t)-2);
if(chk!=c.crc) return false;
for(uint8_t i=0;i<CYL_COUNT;i++){
firingOrder=c.firing; inj_deg=c.ia; spk_deg=c.sa; inj_ms=c.pw;
}
return true;
}

/*================= Presets (firing orders) ============*/
// Map: sensor index (0..N-1) -> cylinder index (0..N-1)
static const uint8_t FO_6_I6_A[6]={0,4,2,5,1,3}; // 1-5-3-6-2-4
static const uint8_t FO_6_I6_B[6]={0,3,1,4,2,5}; // 1-4-2-5-3-6

static const uint8_t FO_8_SBC[8]={0,7,3,2,5,4,6,1}; // 1-8-4-3-6-5-7-2
static const uint8_t FO_8_LS [8]={0,7,6,1,5,4,3,2}; // 1-8-7-2-6-5-4-3
static const uint8_t FO_8_FHO[8]={0,2,6,1,5,4,3,7}; // 1-3-7-2-6-5-4-8

static void apply_preset(const char* name){
#if CYL_COUNT==6
if(!strcmp(name,"i6_153624")) memcpy((void*)firingOrder,FO_6_I6_A,6);
else if(!strcmp(name,"i6_142536")) memcpy((void*)firingOrder,FO_6_I6_B,6);
else memcpy((void*)firingOrder,FO_6_I6_A,6);
#elif CYL_COUNT==8
if(!strcmp(name,"v8_sbc")) memcpy((void*)firingOrder,FO_8_SBC,8);
else if(!strcmp(name,"v8_ls")) memcpy((void*)firingOrder,FO_8_LS,8);
else if(!strcmp(name,"v8_ford_ho")) memcpy((void*)firingOrder,FO_8_FHO,8);
else memcpy((void*)firingOrder,FO_8_SBC,8);
#endif
}

/*================= UART (CLI) =========================*/
/* Default mapping: EUSART2 on RE4 (TX) / RE5 (RX)
* If you prefer EUSART1 RC6/RC7 or others, change PPS in pins_init().
*/
static void uart_puts(const char*s){
#if TARGET_K42
while(*s){ while(!U2TXIF); U2TXB=*s++; }
#else
while(*s){ while(!U2TXIF); U2TXB=*s++; }
#endif
}
static void uart_putf(const char*fmt,...){
char b[160]; va_list ap; va_start(ap,fmt); vsnprintf(b,sizeof b,fmt,ap); va_end(ap); uart_puts(b);
}
static bool uart_getline(char*out,int n){
static int i=0;
#if TARGET_K42
while(U2RXIF){
char c=U2RXB;
#else
while(U2RXIF){
char c=U2RXB;
#endif
if(c=='\r'||c=='\n'){ if(i){ out=0; i=0; return true; } }
else if(i<n-1){ out[i++]=c; }
}
return false;
}

/*================= Hardware init ======================*/
static void clock_init(void){
// Timer1 @ Fosc/4 with prescale
T1CLK=0x01; T1CON=0;
uint8_t ps=(T1_PRESCALE==1)?0:(T1_PRESCALE==2)?1:(T1_PRESCALE==4)?2:3;
T1CONbits.CKPS=ps; TMR1=0; PIR4bits.TMR1IF=0; PIE4bits.TMR1IE=1; T1CONbits.ON=1;

// CCP1 compare -> Timer1
CCPTMRS0bits.C1TSEL=0; // CCP1 uses TMR1
CCP1CON=0b1000; // compare, toggle not used (we poll IF)
PIR4bits.CCP1IF=0; PIE4bits.CCP1IE=1;
}

static void pins_init(void){
// Make used ports digital
ANSELA=0; ANSELB=0; ANSELC=0; ANSELD=0; ANSELE=0;

// Outputs
inj_init_pins(); ign_init_pins(); LED_TRIS=0; LED_LAT=0;

// Inputs: sensors (RBx layer A, RAx layer B)
TRISB=0xFF; WPUB=0xFF; // pull-ups for clean idle-HIGH
TRISA=0xFF; WPUA=0xFF;

// IOC for PORTB (A-layer)
IOCBF=0; IOCBN=0; IOCBP=0;
for(uint8_t i=0;i<CYL_COUNT;i++){ IOCBN|=(1u<<i); IOCBP|=(1u<<i); }

#if MODE_DUAL
// IOC for PORTA (B-layer)
IOCAF=0; IOCAN=0; IOCAP=0;
for(uint8_t i=0;i<CYL_COUNT;i++){ IOCAN|=(1u<<i); IOCAP|=(1u<<i); }
#endif
PIR0bits.IOCIF=0; PIE0bits.IOCIE=1;

// UART PPS — default EUSART2 on RE4 (TX) / RE5 (RX)
INTCON0bits.GIE=0;
PPSLOCK=0x55; PPSLOCK=0xAA; PPSLOCKbits.PPSLOCKED=0;
// TX: U2TX function code = 0x12 (same as Microchip examples); assign to RE4
RE4PPS = 0x12;
// RX: select pin RE5 as input to U2RX
U2RXPPS = 0x25; // RE5 (port code 0x25)
PPSLOCK=0x55; PPSLOCK=0xAA; PPSLOCKbits.PPSLOCKED=1;

// EUSART2 @115200
U2BRG=(uint16_t)((FOSC_HZ/64/115200UL)-1);
U2CON0=0b10010000; U2CON1=0b10000000; U2CON2=0;
INTCON0bits.GIE=1;
}

/*================= CLI ===============================*/
static void print_help(void){
uart_puts(
"get | set ia <c> <deg> | set sa <c> <deg> | set pw <c> <ms>\r\n"
"order <idx> <cyl> | preset <name>\r\n"
#if CYL_COUNT==6
" presets: i6_153624 | i6_142536\r\n"
#else
" presets: v8_sbc | v8_ls | v8_ford_ho\r\n"
#endif
"save | load | defaults\r\n");
}

/*================= Edge handling =====================*/
static inline uint8_t first_set(uint8_t v){ for(uint8_t i=0;i<8;i++) if(v&(1u<<i)) return i; return 0xFF; }

/* ---- Patch B integrated (predictive BTDC for MODE_DUAL=0) ---- */
static void on_edge(uint8_t sensorIdx, bool layerB){
LED_LAT=!LED_LAT;

// Sector timing (adjacent edges on same layer)
static uint16_t t_last=0;
uint16_t tnow=TMR1; uint16_t dt_ticks = tnow - t_last; t_last=tnow;
if(dt_ticks==0) dt_ticks=1;

// Convert sector time to microseconds and per-degree
uint32_t us_sector = ticks_to_us(dt_ticks);
us_per_cam_deg = (float)us_sector / SECTOR_DEG;

// Approx cam RPM (for CLI)
double cam_rev_us = (double)us_sector * (360.0/SECTOR_DEG);
if (cam_rev_us>1.0) rpm_cam = (uint16_t)(60000000.0 / cam_rev_us);

// Map sensor -> cylinder
uint8_t cyl = firingOrder[sensorIdx];
uint32_t t0_us = now_us();

// ---- Injection schedule (deg after edge) ----
uint32_t t_inj_on = t0_us + (uint32_t)(inj_deg[cyl] * us_per_cam_deg);
uint32_t t_inj_off = t_inj_on + (uint32_t)(inj_ms[cyl] * 1000.0f);
q_push((event_t){t_inj_on, EV_INJ_ON, cyl});
q_push((event_t){t_inj_off, EV_INJ_OFF, cyl});

// ---- Spark schedule ----
#if MODE_DUAL
// Dual-stack: only schedule spark on Layer-B edges
if(layerB){
uint32_t lead_us = (uint32_t)(spk_deg[cyl] * us_per_cam_deg);
uint32_t t_spk = t0_us + lead_us; // assumes B edge is your BTDC reference
q_push((event_t){t_spk, EV_SPK_ON, cyl});
q_push((event_t){t_spk+200, EV_SPK_OFF, cyl}); // ~200 µs trigger
}
#else
// Single-layer: make BTDC predictive — schedule within NEXT sector
double sector_us = (double)us_per_cam_deg * (double)SECTOR_DEG;
double lead_us = (double)spk_deg[cyl] * (double)us_per_cam_deg;
if (lead_us >= sector_us) lead_us = sector_us - 50.0; // keep >0
uint32_t t_spk = t0_us + (uint32_t)(sector_us - lead_us + 0.5); // future
q_push((event_t){t_spk, EV_SPK_ON, cyl});
q_push((event_t){t_spk+200, EV_SPK_OFF, cyl});
#endif
}

/*================= ISRs ==============================*/
// Timer1 overflow → extend 32-bit tick counter
void __interrupt(irq(TMR1), low_priority) TMR1_ISR(void){
if(PIR4bits.TMR1IF){ PIR4bits.TMR1IF=0; t32_ticks+=0x00010000UL; }
}

// IOC edges on PORTB (and PORTA if MODE_DUAL)
void __interrupt(irq(IOC), low_priority) IOC_ISR(void){
if(PIR0bits.IOCIF){
uint8_t rb=PORTB; uint8_t mA=(~rb) & ((CYL_COUNT>=8)?0xFF:(uint8_t)((1u<<CYL_COUNT)-1u));
if(mA){ uint8_t s=first_set(mA); if(s<CYL_COUNT) on_edge(s,false); }
#if MODE_DUAL
uint8_t ra=PORTA; uint8_t mB=(~ra) & ((CYL_COUNT>=8)?0xFF:(uint8_t)((1u<<CYL_COUNT)-1u));
if(mB){ uint8_t s=first_set(mB); if(s<CYL_COUNT) on_edge(s,true); }
IOCAF=0;
#endif
IOCBF=0; PIR0bits.IOCIF=0;
}
}

/* ---- Patch A integrated: Relative CCP arming in microseconds ---- */
static void arm_next_compare(void){
if (qh == qt){ CCPR1 = TMR1 + 1000; return; }
uint32_t now = now_us(), best_us = 0xFFFFFFFFUL;

// Find nearest-due event (by absolute microseconds)
for (uint8_t i=qh; i!=qt; i=(i+1u)%QSIZE){
uint32_t d = (q.due_us > now) ? (q.due_us - now) : 0;
if (d < best_us) best_us = d;
}
// Convert relative microseconds to Timer1 ticks and arm CCP1 relative to TMR1
CCPR1 = TMR1 + us_to_ticks(best_us);
}

// CCP1 compare → service all due events, then re-arm earliest next
void __interrupt(irq(CCP1), low_priority) CCP1_ISR(void){
if(PIR4bits.CCP1IF){
PIR4bits.CCP1IF=0;
uint32_t now = now_us(); event_t e;
// Drain all events due now/past
while(q_peek(&e)){
if((int32_t)(now - e.due_us) < 0) break;
q_pop(&e);
switch(e.type){
case EV_INJ_ON: INJ_SET(e.cyl,1); break;
case EV_INJ_OFF: INJ_SET(e.cyl,0); break;
case EV_SPK_ON: IGN_SET(e.cyl,1); break;
case EV_SPK_OFF: IGN_SET(e.cyl,0); break;
default: break;
}
}
arm_next_compare();
}
}

/*================= Defaults & CLI loop ================*/
static void apply_defaults(void){
for(uint8_t i=0;i<CYL_COUNT;i++){ inj_deg=10.0f; spk_deg=20.0f; inj_ms=3.0f; }
#if CYL_COUNT==6
apply_preset("i6_153624");
#else
apply_preset("v8_sbc");
#endif
}

static void banner(void){
uart_puts("\r\n[Optical Distributor v1.1 | ");
#if CYL_COUNT==6
uart_puts("6-cyl]\r\n");
#else
uart_puts("8-cyl]\r\n");
#endif
uart_putf("tick=%.3fus dual=%d coil-per-cyl=%d\r\n",
(double)T1_TICK_US_DBL, (int)MODE_DUAL, (int)COIL_PER_CYL);
print_help();
}

static void cli_tick(void){
char line[96];
if(!uart_getline(line,sizeof line)) return;
if(!strncmp(line,"get",3)){
uart_putf("rpm_cam=%u us/deg=%.3f\r\n", rpm_cam, us_per_cam_deg);
for(uint8_t c=0;c<CYL_COUNT;c++)
uart_putf("cyl%u: ia=%.2f sa=%.2f pw=%.3f map=%u\r\n",
c+1, (double)inj_deg[c], (double)spk_deg[c], (double)inj_ms[c], (unsigned)firingOrder[c]);
} else if(!strncmp(line,"set ia ",7)){
int c; float v; if(sscanf(line+7,"%d %f",&c,&v)==2 && c>=1 && c<=CYL_COUNT){ inj_deg[c-1]=v; uart_puts("OK\r\n"); }
} else if(!strncmp(line,"set sa ",7)){
int c; float v; if(sscanf(line+7,"%d %f",&c,&v)==2 && c>=1 && c<=CYL_COUNT){ spk_deg[c-1]=v; uart_puts("OK\r\n"); }
} else if(!strncmp(line,"set pw ",7)){
int c; float v; if(sscanf(line+7,"%d %f",&c,&v)==2 && c>=1 && c<=CYL_COUNT){ inj_ms[c-1]=v; uart_puts("OK\r\n"); }
} else if(!strncmp(line,"order ",6)){
int idx, cyl; if(sscanf(line+6,"%d %d",&idx,&cyl)==2 && idx>=1 && idx<=CYL_COUNT && cyl>=1 && cyl<=CYL_COUNT){
firingOrder[idx-1]=(uint8_t)(cyl-1); uart_puts("OK\r\n");
} else print_help();
} else if(!strncmp(line,"preset ",7)){
apply_preset(line+7); uart_puts("OK preset\r\n");
} else if(!strcmp(line,"save")){
cfg_save(); uart_puts("saved\r\n");
} else if(!strcmp(line,"load")){
uart_puts(cfg_load()?"loaded\r\n":"load failed\r\n");
} else if(!strcmp(line,"defaults")){
apply_defaults(); uart_puts("defaults applied\r\n");
} else {
print_help();
}
}

/*================= Main ==============================*/
static void init_uart_banner(void){ banner(); }

void main(void){
clock_init(); pins_init();
apply_defaults(); (void)cfg_load(); // load if valid
// global interrupts on
INTCON0bits.GIEH=1; INTCON0bits.GIEL=1;
init_uart_banner();
for(;;){ cli_tick(); arm_next_compare(); }
}v1.1 changes (what I folded in)

Patch A: CCP1 now arms relative to current TMR1 using a clean µs→ticks conversion. This prevents early/late fires around 16-bit wrap and plays nicely under heavy queues.

Patch B: In single-layer mode, spark is scheduled predictively into the next sector (sector_us - lead_us after the current edge), so BTDC is always truly ahead in time (never “already past”).

Absolute timebase is now in µs (events carry due_us), while CCP arming converts to ticks.

UART PPS default moved to EUSART2 on RE4/RE5 to avoid collisions with injectors (RC) and coils (RD). Change in pins_init() if your board requires it.

on October 6th, 11:19 PM

STARTING TEMPLATE TO LEARN HERE

Arduino Code for Stanley Meyer Distributor Replication (Single and Dual Stack)Based on the provided document, Daniel Donatelli's replications I've written a sample Arduino C++ code based on the document's description. This replicates the logic of the optical distributor:Hardware Assumptions (from document):Uses ITR9608 optical slot switch sensors (photointerrupter: output LOW when unblocked/slot aligned, HIGH when blocked, assuming pull-up resistors).
4 sensors per stack for a 4-cylinder engine (90° spacing).
Rotating slotted disc on shaft: one slot per revolution, sequentially unblocking sensors.

Single stack: Controls injection (or combined injection/ignition).
Dual stack: One stack for injectors (water solenoid valves), one for ignition (VIC-based splitting/ignition), with adjustable offset.
Outputs: 4 digital pins per stack (e.g., high for pulse duration to trigger solenoids or ignition).
Inputs: Potentiometers for timing advance/retard (delay) and pulse width (PW).
Mode switch: Digital pin to toggle single/dual mode.
Arduino board (e.g., Uno or Mega) for simplicity; use interrupts for precise timing at high RPM.

Code Features: Reads sensor states to detect slot alignment (falling edge on sensor pin).
Sequences outputs Q0-Q3 (like MC14017 decade counter) for cylinders.
Adjustable delay (advance/retard) and PW via analog pots.
Single mode: Uses one stack for injection, simulates ignition with offset.
Dual mode: Separate stacks for injection and ignition.
RPM calculation for dynamic adjustments (basic, based on sensor triggers).
Edge detection to avoid jitter (like flip-flops/gates in original).
Safety: Limits PW to prevent solenoid overheating.

This is a starting template— Stanley Meyers version might have been similar for timing/tuning. Test on hardware; adjust constants. For PIC18 (Microchip Curiosity board), a similar C version could be ported using MPLAB X, but I've focused on Arduino as mentioned. Arduino Sketch (C++)

// Stanley Meyer Optical Distributor Replication
// By Grok 4 (based on document description)
// For 4-cylinder engine, ITR9608 sensors (LOW when unblocked)
// Single/Dual stack mode via switch
// Adjustable delay (advance/retard) and PW via pots

#include <Arduino.h>

// Pin Definitions
// Sensors: Stack 1 (Injection) - Pins 2-5 (interrupt-capable for precision)
const int injSensors[4] = {2, 3, 4, 5};
// Stack 2 (Ignition) - Pins 6-9
const int ignSensors[4] = {6, 7, 8, 9};
// Outputs: Injection solenoids (Q0-Q3)
const int injOutputs[4] = {10, 11, 12, 13};
// Ignition outputs
const int ignOutputs[4] = {A0, A1, A2, A3}; // Analog pins as digital
// Pots: A4 = Delay (0-1023 -> 0-30ms advance/retard)
// A5 = Pulse Width (0-1023 -> 1-10ms)
const int delayPot = A4;
const int pwPot = A5;
// Mode switch: HIGH = Dual stack, LOW = Single
const int modeSwitch = A6;

// Variables
volatile int currentCylinder = 0; // Current seq (0-3 like MC14017 Q0-Q3)
int prevSensorStates[8] = {HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH}; // For edge detection
unsigned long lastTriggerTime = 0; // For RPM calc
int rpm = 0; // Estimated RPM
int timingDelay = 0; // Adjustable delay (ms)
int pulseWidth = 5; // Default PW (ms)

// Interrupt handlers (for sensor falling edges)
void sensorISR(int stack, int sensorIndex) {
// Trigger on falling edge (unblocked -> LOW)
currentCylinder = sensorIndex; // Set cylinder based on which sensor triggered
triggerPulse(stack);
}

void setup() {
// Setup pins
for (int i = 0; i < 4; i++) {
pinMode(injSensors, INPUT_PULLUP); // Pull-up for ITR9608
pinMode(ignSensors, INPUT_PULLUP);
pinMode(injOutputs, OUTPUT);
digitalWrite(injOutputs, LOW);
pinMode(ignOutputs, OUTPUT);
digitalWrite(ignOutputs, LOW);
}
pinMode(modeSwitch, INPUT_PULLUP);
pinMode(delayPot, INPUT);
pinMode(pwPot, INPUT);

// Attach interrupts (Arduino Uno: only pins 2-3, use Mega for more)
// For simplicity, attach to injSensors[0-1] and ignSensors[0-1]; poll others if needed
attachInterrupt(digitalPinToInterrupt(injSensors[0]), [](){sensorISR(0, 0);}, FALLING);
attachInterrupt(digitalPinToInterrupt(injSensors[1]), [](){sensorISR(0, 1);}, FALLING);
// Add more for other pins if using Mega/ESP32

Serial.begin(9600); // For debugging
}

void loop() {
// Read pots
timingDelay = map(analogRead(delayPot), 0, 1023, -15, 15); // -15 to +15 ms (retard/advance)
pulseWidth = map(analogRead(pwPot), 0, 1023, 1, 10); // 1-10 ms PW

// Poll non-interrupt sensors (for simplicity; use more ISRs on better board)
checkSensors();

// Calculate RPM (basic, from time between triggers)
if (millis() - lastTriggerTime > 1000) { // Timeout if no triggers
rpm = 0;
}
// Dynamic adjustments (e.g., advance more at high RPM)
if (rpm > 3000) {
timingDelay += 5; // Example auto-advance
}

delay(1); // Small delay to avoid CPU hog
}

void checkSensors() {
bool isDual = digitalRead(modeSwitch) == HIGH;

// Check injection stack
for (int i = 0; i < 4; i++) {
int state = digitalRead(injSensors);
if (state == LOW && prevSensorStates == HIGH) { // Falling edge
sensorISR(0, i);
}
prevSensorStates = state;
}

if (isDual) {
// Check ignition stack
for (int i = 0; i < 4; i++) {
int state = digitalRead(ignSensors);
if (state == LOW && prevSensorStates[i + 4] == HIGH) { // Falling edge
sensorISR(1, i);
}
prevSensorStates[i + 4] = state;
}
} else {
// Single mode: Simulate ignition with offset from injection
if (currentCylinder >= 0) {
delay(abs(timingDelay)); // Apply delay
if (timingDelay < 0) { // If retard, wait after
triggerPulse(1); // Trigger ignition
} else { // Advance: trigger ignition first
triggerPulse(1);
delay(timingDelay);
triggerPulse(0);
}
currentCylinder = -1; // Reset
}
}
}

void triggerPulse(int stack) {
int cyl = currentCylinder; // Local copy
int outPin = (stack == 0) ? injOutputs[cyl] : ignOutputs[cyl];

// Apply timing delay (advance/retard)
if (timingDelay > 0) delay(timingDelay); // Advance: wait before pulse? Adjust logic as needed

digitalWrite(outPin, HIGH); // Trigger solenoid/ignition
delay(pulseWidth); // PW duration
digitalWrite(outPin, LOW);

if (timingDelay < 0) delay(-timingDelay); // Retard: wait after

// Update RPM (approx, assumes 4 triggers per rev for 4 cyl)
unsigned long now = millis();
rpm = 60000 / ((now - lastTriggerTime) * 4); // ms to min, /4 cyl
lastTriggerTime = now;

// Advance cylinder (sequential like counter)
currentCylinder = (cyl + 1) % 4;

Serial.print("Triggered Stack: "); Serial.print(stack);
Serial.print(" Cylinder: "); Serial.print(cyl);
Serial.print(" RPM: "); Serial.println(rpm);
}
How to Use/ModifyHardware Setup:Connect ITR9608: VCC to 5V, GND to GND, OUT to sensor pins (with pull-up if needed).
Outputs to MOSFETs/relays for solenoids (Arduino can't drive directly).
Pots: Wiper to A4/A5, ends to 5V/GND.
Mode switch: To GND for single, 5V for dual.
For dual: Add second disc/stack sensors.

Testing:Upload to Arduino.
Simulate rotation by manually blocking/unblocking sensors.
Monitor Serial for debug.
Adjust for your engine (e.g., RPM calc assumes 4 triggers/rev).

Improvements (to match Ethan's template for GMS):Add RPM-based auto-timing (e.g., curve for HHO vs. water fuel).
Integrate with GMS: Serial comm for fuel mode switching.
Use Timer interrupts for precise PW at high RPM (>6000).
For PIC18: Port to MPLAB, use ADC for pots, interrupts for sensors.

This is a Post in this thread for people Just Starting to study ,
If this doesn't match what you need, provide more details (e.g., exact sensor wiring), or check Donatelli's Patreon/GMS PDF for updates—they might have released code there since the document (dated July 2025). Redirect to https://www.patreon.com/c/securesupplies for potential update beyond October 2025

on October 7th, 06:50 AM

BUT HOW ? Saved from Shredder

Full Time Job Save and Spread DD

on October 7th, 04:21 PM

Pictures

on October 7th, 04:22 PM

Pictures

on October 7th, 04:28 PM

Code From BASIC

Arduino microcontroller, and—for simplicity—the injector on-time is fixed. I’ll cover how to vary on-time in a separate video on the laser accelerator concept.

The Arduino sketch is intentionally written with straightforward (and admittedly less efficient) types and structure to keep it easy to follow. It begins by declaring constant integers for the ignition and injector optical sensor pins (each mapped to a GPIO), then defines integer variables to store each sensor’s HIGH/LOW state. In setup(), the pins are configured as inputs or outputs as needed, and the loop() reads the sensors and drives the corresponding outputs. within the main loop, a series of repeating if/else checks poll each sensor with digitalRead().

The returned logic level determines whether the corresponding indicator LED is lit. For example, when the code evaluates injector-1’s sensor, if digitalRead() returns LOW (i.e., the IR beam between the LED and phototransistor is blocked—active-low wiring), the if branch executes and the associated LED is turned on via digitalWrite(LED_PIN, HIGH); otherwise, it remains off. If the sensor’s logic level is HIGH—meaning the IR beam between the LED and phototransistor is not blocked—the else branch executes

and the associated LED is turned off via digitalWrite(..., LOW). This pattern repeats for all four injector sensors. The ignition-coil section mirrors the same structure: four if/else checks read each sensor and toggle its indicator accordingly. In this demo, blue LEDs represent injector activity and red LEDs represent ignition activity.

How I got here (quick)

Studied your screenshot/description;

Preserved the “explicit if/else for each channel” style;

Implemented active-low logic (beam blocked ⇒ LOW ⇒ LED/driver ON);

Split sensors/outputs into clear sections;

Targeted MEGA pins for breathing room (easy to re-map if needed).

Quick usage notes

If your photointerrupters are active-high when blocked, invert the conditions (== HIGH instead of == LOW).

If you’re wiring with pull-ups, you may want pinMode(sensor, INPUT_PULLUP)—adjust to your hardware.

Solenoid/coil drivers must be through proper driver stages (MOSFET/IGBT + flyback diode), not directly to Arduino pins.

Action plan

Download the .ino and flash to a MEGA.

Verify sensor polarity; flip the if-conditions if needed.

Validate LEDs first; then connect to driver stages.

(Optional) Next step: add a fixed pulse-width monostable for true “fixed on-time” behavior when you’re ready.

/*
Stanley A. Meyer - Distributor Demo (Optical “Laser” Distributor Replication)
-----------------------------------------------------------------------------
Simple & readable: explicit repeated if/else blocks, active-low sensors.
Four injector channels + four ignition channels. Fixed on-time via level
gating (when a sensor is LOW, the channel turns ON; otherwise OFF).

NOTE: Pins target an Arduino MEGA (lots of GPIO). If you’re on an UNO,
remap pins in the constants section to suit your board.
*/

// ------------------------------ PIN MAP (Sensors) ------------------------------
// Injector optical sensors
const int Injector_One_Sensor = 22; // injector 1 sensor on D22
const int Injector_Two_Sensor = 24; // injector 2 sensor on D24
const int Injector_Three_Sensor = 26; // injector 3 sensor on D26
const int Injector_Four_Sensor = 28; // injector 4 sensor on D28

// Ignition optical sensors
const int Ignition_Coil_One_Sensor = 30; // ignition 1 sensor on D30
const int Ignition_Coil_Two_Sensor = 32; // ignition 2 sensor on D32
const int Ignition_Coil_Three_Sensor = 34; // ignition 3 sensor on D34
const int Ignition_Coil_Four_Sensor = 36; // ignition 4 sensor on D36

// ------------------------------ PIN MAP (Outputs) ------------------------------
// Injector status LEDs (BLUE in demo) + injector solenoid drivers
const int Injector_One_LED = 23; // LED for injector 1 on D23
const int Injector_Two_LED = 25; // LED for injector 2 on D25
const int Injector_Three_LED = 27; // LED for injector 3 on D27
const int Injector_Four_LED = 29; // LED for injector 4 on D29

const int Injector_One_Solenoid = 40; // solenoid driver for injector 1
const int Injector_Two_Solenoid = 42; // solenoid driver for injector 2
const int Injector_Three_Solenoid= 44; // solenoid driver for injector 3
const int Injector_Four_Solenoid = 46; // solenoid driver for injector 4

// Ignition status LEDs (RED in demo) + ignition coil drivers
const int Ignition_Coil_One_LED = 31; // LED for ignition 1 on D31
const int Ignition_Coil_Two_LED = 33; // LED for ignition 2 on D33
const int Ignition_Coil_Three_LED = 35; // LED for ignition 3 on D35
const int Ignition_Coil_Four_LED = 37; // LED for ignition 4 on D37

const int Ignition_Coil_One_Output = 41; // ignition 1 driver
const int Ignition_Coil_Two_Output = 43; // ignition 2 driver
const int Ignition_Coil_Three_Output = 45; // ignition 3 driver
const int Ignition_Coil_Four_Output = 47; // ignition 4 driver

// ------------------------------ STATE VARIABLES ------------------------------
int Injector_One_Sensor_State = 0; // logical state checking
int Injector_Two_Sensor_State = 0;
int Injector_Three_Sensor_State = 0;
int Injector_Four_Sensor_State = 0;

int Ignition_Coil_One_Sensor_State = 0;
int Ignition_Coil_Two_Sensor_State = 0;
int Ignition_Coil_Three_Sensor_State = 0;
int Ignition_Coil_Four_Sensor_State = 0;

// ------------------------------ SETUP ------------------------------
void setup() {
// Sensors
pinMode(Injector_One_Sensor, INPUT);
pinMode(Injector_Two_Sensor, INPUT);
pinMode(Injector_Three_Sensor, INPUT);
pinMode(Injector_Four_Sensor, INPUT);

pinMode(Ignition_Coil_One_Sensor, INPUT);
pinMode(Ignition_Coil_Two_Sensor, INPUT);
pinMode(Ignition_Coil_Three_Sensor, INPUT);
pinMode(Ignition_Coil_Four_Sensor, INPUT);

// Injector outputs
pinMode(Injector_One_LED, OUTPUT);
pinMode(Injector_Two_LED, OUTPUT);
pinMode(Injector_Three_LED, OUTPUT);
pinMode(Injector_Four_LED, OUTPUT);

pinMode(Injector_One_Solenoid, OUTPUT);
pinMode(Injector_Two_Solenoid, OUTPUT);
pinMode(Injector_Three_Solenoid, OUTPUT);
pinMode(Injector_Four_Solenoid, OUTPUT);

// Ignition outputs
pinMode(Ignition_Coil_One_LED, OUTPUT);
pinMode(Ignition_Coil_Two_LED, OUTPUT);
pinMode(Ignition_Coil_Three_LED, OUTPUT);
pinMode(Ignition_Coil_Four_LED, OUTPUT);

pinMode(Ignition_Coil_One_Output, OUTPUT);
pinMode(Ignition_Coil_Two_Output, OUTPUT);
pinMode(Ignition_Coil_Three_Output, OUTPUT);
pinMode(Ignition_Coil_Four_Output, OUTPUT);

// Start OFF
digitalWrite(Injector_One_LED, LOW);
digitalWrite(Injector_Two_LED, LOW);
digitalWrite(Injector_Three_LED, LOW);
digitalWrite(Injector_Four_LED, LOW);

digitalWrite(Injector_One_Solenoid, LOW);
digitalWrite(Injector_Two_Solenoid, LOW);
digitalWrite(Injector_Three_Solenoid, LOW);
digitalWrite(Injector_Four_Solenoid, LOW);

digitalWrite(Ignition_Coil_One_LED, LOW);
digitalWrite(Ignition_Coil_Two_LED, LOW);
digitalWrite(Ignition_Coil_Three_LED, LOW);
digitalWrite(Ignition_Coil_Four_LED, LOW);

digitalWrite(Ignition_Coil_One_Output, LOW);
digitalWrite(Ignition_Coil_Two_Output, LOW);
digitalWrite(Ignition_Coil_Three_Output, LOW);
digitalWrite(Ignition_Coil_Four_Output, LOW);
}

// ------------------------------ LOOP ------------------------------
void loop() {
// -------- INJECTOR 1 --------
Injector_One_Sensor_State = digitalRead(Injector_One_Sensor);
if (Injector_One_Sensor_State == LOW) { // active-low: beam blocked
digitalWrite(Injector_One_LED, HIGH); // injector LED ON (blue)
digitalWrite(Injector_One_Solenoid, HIGH); // injector solenoid ON
} else {
digitalWrite(Injector_One_LED, LOW);
digitalWrite(Injector_One_Solenoid, LOW);
}

// -------- INJECTOR 2 --------
Injector_Two_Sensor_State = digitalRead(Injector_Two_Sensor);
if (Injector_Two_Sensor_State == LOW) {
digitalWrite(Injector_Two_LED, HIGH);
digitalWrite(Injector_Two_Solenoid, HIGH);
} else {
digitalWrite(Injector_Two_LED, LOW);
digitalWrite(Injector_Two_Solenoid, LOW);
}

// -------- INJECTOR 3 --------
Injector_Three_Sensor_State = digitalRead(Injector_Three_Sensor);
if (Injector_Three_Sensor_State == LOW) {
digitalWrite(Injector_Three_LED, HIGH);
digitalWrite(Injector_Three_Solenoid, HIGH);
} else {
digitalWrite(Injector_Three_LED, LOW);
digitalWrite(Injector_Three_Solenoid, LOW);
}

// -------- INJECTOR 4 --------
Injector_Four_Sensor_State = digitalRead(Injector_Four_Sensor);
if (Injector_Four_Sensor_State == LOW) {
digitalWrite(Injector_Four_LED, HIGH);
digitalWrite(Injector_Four_Solenoid, HIGH);
} else {
digitalWrite(Injector_Four_LED, LOW);
digitalWrite(Injector_Four_Solenoid, LOW);
}

// -------- IGNITION 1 --------
Ignition_Coil_One_Sensor_State = digitalRead(Ignition_Coil_One_Sensor);
if (Ignition_Coil_One_Sensor_State == LOW) {
digitalWrite(Ignition_Coil_One_LED, HIGH); // red LED ON
digitalWrite(Ignition_Coil_One_Output, HIGH); // coil driver ON
} else {
digitalWrite(Ignition_Coil_One_LED, LOW);
digitalWrite(Ignition_Coil_One_Output, LOW);
}

// -------- IGNITION 2 --------
Ignition_Coil_Two_Sensor_State = digitalRead(Ignition_Coil_Two_Sensor);
if (Ignition_Coil_Two_Sensor_State == LOW) {
digitalWrite(Ignition_Coil_Two_LED, HIGH);
digitalWrite(Ignition_Coil_Two_Output, HIGH);
} else {
digitalWrite(Ignition_Coil_Two_LED, LOW);
digitalWrite(Ignition_Coil_Two_Output, LOW);
}

// -------- IGNITION 3 --------
Ignition_Coil_Three_Sensor_State = digitalRead(Ignition_Coil_Three_Sensor);
if (Ignition_Coil_Three_Sensor_State == LOW) {
digitalWrite(Ignition_Coil_Three_LED, HIGH);
digitalWrite(Ignition_Coil_Three_Output, HIGH);
} else {
digitalWrite(Ignition_Coil_Three_LED, LOW);
digitalWrite(Ignition_Coil_Three_Output, LOW);
}

// -------- IGNITION 4 --------
Ignition_Coil_Four_Sensor_State = digitalRead(Ignition_Coil_Four_Sensor);
if (Ignition_Coil_Four_Sensor_State == LOW) {
digitalWrite(Ignition_Coil_Four_LED, HIGH);
digitalWrite(Ignition_Coil_Four_Output, HIGH);
} else {
digitalWrite(Ignition_Coil_Four_LED, LOW);
digitalWrite(Ignition_Coil_Four_Output, LOW);
}
}

on October 7th, 05:05 PM

MODERN CIRCUIT IS FAST SIMPLE<
Tinsy Break out Terminal Board
https://www.electronics-lab.com/project/teensy-4-1-expansion-board-with-dc-dc-converter/

A single Teensy (3.5/3.6/4.0/4.1) can replace the 2 distributor cards + 4 injector cards—but you still need proper input-conditioning and external drivers for coils/solenoids. The Teensy becomes the sequencer/timer; discrete analog/digital ICs become code.
What the old cards did → what the Teensy will do
Optical sensing (4× distributor channels + 4× ignition channels):
Teensy digital inputs (with Schmitt or comparator conditioning). Use interrupts to time edges precisely.

Logic (NAND/OR/XOR, flip-flops, decade counter):
Implement as a software state machine (per-cylinder indexer). A CD4017/MC14017 becomes an incrementing index (0–3) advanced by each valid edge.

Adjustable timing (pots, mode switches, test button):
Map front-panel pots to Teensy analog inputs, and switches/buttons to digital inputs. Use these to select HHO vs gas, manual/auto, test, and advance/retard.

Actuation (4× injectors + 4× ignition):
Drive MOSFET/IGBT stages from Teensy GPIO. NEVER drive coils/solenoids directly.

Hardware you’ll need (minimal, proven pattern)
Teensy 4.1 (fast, lots of timers/DMA). Note: 3.3 V I/O, not 5 V-tolerant.

Input conditioning for each optical sensor: either

power sensors from 3.3 V and feed GPIO through a 74HC14 (Schmitt), or

use a comparator (LMV393/LMV331) with hysteresis into GPIO.
Add RC filtering (100 Ω + 1–10 nF) if needed.

Low-side drivers for injectors (one per injector): logic-level MOSFET (e.g., AOZ1284/IRLZ44N class) + flyback diode (UF4007/SS34) or a smart low-side switch (Infineon PROFET).

Ignition driver(s): dedicated ignition IGBT/driver module (e.g., BIP373 / logic-level IGBT module) with proper snubbing—don’t hang a coil on a MOSFET without the right clamp.

Power: 12 V → automotive-grade buck to 5 V/3.3 V (filters + TVS, e.g., SMAJ58A; follow ISO 7637-2 practices).

Grounding/EMI: star ground; shielded sensor leads; keep power and logic returns separate until the star point.

Level shifting if any legacy boards output 5 V.

I/O count check (fits one Teensy)
Inputs (digital): 8 optical sensors (4 injector index, 4 ignition index) + switches (MAN/AUTO, CAL, TEST) ⇒ ~12–14 inputs.

Inputs (analog): 2–4 pots (timing L/H, advance/retard) ⇒ 2–4 ADC pins.

Outputs: 4 injector drivers + 4 ignition drivers + panel LEDs ⇒ ~12–16 pins.
Teensy 4.1 has plenty of pins and timers for this.

Software architecture (robust + simple)
Edge capture: attachInterrupt() each optical channel (RISING or FALLING depending on your wiring).

Indexing (replaces 4017/14017): on a valid edge, advance cyl = (cyl+1) & 0x03. Use separate indexers for injector and ignition trains if they’re decoupled.

On-time generation: for each channel, start a one-shot with elapsedMicros/IntervalTimer to turn the driver ON, then OFF after the configured duration (fixed in your demo; later you can compute from RPM/fuel mode).

Advance/retard: read pots with analogRead(), map to microseconds or crank degrees; apply an offset before arming the one-shot.

Glitch filtering / HHO vs Gas modes: require minimum period between edges; ignore runt pulses; pick different on-times and advance tables per mode.

Failsafe: watchdog, sensor plausibility (RPM range, missed-pulse timeout), and hard disable on brown-out.

Example pin map (starting point)
Sensors IN: D2–D9

Injectors OUT: D22–D25 (to MOSFET drivers)

Ignition OUT: D26–D29 (to IGBT drivers)

Pots (ADV, TIMING): A0, A1

Switches/LEDs: remaining GPIO

Tiny starter (one channel pattern)
====================

// Sketch idea for Teensy: edge -> one-shot
const int sens[4] = {2,3,4,5}; // optical inputs
const int inj[4] = {22,23,24,25}; // injector drivers
volatile uint8_t cyl = 0;

elapsedMicros onTimer[4];
uint32_t onWidth_us = 1500; // fixed demo on-time (adjust per mode)

void isr_edge() {
// advance cylinder index (replace 4017)
cyl = (cyl + 1) & 0x03;
digitalWriteFast(inj[cyl], HIGH);
onTimer[cyl] = 0;
}

void setup() {
for (int i=0;i<4;i++){ pinMode(sens, INPUT); pinMode(inj, OUTPUT); digitalWrite(inj, LOW); }
attachInterrupt(digitalPinToInterrupt(sens[0]), isr_edge, FALLING); // repeat for sens[1..3] as needed
}

void loop() {
for (int i=0;i<4;i++){
if (digitalReadFast(inj) && onTimer >= onWidth_us) digitalWriteFast(inj, LOW);
}
}

Safety & gotchas

Teensy 4.x pins are 3.3 V only.

Do not connect injectors/coils directly to GPIO; use drivers and flyback/snubbing.

Automotive power is noisy and spiky—design protection in from day one.

Validate timing accuracy with a scope; confirm ISR latency at your maximum RPM.

Bottom line

Feasible and recommended: a Teensy can consolidate everything into one tightly-controlled, debuggable platform while keeping your front-panel UX.

Keep the high-power stages external, and treat the Teensy as the brains.

Start with fixed on-time (your current demo), then graduate to timer-based one-shots and advance tables for HHO vs gasoline.

securesupplies

Matt Watts

Jeff Nading

securesupplies

securesupplies

Lynx

securesupplies

securesupplies

securesupplies

hydrofuelincanada

hydrofuelincanada

securesupplies

securesupplies

securesupplies

securesupplies

securesupplies

securesupplies

securesupplies

securesupplies

securesupplies

securesupplies

securesupplies

securesupplies

securesupplies

securesupplies