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(); }