Place braces on expressionless loops in utils.

[freeems-vanilla.git] / src / init.c

/* FreeEMS - the open source engine management system
 *
 * Copyright 2008 Fred Cooke
 *
 * This file is part of the FreeEMS project.
 *
 * FreeEMS software is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * FreeEMS software is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with any FreeEMS software.  If not, see http://www.gnu.org/licenses/
 *
 * We ask that if you make any changes to this file you email them upstream to
 * us at admin(at)diyefi(dot)org or, even better, fork the code on github.com!
 *
 * Thank you for choosing FreeEMS to run your engine!
 */


/**     @file init.c
 *
 * @brief Initialise the devices state
 *
 * Setup, configure and initialise all aspects of the devices state including
 * but not limited to:
 *
 * - Setup the bus clock speed
 * - Configuration based variable initialisation
 * - I/O register behaviour and initial state
 * - Configure and enable interrupts
 * - Copy tunable data up to RAM from flash
 * - Configure peripheral module behaviour
 *
 * @author Fred Cooke
 */


#define INIT_C
#include "inc/freeEMS.h"
#include "inc/interrupts.h"
#include "inc/utils.h"
#include "inc/commsISRs.h"
#include "inc/pagedLocationBuffers.h"
#include "inc/init.h"
#include <string.h>


/** @brief The main top level init
 *
 * The main init function to be called from main.c before entering the main
 * loop. This function is simply a delegator to the finer grained special
 * purpose init functions.
 *
 * @author Fred Cooke
 */
void init(){
        ATOMIC_START();                 /* Disable ALL interrupts while we configure the board ready for use */
        initPLL();                      /* Set up the PLL and use it */
        initIO();                       /* TODO make this config dependent. Set up all the pins and modules to be in low power harmless states */
        initAllPagedRAM();              /* Copy table and config blocks of data from flash to the paged ram blocks for fast data lookup */
        initAllPagedAddresses();        /* Save the paged memory addresses to variables such that we can access them from another paged block with no warnings */
        initVariables();                /* Initialise the rest of the running variables etc */
        initFlash();                    /* TODO, finalise this */
        initECTTimer();                 /* TODO move this to inside config in an organised way. Set up the timer module and its various aspects */
        initPITTimer();                 /* TODO ditto... */
        initSCIStuff();                 /* Setup the sci module(s) that we will use. */
        initConfiguration();            /* TODO Set user/feature/config up here! */
        initInterrupts();               /* still last, reset timers, enable interrupts here TODO move this to inside config in an organised way. Set up the rest of the individual interrupts */
        ATOMIC_END();                   /* Re-enable any configured interrupts */
}


/* used to chop out all the init stuff at compile time for hardware testing. */
//#define NO_INIT


/** @brief Set the PLL clock frequency
 *
 * Set the Phase Locked Loop to our desired frequency (80MHz) and switch to
 * using it for clock (40MHz bus speed).
 *
 * @author Fred Cooke
 */
void initPLL(){
        CLKSEL &= PLLSELOFF;    /* Switches to base external OSCCLK to ensure PLL is not being used (off out of reset, but not sure if the monitor turns it on before passing control or not) */
        PLLCTL &= PLLOFF;               /* Turn the PLL device off to adjust its speed (on by default out of reset) */
        REFDV = PLLDIVISOR;             /* 16MHz / (3 + 1) = 4MHz Bus frequency */
        SYNR = PLLMULTIPLIER;   /* 4MHz * (9 + 1) = 40MHz Bus frequency */
        PLLCTL |= PLLON;                /* Turn the PLL device back on again at 80MHz */

        while (!(CRGFLG & PLLLOCK)){
                /* Do nothing while we wait till the PLL loop locks onto the target frequency. */
                /* Target frequency is given by (2 * (crystal frequency / (REFDV + 1)) * (SYNR + 1)) */
                /* Bus frequency is half PLL frequency and given by ((crystal frequency / (REFDV + 1)) * (SYNR + 1)) */
        }

        CLKSEL = PLLSELON;              /* Switches to PLL clock for internal bus frequency     */
        /* from MC9S12XDP512V2.pdf Section 2.4.1.1.2 page 101 Third paragraph           */
        /* "This takes a MAXIMUM of 4 OSCCLK clock cylces PLUS 4 PLL clock cycles"      */
        /* "During this time ALL clocks freeze, and CPU activity ceases"                        */
        /* Therefore there is no point waiting for this to occur, we already are...     */
}


