/* * © 2020, Chris Harlow. All rights reserved. * * This file is part of Asbelos DCC API * * This 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. * * It 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 CommandStation. If not, see . */ #include //#include // use IDE menu Tools..Manage Libraries to locate and install TimerOne #include // use IDE menu Tools..Manage Libraries to locate and install TimerOne #include "AnalogReadFast.h" #include "Hardware.h" #include "Config.h" #include "DIAG.h" #if defined(ARDUINO_ARCH_AVR) #include // use IDE menu Tools..Manage Libraries to locate and install DIO2 #define WritePin digitalWrite2 #define ReadPin digitalRead2 #else #define WritePin digitalWrite #define ReadPin digitalRead #endif void Hardware::init() { pinMode(MAIN_POWER_PIN, OUTPUT); pinMode(MAIN_BRAKE_PIN, OUTPUT); pinMode(MAIN_SIGNAL_PIN, OUTPUT); if (MAIN_SIGNAL_PIN_ALT != UNUSED_PIN) pinMode(MAIN_SIGNAL_PIN_ALT, OUTPUT); pinMode(MAIN_SENSE_PIN, INPUT); if (MAIN_FAULT_PIN != UNUSED_PIN) pinMode(MAIN_FAULT_PIN, INPUT); pinMode(PROG_POWER_PIN, OUTPUT); pinMode(PROG_BRAKE_PIN, OUTPUT); pinMode(PROG_SIGNAL_PIN, OUTPUT); if (PROG_SIGNAL_PIN_ALT != UNUSED_PIN) pinMode(PROG_SIGNAL_PIN_ALT, OUTPUT); pinMode(PROG_SENSE_PIN, INPUT); if (PROG_FAULT_PIN != UNUSED_PIN) pinMode(PROG_FAULT_PIN, INPUT); } void Hardware::setPower(bool isMainTrack, bool on) { WritePin(isMainTrack ? MAIN_POWER_PIN : PROG_POWER_PIN, on ? HIGH : LOW); } void Hardware::setBrake(bool isMainTrack, bool on) { WritePin(isMainTrack ? MAIN_BRAKE_PIN : PROG_BRAKE_PIN, on ? HIGH : LOW); } void Hardware::setSignal(bool isMainTrack, bool high) { byte pin = isMainTrack ? MAIN_SIGNAL_PIN : PROG_SIGNAL_PIN; byte pin2 = isMainTrack ? MAIN_SIGNAL_PIN_ALT : PROG_SIGNAL_PIN_ALT; WritePin(pin, high ? HIGH : LOW); if (pin2 != UNUSED_PIN) WritePin(pin2, high ? LOW : HIGH); } void Hardware::setSyncSignal(bool high) { // This sets the same signal down both tracks at the same time. // Speed notes.... // Objective is to get the two track signals to change as close as possible // the high ? HIGH:LOW will only be evaluated once // The UNUSED_PIN check will be done at compile time. // If even more speed is required, its possible (not SAMD) to pre-prepare the // DIO pinnumber->pincode translation so the WritePin (digitalWrite2) does not // have to calculate the register and bit numbers every time. WritePin(MAIN_SIGNAL_PIN, high ? HIGH : LOW); WritePin(PROG_SIGNAL_PIN, high ? HIGH : LOW); if (MAIN_SIGNAL_PIN_ALT != UNUSED_PIN) WritePin(MAIN_SIGNAL_PIN_ALT, high ? LOW : HIGH); if (PROG_SIGNAL_PIN_ALT != UNUSED_PIN) WritePin(PROG_SIGNAL_PIN_ALT, high ? LOW : HIGH); } int Hardware::getCurrentRaw(bool isMainTrack) { // tooo much crap for a interrupt routine. Will see how that goes. byte faultpin = isMainTrack ? MAIN_FAULT_PIN : PROG_FAULT_PIN; byte powerpin = isMainTrack ? MAIN_POWER_PIN : PROG_POWER_PIN; if (faultpin != UNUSED_PIN && ReadPin(faultpin) == LOW && ReadPin(powerpin) == HIGH) return (int) (32000 / (isMainTrack ? MAIN_SENSE_FACTOR : PROG_SENSE_FACTOR)); // 32A should be enough // IMPORTANT: This function can be called in Interrupt() time within the 56uS timer // The default analogRead takes ~100uS which is catastrphic // so analogReadFast is used here. (-2uS) return analogReadFast(isMainTrack ? MAIN_SENSE_PIN : PROG_SENSE_PIN); } unsigned int Hardware::getCurrentMilliamps(bool isMainTrack, int raw) { return (unsigned int)(raw * (isMainTrack ? MAIN_SENSE_FACTOR : PROG_SENSE_FACTOR)); } void Hardware::setCallback(int duration, void (*isr)()) { TimerA.initialize(); TimerA.setPeriod(duration); TimerA.attachInterrupt(isr); TimerA.start(); } // shortcut to cpu dependent high speed write void Hardware::pinWrite(int pin, bool high) { WritePin(pin,high); } // Railcom support functions, not yet implemented //void Hardware::setSingleCallback(int duration, void (*isr)()) { // Timer2.initialize(duration); // Timer2.disablePwm(TIMER1_A_PIN); // Timer2.disablePwm(TIMER1_B_PIN); // Timer2.attachInterrupt(isr); //} //void Hardware::resetSingleCallback(int duration) { // if (duration==0) Timer2.stop(); // else Timer2.initialize(duration); //}