DigitalOutput::DigitalOutput(uint8_t iPin)
: mPin(iPin)
, mBit(digitalPinToBitMask(iPin))
, mOut(0)
, mMirror(false)
{
pinMode(iPin,OUTPUT);
uint8_t timer = digitalPinToTimer(iPin);
uint8_t port = digitalPinToPort(iPin);
if (port == NOT_A_PIN)
{
return;
}
// If the pin that support PWM output, we need to turn it off
// before doing a digital write.
if (timer != NOT_ON_TIMER)
{
turnOffPWM(timer);
}
mOut = portOutputRegister(port);
}
void digitalWrite(uint8_t pin, uint8_t val)
{
uint8_t timer = digitalPinToTimer(pin); // Hussein: After hussein finish this function uncomment this
uint8_t bit = digitalPinToBitMask(pin);
uint8_t port = digitalPinToPort(pin);
volatile uint8_t *out;
if (port == NOT_A_PIN) return;
// If the pin that support PWM output, we need to turn it off
// before doing a digital write.
if (timer != NOT_ON_TIMER) turnOffPWM(timer); // Hossam: uncomment this line when finish this function
out = portOutputRegister(port);
//uint8_t oldSREG = SREG;
cli();
//DI();
if (val == LOW) {
*out &= ~bit;
} else {
*out |= bit;
}
//SREG = oldSREG;
}
void digitalWrite(uint8_t pin, uint8_t val)
{
uint8_t timer = digitalPinToTimer(pin);
uint8_t bit = digitalPinToBitMask(pin);
uint8_t port = digitalPinToPort(pin);
volatile uint8_t *out;
if (port == NOT_A_PIN) return;
// If the pin that support PWM output, we need to turn it off
// before doing a digital write.
if (timer != NOT_ON_TIMER) turnOffPWM(timer);
out = portOutputRegister(port);
uint8_t oldSREG = SREG;
cli();
if (val == LOW) {
*out &= ~bit;
} else {
*out |= bit;
}
SREG = oldSREG;
}
void digitalWrite(register uint8_t pin, register uint8_t val)
{
uint32_t idx;
if (unlikely(pin >= GPIO_TOTAL))
return;
if (unlikely(g_APinState[pin].uCurrentInput)) {
if (val) {
trace_debug("%s: input pin%u driven high: enabling "
"pullup", __func__, pin);
pinMode(pin, INPUT_PULLUP);
} else {
trace_error("%s: input pin%u driven low!", __func__,
pin);
}
return;
}
if (unlikely(g_APinState[pin].uCurrentPwm)) {
turnOffPWM(pin);
}
idx = pinGetIndex(pin);
digitalWriteSetVal(idx, pin, val);
// alias - enable w/o on Fab D for waggle of pin 20 to compensate for pin 13 error
if (unlikely(g_APinDescription[idx].ulGPIOAlias != NONE)){
idx = pinGetIndex(g_APinDescription[idx].ulGPIOAlias);
digitalWriteSetVal(idx, g_APinDescription[idx].ulGPIOAlias, val);
}
//trace_debug("%s: pin=%d, handle=%d, val=%d", __func__, pin, handle, val);
}
void digitalWrite(UINT8 pin, UINT8 val)
{
UINT8 timer = digitalPinToTimer[pin];
UINT8 _bit = digitalPinToBitMask[pin];
UINT8 port = digitalPinToPort[pin];
volatile UINT8 *out;
if(port == NOT_A_PORT) return;
if(timer != NOT_ON_TIMER) turnOffPWM(timer);
out = portOutputRegister[port];
UINT8 oldGIE = GIE;
di();
if(val == LOW)
{
*out &= ~_bit;
}
else
{
*out |= _bit;
}
GIE = oldGIE;
}
void digitalWrite(uint8_t pin, uint8_t val){
if(pin > 5 || pin < 0){return;}
if(pin<2){turnOffPWM(pin);} //If its a PWM pin, make sure the PWM is off
if(!val){
PORTB &= ~_BV(pin);
} else {
PORTB |= _BV(pin);
}
}
void Hackscribble_Ferro::_initialiseChipSelect()
{
uint8_t timer = digitalPinToTimer(_chipSelect);
_bit = digitalPinToBitMask(_chipSelect);
uint8_t port = digitalPinToPort(_chipSelect);
if (port == NOT_A_PIN) return;
// If the pin that support PWM output, we need to turn it off
// before doing a digital write.
if (timer != NOT_ON_TIMER) turnOffPWM(timer);
_out = portOutputRegister(port);
}
int digitalRead(uint8_t pin)
{
uint8_t timer = digitalPinToTimer(pin);
uint8_t bit = digitalPinToBitMask(pin);
uint8_t port = digitalPinToPort(pin);
if (port == NOT_A_PIN) return LOW;
// If the pin that support PWM output, we need to turn it off
// before getting a digital reading.
if (timer != NOT_ON_TIMER) turnOffPWM(timer);
if (*portInputRegister(port) & bit) return HIGH;
return LOW;
}
void digitalWrite(uint8_t pin, uint8_t value)
{
uint8_t timer = digitalPinToTimer(pin);
uint8_t bit = digitalPinToBitMask(pin);
uint8_t port = digitalPinToPort(pin);
t_SetPortCfg cfg;
if (timer != NOT_ON_TIMER) turnOffPWM(timer);
if(port == NOT_A_PORT)
{
return;
}
cfg.pID = (uint16_t)portModeRegister(port);
setPinValue(value,cfg.pID,bit);
}
uint8_t digitalRead(uint8_t pin)
{
uint8_t timer = digitalPinToTimer(pin);
uint8_t bit = digitalPinToBitMask(pin);
uint8_t port = digitalPinToPort(pin);
t_SetPortCfg cfg;
if (timer != NOT_ON_TIMER) turnOffPWM(timer);
if(port == NOT_A_PIN)
{
return 0;
}
cfg.pID = (uint16_t)portModeRegister(port);
return getPinValue(cfg.pID,bit);
}
void DirectOutputPin::setPin(uint8_t pin)
{
uint8_t port = digitalPinToPort(pin);
if (port == NOT_A_PIN) return;
volatile uint8_t *modeRegister = portModeRegister(port);
_outputRegister = portOutputRegister(port);
_bitMask = digitalPinToBitMask(pin);
uint8_t oldSREG = SREG;
cli();
*modeRegister |= _bitMask;
SREG = oldSREG;
uint8_t timer = digitalPinToTimer(pin);
if (timer != NOT_ON_TIMER) turnOffPWM(timer);
}
uint8_t digitalRead(uint8_t pin){
if(pin > 5 || pin < 0){return 0;}
if(pin < 2) turnOffPWM(pin); //If its PWM pin, makes sure the PWM is off
return !!(PINB & _BV(pin));
}
void AdaEncoder::addEncoder(char _id, uint8_t _pinA, uint8_t _pinB)
{
AdaEncoder *tmpencoder;
id=_id;
pinA=_pinA;
pinB=_pinB;
#ifdef DEBUG
printBuffer.putString(getPSTR("addEncoder: "));
printBuffer.put(id);
printBuffer.put('\n');
printBuffer.putHex(pinA); printBuffer.put(' ');
printBuffer.putHex(pinB); printBuffer.put(' ');
printBuffer.putString(getPSTR(" *\n"));
#endif
// error checking
if (pinA == pinB) return; // No! silly
if (pinA < 8 && pinB > 7) return; // No! different ports
if ((pinA > 7 && pinA < 14) && (pinB < 8 || pinB > 13)) return; // No! different ports
if (pinA > 13 && pinB < 14) return; // No! different ports
if (pinA > 19 || pinB > 19) return; // No! out of band
turning=0;
clicks=0;
/* ADD TO THE LIST HERE */
if (firstEncoder==NULL) { firstEncoder=this; }
else {
tmpencoder=firstEncoder;
while (tmpencoder->next != NULL) tmpencoder=tmpencoder->next;
tmpencoder->next=this;
}
this->next=NULL;
port=portInputRegister(digitalPinToPort(pinA));
if (port == NOT_A_PIN) { return; }
// ** A **
bitA=digitalPinToBitMask(pinA);
uint8_t timerA=digitalPinToTimer(pinA);
if (timerA != NOT_ON_TIMER) turnOffPWM(timerA);
#ifdef DEBUG
//char buffer[16];
//Serial.print("encoder addr: ");
//sprintf(buffer, "%p", this);
//Serial.println(buffer);
printBuffer.putString("bitA: ");
printBuffer.putHex(bitA);
#endif
// ** B **
bitB=digitalPinToBitMask(pinB);
uint8_t timerB=digitalPinToTimer(pinB);
if (timerB != NOT_ON_TIMER) turnOffPWM(timerB);
#ifdef DEBUG
printBuffer.putString("bitB: ");
printBuffer.putHex(bitB);
#endif
// ** INTERRUPT **
#ifndef SWINTR_DEBUG
// This section should be on normally. OFF if performing software interrupts!
// GreyGnome DEBUG: Turn these two lines off by defining
// SWINTR_DEBUG. In the sketch, turn the pins into Outputs and set them high.
// Then set them as you wish, to create software interrupts.
pinMode(pinA, INPUT); pinMode(pinB, INPUT);
digitalWrite(pinA, HIGH); digitalWrite(pinB, HIGH);
#endif
attachInterrupt(pinA, pinB);
#ifdef DEBUGTIME
ada_output_port=portOutputRegister(digitalPinToPort(13)); // GreyGnome DEBUG.
ada_output_mask=digitalPinToBitMask(13); // defines the actual pin on that port
ada_not_output_mask=ada_output_mask^0xFF;
#endif
}
void AdaEncoder::addEncoder(char id, uint8_t pinA, uint8_t pinB)
{
#ifdef DEBUG
Serial.print("DEBUG addEncoder: ");
Serial.print(pinA, HEX); Serial.print(' ');
Serial.print(pinB, HEX); Serial.print(' ');
Serial.println(" *");
#endif
// error checking
if (pinA == pinB) return; // No! silly
if (pinA < 8 && pinB > 7) return; // No! different ports
if ((pinA > 7 && pinA < 14) && (pinB < 8 || pinB > 13)) return; // No! different ports
if (pinA > 13 && pinB < 14) return; // No! different ports
if (pinA > 19 || pinB > 19) return; // No! out of band
encoder *newencoder=(encoder*) malloc(sizeof(struct encoder));
newencoder->turning=0;
newencoder->clicks=0;
newencoder->id=id;
newencoder->next=NULL;
newencoder->port=portInputRegister(digitalPinToPort(pinA));
if (newencoder->port == NOT_A_PIN) { free(newencoder); return; }
// ** A **
newencoder->bitA=digitalPinToBitMask(pinA);
uint8_t timerA=digitalPinToTimer(pinA);
if (timerA != NOT_ON_TIMER) turnOffPWM(timerA);
#ifdef DEBUG
char buffer[16];
Serial.print("encoder addr: ");
sprintf(buffer, "%p", newencoder);
Serial.println(buffer);
Serial.print("bitA: ");
Serial.print(newencoder->bitA, BIN);
#endif
// ** B **
newencoder->bitB=digitalPinToBitMask(pinB);
uint8_t timerB=digitalPinToTimer(pinB);
if (timerB != NOT_ON_TIMER) turnOffPWM(timerB);
#ifdef DEBUG
Serial.print("bitB: ");
Serial.println(newencoder->bitB, BIN);
#endif
// ** INTERRUPT **
#ifndef SWINTR_DEBUG
// This section should be on normally. OFF if performing software interrupts!
// GreyGnome DEBUG: Turn these two lines off by defining
// SWINTR_DEBUG. In the sketch, turn the pins into Outputs and set them high.
// Then set them as you wish, to create software interrupts.
pinMode(pinA, INPUT); pinMode(pinB, INPUT);
digitalWrite(pinA, HIGH); digitalWrite(pinB, HIGH);
#endif
AdaEncoders[pinA]=newencoder;
AdaEncoders[pinB]=newencoder;
AdaEncoder::attachInterrupt(pinA, pinB);
// encoder linked list: add to it. Use this in loop() to search for the encoder that triggered the interrupt.
if (firstEncoder==NULL) { firstEncoder=newencoder; }
else {
tmpencoder=firstEncoder;
while (tmpencoder->next != NULL) {
tmpencoder=tmpencoder->next;
}
tmpencoder->next=newencoder;
}
#ifdef DEBUGTIME
ada_output_port=portOutputRegister(digitalPinToPort(13)); // GreyGnome DEBUG.
ada_output_mask=digitalPinToBitMask(13); // defines the actual pin on that port
ada_not_output_mask=ada_output_mask^0xFF;
#endif
}
void motorOff() {
MotorEnable = false;
turnOffPWM();
}