/* Configure all the I/O to default values to keep power use down etc */
void initIO(){
        /* for now, hard code all stuff to be outputs as per Freescale documentation,   */
        /* later what to do will be pulled from flash configuration such that all               */
        /* things are setup at once, and not messed with thereafter. when the port              */
        /* something uses is changed via the tuning interface, the confuration will be  */
        /* done on the fly, and the value burned to flash such that next boot happens   */
        /* correctly and current running devices are used in that way.                                  */

        /* Turn off and on and configure all the modules in an explicit way */
        // TODO set up and turn off all modules (CAN,SCI,SPI,IIC,etc)

        /* Turn off the digital input buffers on the ATD channels */
        ATD0DIEN = ZEROS; /* You are out of your mind if you waste this on digital Inputs */
        ATD1DIEN0 = ZEROS; /* You are out of your mind if you waste this on digital Inputs (NOT-bonded, can't use) */
        ATD1DIEN1 = ZEROS; /* You are out of your mind if you waste this on digital Inputs */
        /* TODO Second half of ATD1 - can we disable this somehow */

        /* And configure them all for analog input */
        ATD0CTL2 = 0x80; /* Turns on the ADC block. */
        ATD0CTL3 = 0x40; /* Set sequence length = 8 */
        ATD0CTL5 = 0xB0; /* Sets justification to right, multiplex and scan all channels. */
        // TODO find out if this is the default (i suspect it is)
        // TODO look into sampling techniques

        /* And configure them all for analog input */
        ATD1CTL0 = 0x07; /* Sets wrap on 8th ADC because we can't use the other 8 */
        ATD1CTL2 = 0x80; /* Turns on the ADC block. */
        ATD1CTL3 = 0x40; /* Set sequence length = 8 */
        ATD1CTL5 = 0xB0; /* Sets justification to right, multiplex and scan all channels. */
        // TODO find out if this is the default (i suspect it is)
        // TODO look into sampling techniques

#ifndef NO_INIT
        /* Set up the PWM component and initialise its values to off */
        PWME = 0x7F; /* Turn on PWM 0 - 6 (7 is user LED on main board) */
        PWMCLK = ZEROS; /* The fastest we can go for all channels */
        PWMPRCLK = ZEROS; /* The fastest prescaler we can go for all channels */
        PWMSCLA = ZEROS; /* The fastest we can go */
        PWMSCLB = ZEROS; /* The fastest we can go */
        /* TODO PWM channel concatenation for high resolution */
        // join channel pairs together here (needs 16 bit regs enabled too)
        /* TODO Initialise pwm channels with frequency, and initial duty for real use */
        // initial PWM settings for testing
        /* PWM periods */
        PWMPER0 = 0xFF; // 255 for ADC0 testing
        PWMPER1 = 0xFF; // 255 for ADC1 testing
        PWMPER2 = 0xFF; // 255 for ADC1 testing
        PWMPER3 = 0xFF; // 255 for ADC1 testing
        PWMPER4 = 0xFF; // 255 for ADC1 testing
        PWMPER5 = 0xFF; // 255 for ADC1 testing
        PWMPER6 = 0xFF; // 255 for ADC1 testing
        PWMPER7 = 0xFF; // 255 for ADC1 testing
        /* PWM duties */
        PWMDTY0 = 0;
        PWMDTY1 = 0;
        PWMDTY2 = 0;
        PWMDTY3 = 0;
        PWMDTY4 = 0;
        PWMDTY5 = 0;
        PWMDTY6 = 0;
        PWMDTY7 = 0;


        /* Initialise the state of pins configured as output */
        /* Initialise to low such that transistor grounded things are all turned off by default. */
        PORTA = ZEROS; /* The serial monitor pin is on 0x40, and could cause problems if capacitance at the output is large when a reset occurs. */
        PORTB = ZEROS; /* Init the rest of the spark outputs as off */
        PORTE = 0x1F; /* 0b_0001_1111 : when not in use 0b_1001_1111 PE7 should be high PE5 and PE6 should be low, the rest high */
        PORTK = ZEROS;
        PORTS = ZEROS;
        PORTT = ZEROS; /* All pins in off state at boot up (only matters for 2 - 7) */
        PORTM = ZEROS;
        PORTP = ZEROS; // TODO hook these up to the adc channels such that you can vary the brightness of an led with a pot.
        PORTH = ZEROS;
        PORTJ = ZEROS;
        /* AD0PT1 You are out of your mind if you waste this on digital Inputs */
        /* AD1PT1 You are out of your mind if you waste this on digital Inputs */

        /* Initialise the Data Direction Registers */
        /* To outputs based on the note at the end of chapter 1.2.2 of MC9S12XDP512V2.pdf */
        DDRA = ONES; /* GPIO (8) */
        DDRB = ONES; /* GPIO (8) */
        DDRE = 0xFC; /* 0b_1111_1100 : Clock and mode pins PE0,PE1 are input only pins, the rest are GPIO */
        DDRK = ONES; /* Only 0,1,2,3,4,5,7, NOT 6 (7) */
        DDRS = ONES; /* SCI0, SCI1, SPI0 (8) */
        DDRT = 0xFC; /* 0b_1111_1100 set ECT pins 0,1 to IC and 2:7 to OC (8) */
        DDRM = ONES; /* CAN 0 - 3 (8) */
        DDRP = ONES; /* PWM pins (8) */
        DDRH = ZEROS; /* All pins configured as input for misc isrs (SPI1, SPI2) (8) */
        DDRJ = ONES; /* Only 0,1,6,7 are brought out on the 112 pin chip (4) */
        /* Configure the non bonded pins to output to avoid current drain (112 pin package) */
        DDRC = ONES; /* NON-bonded external data bus pins */
        DDRD = ONES; /* NON-bonded external data bus pins */
        /* AD0DDR1 You are out of your mind if you waste this on digital Inputs */
        /* AD1DDR1 You are out of your mind if you waste this on digital Inputs */
#endif
}


