void StepperMotor::initialize(brain_pin_e stepPin, brain_pin_e directionPin, pin_output_mode_e directionPinMode,
float reactionTime, int totalSteps, brain_pin_e enablePin, Logging *sharedLogger) {
this->reactionTime = maxF(1, reactionTime);
this->totalSteps = maxI(3, totalSteps);
logger = sharedLogger;
if (stepPin == GPIO_UNASSIGNED || directionPin == GPIO_UNASSIGNED) {
return;
}
stepPort = getHwPort("step", stepPin);
this->stepPin = getHwPin("step", stepPin);
this->directionPinMode = directionPinMode;
this->directionPin.initPin("stepper dir", directionPin, &this->directionPinMode);
enablePort = getHwPort("enable", enablePin);
this->enablePin = getHwPin("enable", enablePin);
efiSetPadMode("stepper step", stepPin, PAL_MODE_OUTPUT_PUSHPULL);
efiSetPadMode("stepper enable", enablePin, PAL_MODE_OUTPUT_PUSHPULL);
palWritePad(this->enablePort, enablePin, true); // disable stepper
// All pins must be 0 for correct hardware startup (e.g. stepper auto-disabling circuit etc.).
palWritePad(this->stepPort, this->stepPin, false);
this->directionPin.setValue(false);
this->currentDirection = false;
chThdCreateStatic(stThreadStack, sizeof(stThreadStack), NORMALPRIO, (tfunc_t) stThread, this);
}
void initI2Cmodule(void) {
print("Starting I2C module\r\n");
i2cInit();
i2cStart(&I2CD1, &i2cfg);
efiSetPadMode("I2C clock", EFI_I2C_SCL_BRAIN_PIN, PAL_MODE_ALTERNATE(EFI_I2C_AF) | PAL_STM32_OTYPE_OPENDRAIN);
efiSetPadMode("I2C data", EFI_I2C_SDA_BRAIN_PIN, PAL_MODE_ALTERNATE(EFI_I2C_AF) | PAL_STM32_OTYPE_OPENDRAIN);
}
void initSpiModule(SPIDriver *driver, brain_pin_e sck, brain_pin_e miso,
brain_pin_e mosi,
int sckMode,
int mosiMode,
int misoMode) {
efiSetPadMode("SPI clock", sck, PAL_MODE_ALTERNATE(getSpiAf(driver)) + sckMode);
efiSetPadMode("SPI master out", mosi, PAL_MODE_ALTERNATE(getSpiAf(driver)) + mosiMode);
efiSetPadMode("SPI master in ", miso, PAL_MODE_ALTERNATE(getSpiAf(driver)) + misoMode);
}
void turnOnCapturePin(const char *msg, brain_pin_e brainPin) {
ICUDriver *driver = getInputCaptureDriver(msg, brainPin);
if (driver != NULL) {
iomode_t mode = (iomode_t) PAL_MODE_ALTERNATE(getAlternateFunctions(driver));
efiSetPadMode(msg, brainPin, mode);
}
}
void startTsPort(ts_channel_s *tsChannel) {
#if EFI_PROD_CODE || defined(__DOXYGEN__)
#if EFI_USB_SERIAL || defined(__DOXYGEN__)
if (isCommandLineConsoleOverTTL()) {
print("TunerStudio over USB serial");
/**
* This method contains a long delay, that's the reason why this is not done on the main thread
*/
usb_serial_start();
// if console uses UART then TS uses USB
tsChannel->channel = (BaseChannel *) CONSOLE_USB_DEVICE;
} else
#endif
{
if (CONFIGB(useSerialPort)) {
print("TunerStudio over USART");
efiSetPadMode("tunerstudio rx", engineConfiguration->binarySerialRxPin, PAL_MODE_ALTERNATE(TS_SERIAL_AF));
efiSetPadMode("tunerstudio tx", engineConfiguration->binarySerialTxPin, PAL_MODE_ALTERNATE(TS_SERIAL_AF));
#if TS_UART_DMA_MODE
print("Using UART-DMA mode");
// init FIFO queue
iqObjectInit(&tsUartDma.fifoRxQueue, tsUartDma.buffer, sizeof(tsUartDma.buffer), NULL, NULL);
// start DMA driver
tsDmaUartConfig.speed = CONFIGB(tunerStudioSerialSpeed);
uartStart(TS_DMA_UART_DEVICE, &tsDmaUartConfig);
// start continuous DMA transfer using our circular buffer
tsUartDma.readPos = 0;
uartStartReceive(TS_DMA_UART_DEVICE, sizeof(tsUartDma.dmaBuffer), tsUartDma.dmaBuffer);
#else
print("Using Serial mode");
tsSerialConfig.speed = CONFIGB(tunerStudioSerialSpeed);
sdStart(TS_SERIAL_UART_DEVICE, &tsSerialConfig);
tsChannel->channel = (BaseChannel *) TS_SERIAL_UART_DEVICE;
#endif /* TS_UART_DMA_MODE */
} else
tsChannel->channel = (BaseChannel *) NULL; // actually not used
}
#else /* EFI_PROD_CODE */
tsChannel->channel = (BaseChannel *) TS_SIMULATOR_PORT;
#endif /* EFI_PROD_CODE */
}
void initSpiCs(SPIConfig *spiConfig, brain_pin_e csPin) {
spiConfig->end_cb = NULL;
ioportid_t port = getHwPort("spi", csPin);
ioportmask_t pin = getHwPin("spi", csPin);
spiConfig->ssport = port;
spiConfig->sspad = pin;
efiSetPadMode("chip select", csPin, PAL_STM32_MODE_OUTPUT);
}
void initSpiModule(SPIDriver *driver, brain_pin_e sck, brain_pin_e miso,
brain_pin_e mosi,
int sckMode,
int mosiMode,
int misoMode) {
/**
* See https://github.com/rusefi/rusefi/pull/664/
*
* Info on the silicon defect can be found in this document, section 2.5.2:
* https://www.st.com/content/ccc/resource/technical/document/errata_sheet/0a/98/58/84/86/b6/47/a2/DM00037591.pdf/files/DM00037591.pdf/jcr:content/translations/en.DM00037591.pdf
*/
efiSetPadMode("SPI clock", sck, PAL_MODE_ALTERNATE(getSpiAf(driver)) | sckMode | PAL_STM32_OSPEED_HIGHEST);
efiSetPadMode("SPI master out", mosi, PAL_MODE_ALTERNATE(getSpiAf(driver)) | mosiMode | PAL_STM32_OSPEED_HIGHEST);
efiSetPadMode("SPI master in ", miso, PAL_MODE_ALTERNATE(getSpiAf(driver)) | misoMode | PAL_STM32_OSPEED_HIGHEST);
}
void OutputPin::initPin(const char *msg, brain_pin_e brainPin, pin_output_mode_e *outputMode) {
#if EFI_GPIO_HARDWARE || defined(__DOXYGEN__)
if (brainPin == GPIO_UNASSIGNED)
return;
ioportid_t port = getHwPort(msg, brainPin);
int pin = getHwPin(msg, brainPin);
/**
* This method is used for digital GPIO pins only, for peripheral pins see mySetPadMode
*/
if (port == GPIO_NULL) {
// that's for GRIO_NONE
this->port = port;
return;
}
assertOMode(*outputMode);
iomode_t mode = (*outputMode == OM_DEFAULT || *outputMode == OM_INVERTED) ?
PAL_MODE_OUTPUT_PUSHPULL : PAL_MODE_OUTPUT_OPENDRAIN;
/**
* @brief Initialize the hardware output pin while also assigning it a logical name
*/
if (this->port != NULL && (this->port != port || this->pin != pin)) {
/**
* here we check if another physical pin is already assigned to this logical output
*/
// todo: need to clear '&outputs' in io_pins.c
warning(CUSTOM_OBD_PIN_CONFLICT, "outputPin [%s] already assigned to %x%d", msg, this->port, this->pin);
engine->withError = true;
return;
}
this->currentLogicValue = INITIAL_PIN_STATE;
this->port = port;
this->pin = pin;
efiSetPadMode(msg, brainPin, mode);
setDefaultPinState(outputMode);
#endif /* EFI_GPIO_HARDWARE */
}
static void initAdcPin(brain_pin_e pin, const char *msg) {
// todo: migrate to scheduleMsg if we want this back print("adc %s\r\n", msg);
efiSetPadMode("adc input", pin, PAL_MODE_INPUT_ANALOG);
}
void initHardware(Logging *l) {
efiAssertVoid(CUSTOM_IH_STACK, getRemainingStack(chThdGetSelfX()) > 256, "init h");
sharedLogger = l;
engine_configuration_s *engineConfiguration = engine->engineConfigurationPtr;
efiAssertVoid(CUSTOM_EC_NULL, engineConfiguration!=NULL, "engineConfiguration");
board_configuration_s *boardConfiguration = &engineConfiguration->bc;
printMsg(sharedLogger, "initHardware()");
// todo: enable protection. it's disabled because it takes
// 10 extra seconds to re-flash the chip
//flashProtect();
chMtxObjectInit(&spiMtx);
#if EFI_HISTOGRAMS
/**
* histograms is a data structure for CPU monitor, it does not depend on configuration
*/
initHistogramsModule();
#endif /* EFI_HISTOGRAMS */
/**
* We need the LED_ERROR pin even before we read configuration
*/
initPrimaryPins();
if (hasFirmwareError()) {
return;
}
#if EFI_INTERNAL_FLASH
palSetPadMode(CONFIG_RESET_SWITCH_PORT, CONFIG_RESET_SWITCH_PIN, PAL_MODE_INPUT_PULLUP);
initFlash(sharedLogger);
/**
* this call reads configuration from flash memory or sets default configuration
* if flash state does not look right.
*/
if (SHOULD_INGORE_FLASH()) {
engineConfiguration->engineType = DEFAULT_ENGINE_TYPE;
resetConfigurationExt(sharedLogger, engineConfiguration->engineType PASS_ENGINE_PARAMETER_SUFFIX);
writeToFlashNow();
} else {
readFromFlash();
}
#else
engineConfiguration->engineType = DEFAULT_ENGINE_TYPE;
resetConfigurationExt(sharedLogger, engineConfiguration->engineType PASS_ENGINE_PARAMETER_SUFFIX);
#endif /* EFI_INTERNAL_FLASH */
#if EFI_HD44780_LCD
// initI2Cmodule();
lcd_HD44780_init(sharedLogger);
if (hasFirmwareError())
return;
lcd_HD44780_print_string(VCS_VERSION);
#endif /* EFI_HD44780_LCD */
if (hasFirmwareError()) {
return;
}
#if EFI_SHAFT_POSITION_INPUT || defined(__DOXYGEN__)
initTriggerDecoder();
#endif
bool isBoardTestMode_b;
if (CONFIGB(boardTestModeJumperPin) != GPIO_UNASSIGNED) {
efiSetPadMode("board test", CONFIGB(boardTestModeJumperPin),
PAL_MODE_INPUT_PULLUP);
isBoardTestMode_b = (!efiReadPin(CONFIGB(boardTestModeJumperPin)));
// we can now relese this pin, it is actually used as output sometimes
unmarkPin(CONFIGB(boardTestModeJumperPin));
} else {
isBoardTestMode_b = false;
}
#if HAL_USE_ADC || defined(__DOXYGEN__)
initAdcInputs(isBoardTestMode_b);
#endif
if (isBoardTestMode_b) {
// this method never returns
initBoardTest();
}
initRtc();
initOutputPins();
#if EFI_MAX_31855
initMax31855(sharedLogger, getSpiDevice(CONFIGB(max31855spiDevice)), CONFIGB(max31855_cs));
#endif /* EFI_MAX_31855 */
#if EFI_CAN_SUPPORT
initCan();
#endif /* EFI_CAN_SUPPORT */
// init_adc_mcp3208(&adcState, &SPID2);
// requestAdcValue(&adcState, 0);
#if EFI_SHAFT_POSITION_INPUT || defined(__DOXYGEN__)
// todo: figure out better startup logic
initTriggerCentral(sharedLogger);
#endif /* EFI_SHAFT_POSITION_INPUT */
turnOnHardware(sharedLogger);
#if HAL_USE_SPI || defined(__DOXYGEN__)
initSpiModules(boardConfiguration);
#endif
#if EFI_HIP_9011 || defined(__DOXYGEN__)
initHip9011(sharedLogger);
#endif /* EFI_HIP_9011 */
#if EFI_FILE_LOGGING || defined(__DOXYGEN__)
initMmcCard();
#endif /* EFI_FILE_LOGGING */
#if EFI_MEMS || defined(__DOXYGEN__)
initAccelerometer(PASS_ENGINE_PARAMETER_SIGNATURE);
#endif
// initFixedLeds();
#if EFI_BOSCH_YAW || defined(__DOXYGEN__)
initBoschYawRateSensor();
#endif /* EFI_BOSCH_YAW */
// initBooleanInputs();
#if EFI_UART_GPS || defined(__DOXYGEN__)
initGps();
#endif
#if EFI_SERVO
initServo();
#endif
#if ADC_SNIFFER || defined(__DOXYGEN__)
initAdcDriver();
#endif
#if HAL_USE_I2C || defined(__DOXYGEN__)
addConsoleActionII("i2c", sendI2Cbyte);
#endif
// USBMassStorageDriver UMSD1;
// while (true) {
// for (int addr = 0x20; addr < 0x28; addr++) {
// sendI2Cbyte(addr, 0);
// int err = i2cGetErrors(&I2CD1);
// print("I2C: err=%x from %d\r\n", err, addr);
// chThdSleepMilliseconds(5);
// sendI2Cbyte(addr, 255);
// chThdSleepMilliseconds(5);
// }
// }
#if EFI_VEHICLE_SPEED || defined(__DOXYGEN__)
initVehicleSpeed(sharedLogger);
#endif
#if EFI_CDM_INTEGRATION
cdmIonInit();
#endif
#if HAL_USE_EXT || defined(__DOXYGEN__)
initJoystick(sharedLogger);
#endif
calcFastAdcIndexes();
printMsg(sharedLogger, "initHardware() OK!");
}