/** @brief Buffer lookup tables addresses
 *
 * Save pointers to the lookup tables which live in paged flash.
 *
 * @note Many thanks to Jean Bélanger for the inspiration/idea to do this!
 *
 * @author Fred Cooke
 */
void initLookupAddresses(){
        IATTransferTableLocation = (void*)&IATTransferTable;
        CHTTransferTableLocation = (void*)&CHTTransferTable;
        MAFTransferTableLocation = (void*)&MAFTransferTable;
        TestTransferTableLocation = (void*)&TestTransferTable;
}


/** @brief Buffer fuel tables addresses
 *
 * Save pointers to the fuel tables which live in paged flash.
 *
 * @note Many thanks to Jean Bélanger for the inspiration/idea to do this!
 *
 * @author Fred Cooke
 */
void initFuelAddresses(){
        /* Setup addresses within the page to avoid warnings */
        VETableMainFlashLocation                = (void*)&VETableMainFlash;
        VETableSecondaryFlashLocation   = (void*)&VETableSecondaryFlash;
        VETableTertiaryFlashLocation    = (void*)&VETableTertiaryFlash;
        LambdaTableFlashLocation                = (void*)&LambdaTableFlash;
        VETableMainFlash2Location               = (void*)&VETableMainFlash2;
        VETableSecondaryFlash2Location  = (void*)&VETableSecondaryFlash2;
        VETableTertiaryFlash2Location   = (void*)&VETableTertiaryFlash2;
        LambdaTableFlash2Location               = (void*)&LambdaTableFlash2;
}


/** @brief Copy fuel tables to RAM
 *
 * Initialises the fuel tables in RAM by copying them up from flash.
 *
 * @author Fred Cooke
 */
void initPagedRAMFuel(void){
        /* Copy the tables from flash to RAM */
        RPAGE = RPAGE_FUEL_ONE;
        memcpy((void*)&TablesA, VETableMainFlashLocation,               MAINTABLE_SIZE);
        memcpy((void*)&TablesB, (void*)&VETableSecondaryFlash,  MAINTABLE_SIZE);
        memcpy((void*)&TablesC, (void*)&VETableTertiaryFlash,   MAINTABLE_SIZE);
        memcpy((void*)&TablesD, (void*)&LambdaTableFlash,               MAINTABLE_SIZE);
        RPAGE = RPAGE_FUEL_TWO;
        memcpy((void*)&TablesA, (void*)&VETableMainFlash2,              MAINTABLE_SIZE);
        memcpy((void*)&TablesB, (void*)&VETableSecondaryFlash2, MAINTABLE_SIZE);
        memcpy((void*)&TablesC, (void*)&VETableTertiaryFlash2,  MAINTABLE_SIZE);
        memcpy((void*)&TablesD, (void*)&LambdaTableFlash2,              MAINTABLE_SIZE);
}


/** @brief Buffer timing tables addresses
 *
 * Save pointers to the timing tables which live in paged flash.
 *
 * @note Many thanks to Jean Bélanger for the inspiration/idea to do this!
 *
 * @author Fred Cooke
 */
void initTimingAddresses(){
        /* Setup addresses within the page to avoid warnings */
        IgnitionAdvanceTableMainFlashLocation                   = (void*)&IgnitionAdvanceTableMainFlash;
        IgnitionAdvanceTableSecondaryFlashLocation              = (void*)&IgnitionAdvanceTableSecondaryFlash;
        InjectionAdvanceTableMainFlashLocation                  = (void*)&InjectionAdvanceTableMainFlash;
        InjectionAdvanceTableSecondaryFlashLocation             = (void*)&InjectionAdvanceTableSecondaryFlash;
        IgnitionAdvanceTableMainFlash2Location                  = (void*)&IgnitionAdvanceTableMainFlash2;
        IgnitionAdvanceTableSecondaryFlash2Location             = (void*)&IgnitionAdvanceTableSecondaryFlash2;
        InjectionAdvanceTableMainFlash2Location                 = (void*)&InjectionAdvanceTableMainFlash2;
        InjectionAdvanceTableSecondaryFlash2Location    = (void*)&InjectionAdvanceTableSecondaryFlash2;
}


/** @brief Copy timing tables to RAM
 *
 * Initialises the timing tables in RAM by copying them up from flash.
 *
 * @author Fred Cooke
 */
void initPagedRAMTime(){
        /* Copy the tables from flash to RAM */
        RPAGE = RPAGE_TIME_ONE;
        memcpy((void*)&TablesA, IgnitionAdvanceTableMainFlashLocation,                  MAINTABLE_SIZE);
        memcpy((void*)&TablesB, IgnitionAdvanceTableSecondaryFlashLocation,             MAINTABLE_SIZE);
        memcpy((void*)&TablesC, InjectionAdvanceTableMainFlashLocation,                 MAINTABLE_SIZE);
        memcpy((void*)&TablesD, InjectionAdvanceTableSecondaryFlashLocation,    MAINTABLE_SIZE);
        RPAGE = RPAGE_TIME_TWO;
        memcpy((void*)&TablesA, IgnitionAdvanceTableMainFlash2Location,                 MAINTABLE_SIZE);
        memcpy((void*)&TablesB, IgnitionAdvanceTableSecondaryFlash2Location,    MAINTABLE_SIZE);
        memcpy((void*)&TablesC, InjectionAdvanceTableMainFlash2Location,                MAINTABLE_SIZE);
        memcpy((void*)&TablesD, InjectionAdvanceTableSecondaryFlash2Location,   MAINTABLE_SIZE);
}


/** @brief Buffer tunable tables addresses
 *
 * Save pointers to the tunable tables which live in paged flash and their
 * sub-sections too.
 *
 * @note Many thanks to Jean Bélanger for the inspiration/idea to do this!
 *
 * @author Fred Cooke
 */
void initTunableAddresses(){
        /* Setup addresses within the page to avoid warnings */
        SmallTablesAFlashLocation       = (void*)&SmallTablesAFlash;
        SmallTablesBFlashLocation       = (void*)&SmallTablesBFlash;
        SmallTablesCFlashLocation       = (void*)&SmallTablesCFlash;
        SmallTablesDFlashLocation       = (void*)&SmallTablesDFlash;
        SmallTablesAFlash2Location      = (void*)&SmallTablesAFlash2;
        SmallTablesBFlash2Location      = (void*)&SmallTablesBFlash2;
        SmallTablesCFlash2Location      = (void*)&SmallTablesCFlash2;
        SmallTablesDFlash2Location      = (void*)&SmallTablesDFlash2;

        /* TablesA */
        dwellDesiredVersusVoltageTableLocation    = (void*)&SmallTablesAFlash.dwellDesiredVersusVoltageTable;
        dwellDesiredVersusVoltageTable2Location   = (void*)&SmallTablesAFlash2.dwellDesiredVersusVoltageTable;
        injectorDeadTimeTableLocation             = (void*)&SmallTablesAFlash.injectorDeadTimeTable;
        injectorDeadTimeTable2Location            = (void*)&SmallTablesAFlash2.injectorDeadTimeTable;
        postStartEnrichmentTableLocation          = (void*)&SmallTablesAFlash.postStartEnrichmentTable;
        postStartEnrichmentTable2Location         = (void*)&SmallTablesAFlash2.postStartEnrichmentTable;
        engineTempEnrichmentTableFixedLocation    = (void*)&SmallTablesAFlash.engineTempEnrichmentTableFixed;
        engineTempEnrichmentTableFixed2Location   = (void*)&SmallTablesAFlash2.engineTempEnrichmentTableFixed;
        primingVolumeTableLocation                = (void*)&SmallTablesAFlash.primingVolumeTable;
        primingVolumeTable2Location               = (void*)&SmallTablesAFlash2.primingVolumeTable;
        engineTempEnrichmentTablePercentLocation  = (void*)&SmallTablesAFlash.engineTempEnrichmentTablePercent;
        engineTempEnrichmentTablePercent2Location = (void*)&SmallTablesAFlash2.engineTempEnrichmentTablePercent;
        dwellMaxVersusRPMTableLocation            = (void*)&SmallTablesAFlash.dwellMaxVersusRPMTable;
        dwellMaxVersusRPMTable2Location           = (void*)&SmallTablesAFlash2.dwellMaxVersusRPMTable;

        /* TablesB */
        perCylinderFuelTrimsLocation  = (void*)&SmallTablesBFlash.perCylinderFuelTrims;
        perCylinderFuelTrims2Location = (void*)&SmallTablesBFlash2.perCylinderFuelTrims;

        /* TablesC */
        // TODO

        /* TablesD */
        // TODO

        /* filler defs */
        fillerALocation  = (void*)&SmallTablesAFlash.filler;
        fillerA2Location = (void*)&SmallTablesAFlash2.filler;
        fillerBLocation  = (void*)&SmallTablesBFlash.filler;
        fillerB2Location = (void*)&SmallTablesBFlash2.filler;
        fillerCLocation  = (void*)&SmallTablesCFlash.filler;
        fillerC2Location = (void*)&SmallTablesCFlash2.filler;
        fillerDLocation  = (void*)&SmallTablesDFlash.filler;
        fillerD2Location = (void*)&SmallTablesDFlash2.filler;
}


/**
 *
 */
void initPagedRAMTune(){
        /* Copy the tables from flash to RAM */
        RPAGE = RPAGE_TUNE_ONE;
        memcpy((void*)&TablesA, SmallTablesAFlashLocation,      MAINTABLE_SIZE);
        memcpy((void*)&TablesB, SmallTablesBFlashLocation,      MAINTABLE_SIZE);
        memcpy((void*)&TablesC, SmallTablesCFlashLocation,      MAINTABLE_SIZE);
        memcpy((void*)&TablesD, SmallTablesDFlashLocation,      MAINTABLE_SIZE);
        RPAGE = RPAGE_TUNE_TWO;
        memcpy((void*)&TablesA, SmallTablesAFlash2Location,     MAINTABLE_SIZE);
        memcpy((void*)&TablesB, SmallTablesBFlash2Location,     MAINTABLE_SIZE);
        memcpy((void*)&TablesC, SmallTablesCFlash2Location,     MAINTABLE_SIZE);
        memcpy((void*)&TablesD, SmallTablesDFlash2Location,     MAINTABLE_SIZE);
}


/** @brief Buffer addresses of paged data
 *
 * If you try to access paged data from the wrong place you get nasty warnings.
 * These calls to functions that live in the same page that they are addressing
 * prevent those warnings.
 *
 * @note Many thanks to Jean Bélanger for the inspiration/idea to do this!
 *
 * @author Fred Cooke
 */
void initAllPagedAddresses(){
        /* Setup pointers to lookup tables */
        initLookupAddresses();
        /* Setup pointers to the main tables */
        initFuelAddresses();
        initTimingAddresses();
        initTunableAddresses();
}


/** @brief Copies paged flash to RAM
 *
 * Take the tables and config from flash up to RAM to allow live tuning.
 *
 * For the main tables and other paged config we need to adjust
 * the RPAGE value to the appropriate one before copying up.
 *
 * This function is simply a delegator to the ones for each flash page. Each
 * one lives in the same paged space as the data it is copying up.
 *
 * @author Fred Cooke
 */
void initAllPagedRAM(){
        /* Copy the tables up to their paged ram blocks through the window from flash */
        initPagedRAMFuel();
        initPagedRAMTime();
        initPagedRAMTune();

        /* Default to page one for now, perhaps read the configured port straight out of reset in future? TODO */
        setupPagedRAM(TRUE); // probably something like (PORTA & TableSwitchingMask)
}


        /* Init all pointers to tunable items with direct addresses */
        /* Pointers remain the same when switching pages so are initialised only once */
//      VETableMain = &TablesA.VETableMain;
//      VETableSecondary = &TablesB.VETableSecondary;
//      VETableTertiary = &TablesC.VETableMainTertiary;
//      LambdaTable = &TablesD.LambdaTable;
//
//      IgnitionAdvanceTableMain = &TablesA.IgnitionAdvanceTableMain;
//      IgnitionAdvanceTableSecondary = &TablesB.IgnitionAdvanceTableSecondary;
//      InjectionAdvanceTableMain = &TablesC.InjectionAdvanceTableMain;
//      InjectionAdvanceTableSecondary = &TablesD.InjectionAdvanceTableSecondary;
//
//      dwellDesiredVersusVoltageTable = &TablesA.SmallTablesA.dwellDesiredVersusVoltageTable;
//      injectorDeadTimeTable = &TablesA.SmallTablesA.injectorDeadTimeTable;
//      postStartEnrichmentTable = &TablesA.SmallTablesA.postStartEnrichmentTable;
//      engineTempEnrichmentTableFixed = &TablesA.SmallTablesA.engineTempEnrichmentTableFixed;
//      primingVolumeTable = &TablesA.SmallTablesA.primingVolumeTable;
//      engineTempEnrichmentTablePercent = &TablesA.SmallTablesA.engineTempEnrichmentTablePercent;
//      dwellMaxVersusRPMTable = &TablesA.SmallTablesA.dwellMaxVersusRPMTable;
//
//      perCylinderFuelTrims = TablesB.SmallTablesB.perCylinderFuelTrims;


/* Initialise and set up all running variables that require a non-zero start value here */
/* All other variables are initialised to zero by the premain built in code                             */
void initVariables(){
        /* And the opposite for the other halves */
        CoreVars = &CoreVars0;
        DerivedVars = &DerivedVars0;
        ADCArrays = &ADCArrays0;
        ADCArraysRecord = &ADCArrays1;
        asyncADCArrays = &asyncADCArrays0;
        asyncADCArraysRecord = &asyncADCArrays1;
        currentDwellMath = &currentDwell0;
        currentDwellRealtime = &currentDwell1;

        injectorMainPulseWidthsMath = injectorMainPulseWidths0;
        injectorMainPulseWidthsRealtime = injectorMainPulseWidths1;
        injectorStagedPulseWidthsMath = injectorStagedPulseWidths0;
        injectorStagedPulseWidthsRealtime = injectorStagedPulseWidths1;

        mathSampleTimeStamp = &ISRLatencyVars.mathSampleTimeStamp0; // TODO temp, remove
        mathSampleTimeStampRecord = &ISRLatencyVars.mathSampleTimeStamp1; // TODO temp, remove
        RPM = &RPM0; // TODO temp, remove
        RPMRecord = &RPM1; // TODO temp, remove

        /* Setup the pointers to the registers for fueling use, this does NOT work if done in global.c, I still don't know why. */
        injectorMainTimeRegisters[0] = TC2_ADDR;
        injectorMainTimeRegisters[1] = TC3_ADDR;
        injectorMainTimeRegisters[2] = TC4_ADDR;
        injectorMainTimeRegisters[3] = TC5_ADDR;
        injectorMainTimeRegisters[4] = TC6_ADDR;
        injectorMainTimeRegisters[5] = TC7_ADDR;
        injectorMainControlRegisters[0] = TCTL2_ADDR;
        injectorMainControlRegisters[1] = TCTL2_ADDR;
        injectorMainControlRegisters[2] = TCTL1_ADDR;
        injectorMainControlRegisters[3] = TCTL1_ADDR;
        injectorMainControlRegisters[4] = TCTL1_ADDR;
        injectorMainControlRegisters[5] = TCTL1_ADDR;

        configuredBasicDatalogLength = maxBasicDatalogLength;

        // TODO perhaps read from the ds1302 once at start up and init the values or different ones with the actual time and date then update them in RTI
}


/** @brief Flash module setup
 *
 * Initialise configuration registers for the flash module to allow burning of
 * non-volatile flash memory from within the firmware.
 *
 * The FCLKDIV register can be written once only after reset, thus the lower
 * seven bits and the PRDIV8 bit must be set at the same time.
 *
 * We want to put the flash clock as high as possible between 150kHz and 200kHz
 *
 * The oscillator clock is 16MHz and because that is above 12.8MHz we will set
 * the PRDIV8 bit to further divide by 8 bits as per the manual.
 *
 * 16MHz = 16000KHz which pre-divided by 8 is 2000kHz
 *
 * 2000kHz / 200kHz = 10 thus we want to set the divide register to 10 or 0x0A
 *
 * Combining 0x0A with PRDIV8 gives us 0x4A (0x0A | 0x40 = 0x4A) so we use that
 *
 * @author Sean Keys
 *
 * @note If you use a different crystal lower than 12.8MHz PRDIV8 should not be set.
 *
 * @warning If the frequency you end up with is outside 150kHz - 200kHz you may
 *          damage your flash module or get corrupt data written to it.
 */
void initFlash(){
        FCLKDIV = 0x4A;                         /* Set the flash clock frequency        */
        FPROT = 0xFF;                           /* Disable all flash protection         */
        FSTAT = FSTAT | (PVIOL | ACCERR);       /* Clear any errors                     */
}


/* Set up the timer module and its various interrupts */
void initECTTimer(){

        // TODO rearrange the order of this stuff and pull enable and interrupt enable out to the last function call of init.


#ifndef NO_INIT
        /* Timer channel interrupts */
        TIE = 0x03; /* 0,1 IC interrupts enabled for reading engine position and RPM, 6 OC channels disabled such that no injector switching happens till scheduled */
        TFLG = ONES; /* Clear all the flags such that we are up and running before they first occur */
        TFLGOF = ONES; /* Clear all the flags such that we are up and running before they first occur */

        /* TODO Turn the timer on and set the rate and overflow interrupt */
        TSCR1 = 0x88; /* 0b_1000_1000 Timer enabled, and precision timer turned on */
        TSCR2 = 0x87; /* 0b_1000_0111 Overflow interrupt enable, divide by 256 if precision turned off */
//      PTPSR = 0x03; /* 4 prescaler gives .1uS resolution and max period of 7ms measured */
        PTPSR = 0x1F; /* 32 prescaler gives 0.8uS resolution and max period of 52.4288ms measured */
//      PTPSR = 0x3F; /* 64 prescaler gives 1.6uS resolution and max period of 105ms measured */
//      PTPSR = 0xFF; /* 256 prescaler gives 6.4uS resolution and max period of 400ms measured */
//      PTPSR = 0x7F; /* 128 prescaler gives 3.2uS resolution and max period of 200ms measured */
        /* http://www.google.com/search?hl=en&safe=off&q=1+%2F+%2840MHz+%2F+32+%29&btnG=Search */
        /* http://www.google.com/search?hl=en&safe=off&q=1+%2F+%2840MHz+%2F+32+%29+*+2%5E16&btnG=Search */
        /* www.mecheng.adelaide.edu.au/robotics_novell/WWW_Devs/Dragon12/LM4_Timer.pdf */

        /* Initial actions */
        TIOS = 0xFC; /* 0b_1111_1100 0 and 1 are input capture, 2 through 7 are output compare */
        TCTL1 = ZEROS; /* Set disabled at startup time, use these and other flags to switch fueling on and off inside the decoder */
        TCTL2 = ZEROS; /* 0,1 have compare turned off regardless as they are in IC mode. */
        TCTL3 = ZEROS; /* Capture off for 4 - 7 */
        TCTL4 = 0x0F; /* Capture on both edges of two pins for IC (0,1), capture off for 2,3 */

        // TODO setup delay counters on 0 and 1 to filter noise (nice feature!)
        //DLYCT = ??; built in noise filter

        /* Configurable tachometer output */
        PTMCPSR = fixedConfigs1.tachoSettings.tachoTickFactor - 1; // Precision prescaler - fastest is 1 represented by 0, slowest/longest possible is 256 represented by 255 or 0xFF
        MCCNT = ONES16; // init to slowest possible, first
        MCCTL = 0xC4; // turn on and setup the mod down counter
        MCFLG = 0x80; // clear the flag up front
#endif
}


/* Configure the PIT timers for their various uses. */
void initPITTimer(){
#ifndef NO_INIT
        /*  */
        // set micro periods
        PITMTLD0 = 0x1F; /* 32 prescaler gives 0.8uS resolution and max period of 52.4288ms measured */
        PITMTLD1 = 0x1F; /* ditto */
        /* http://www.google.com/search?hl=en&safe=off&q=1+%2F+%2840MHz+%2F+32+%29 Exactly the same as for ECT */

        // set timers running
//      PITLD0 = dwellPeriod;
        // enable module
        PITCFLMT = 0x80;
        // enable channels
        //PITCE = 0x03;
        // enable interrupt
//      PITINTE = 0x01;
        // clear flags
        //PITFLT = ONES;
#endif
}

/* Setup the sci module(s) that we need to use. */
void initSCIStuff(){
        /* The alternative register set selector defaults to zero */

        // set the baud/data speed
        SCI0BD = fixedConfigs1.serialSettings.baudDivisor;

        // etc

        /* Switch to alternative register set? */

        // etc

        /* Switch back again? */

        /*
         * 0 = LOOPS (normal two wire operation)
         * 0 = SCISWAI (Wait mode on)
         * 0 = RSRC (if loops=1, int/ext wiring)
         * 1 = M MODE (9 bit operation)
         * 0 = WAKE (idle line wakeup)
         * 0 = ILT (idle line type count start pos)
         * 1 = PE (parity on)
         * 1 = PT (odd parity) (minicom defaults to no parity)
         *
         * 00010011 = 0x13
         */
        SCI0CR1 = 0x13;

        /*
         * 0 = TIE (tx data empty isr disabled)
         * 0 = TCIE (tx complete isr disabled)
         * 1 = RIE (rx full isr enabled)
         * 0 = ILIE (idle line isr disabled)
         * 1 = TE (transmit enabled)
         * 1 = RE (receive enabled)
         * 0 = RWU (rx wake up normal)
         * 0 = SBK (send break off)
         *
         * 00101100 = 0x2C
         */
        SCI0CR2 = 0x2C;
}

/* TODO Load and calculate all configuration data required to run */
void initConfiguration(){
//      // TODO Calc TPS ADC range on startup or every time? this depends on whether we ensure that things work without a re init or reset or not.


        /* Add in tunable physical parameters at boot time TODO move to init.c TODO duplicate for secondary fuel? or split somehow?
         *nstant = ((masterConst * perCylinderVolume) / (stoichiometricAFR * injectorFlow));
         *nstant = ((139371764   * 16384                        ) / (15053                         * 4096                ));
         * OR
         *nstant = ((masterConst / injectorFlow) * perCylinderVolume) / stoichiometricAFR;
         *nstant = ((139371764   / 4096            ) * 16384                    ) / 15053                        ;
         * http://www.google.com/search?hl=en&safe=off&q=((139371764++%2F+4096+++++)+*+16384+++)+%2F+15053++++&btnG=Search */
        bootFuelConst = ((unsigned long)(masterFuelConstant / fixedConfigs1.engineSettings.injectorFlow) * fixedConfigs1.engineSettings.perCylinderVolume) / fixedConfigs1.engineSettings.stoichiometricAFR;

        /* The MAP range used to convert fake TPS from MAP and vice versa */
        TPSMAPRange = fixedConfigs2.sensorRanges.TPSOpenMAP - fixedConfigs2.sensorRanges.TPSClosedMAP;

        /* The ADC range used to generate TPS percentage */
        TPSADCRange = fixedConfigs2.sensorRanges.TPSMaximumADC - fixedConfigs2.sensorRanges.TPSMinimumADC;


        /* Use like flags for now, just add one for each later */
        unsigned char cumulativeConfigErrors = 0;

        /* Check various aspects of config which will cause problems */

        /* BRV max bigger than variable that holds it */
        if(((unsigned long)fixedConfigs2.sensorRanges.BRVMinimum + fixedConfigs2.sensorRanges.BRVRange) > 65535){
                //sendError(BRV_MAX_TOO_LARGE);
                cumulativeConfigErrors++;
        }

        // TODO check all critical variables here!

        /*
         * check ignition settings for range etc, possibly check some of those on the fly too
         * check fuel settings for being reasonable
         * check all variable tables for correct sizing
         * etc
         */

        while(cumulativeConfigErrors > 0){
                sleep(1000);
                PORTS_BA ^= ONES16; // flash leds
                //send("There were ");
                //sendUC(cumulativeConfigErrors);
                //send(" config errors, init aborted!");
        } // TODO ensure that we can recieve config and settings via serial while this is occuring! If not a bad config will lock us out all together.
}


/* Set up all the remaining interrupts */
void initInterrupts(){
        /* IMPORTANT : Set the s12x vector base register (Thanks Karsten!!) */
        IVBR = 0xF7; /* Without this the interrupts will never find your code! */

        /* Set up the Real Time Interrupt */
        RTICTL = 0x81; /* 0b_1000_0001 0.125ms/125us period http://www.google.com/search?hl=en&safe=off&q=1+%2F+%2816MHz+%2F+%282+*+10%5E3%29+%29&btnG=Search */
//      RTICTL = 0xF9; /* 0b_1111_1001 0.125s/125ms period http://www.google.com/search?hl=en&safe=off&q=1+%2F+%2816MHz+%2F+%282*10%5E6%29+%29&btnG=Search */
        CRGINT |= 0x80; /* Enable the RTI */
        CRGFLG = 0x80; /* Clear the RTI flag */

#ifndef NO_INIT
        // set up port H for testing
        PPSH = ZEROS; // falling edge/pull up for all
        PIEH = ONES; // enable all pins interrupts
        PIFH = ONES; // clear all port H interrupt flags
#endif

        // TODO set up irq and xirq for testing
        // IRQCR for IRQ
        //

        /* VReg API setup (only for wait mode? i think so) */
//      VREGAPIR = 0x09C3; /* For 500ms period : (500ms - 0.2ms) / 0.2ms = 0b100111000011 = 2499 */
//      VREGAPICL = 0x02; /* Enable the interrupt */
//      VREGAPICL = 0x04; /* Start the counter running */
        /* Writing a one to the flag will set it if it is unset, so best not to mess with it here as it probably starts off unset */

        /* LVI Low Voltage Interrupt enable */
        VREGCTRL = 0x02; // Counts bad power events for diagnosis reasons
}