Pin.h

Go to the documentation of this file.

 
#include "Arduino.h"
 
#pragma once
 
#define DDR_HIGH (*_DDR |= _offset)  
#define DDR_TOGGLE (*_DDR ^= _offset)  
#define DDR_LOW (*_DDR &= _ioffset)  
 
#define PORT_HIGH (*_PORT |= _offset)  
#define PORT_TOGGLE (*_PORT ^= _offset)  
#define PORT_LOW (*_PORT &= _ioffset)  
 
#define DDR_ON (*_DDR & _offset)  
#define DDR_OFF (*_DDR | _ioffset)  
 
#define PORT_ON (*_PORT & _offset)  
#define PORT_OFF (*_PORT | _ioffset)  
 
#define PIN_ON (*_PIN & _offset)  
#define PIN_OFF (*_PIN | _ioffset)  
 
class Pin {
  public:
    Pin() {
      _number = 0;
      _offset = digitalPinToBitMask(_number);
      _ioffset = ~_offset;
      _timer = digitalPinToTimer(_number);
      _PIN = portInputRegister(digitalPinToPort(_number));
      _PORT = portOutputRegister(digitalPinToPort(_number));
      _DDR = portModeRegister(digitalPinToPort(_number));
    }
 
    Pin(uint8_t number) {
      _number = number;
      _offset = digitalPinToBitMask(_number);
      _ioffset = ~_offset;
      _timer = digitalPinToTimer(_number);
      _PIN = portInputRegister(digitalPinToPort(_number));
      _PORT = portOutputRegister(digitalPinToPort(_number));
      _DDR = portModeRegister(digitalPinToPort(_number));
    }
 
    Pin(uint8_t number, uint8_t offset, uint8_t timer, volatile uint8_t* PIN, volatile uint8_t* PORT, volatile uint8_t* DDR) {
      _number = number;
      _offset = offset;
      _ioffset = ~_offset;
      _timer = timer;
      _PIN = PIN;
      _PORT = PORT;
      _DDR = DDR;
    }
 
    operator bool() const {
      return bool(PIN_ON);
    }
 
    Pin& operator =(uint8_t state) {
      uint8_t oldSREG = SREG;
      cli();
      if (state == LOW) {
        PORT_LOW;
      } else {
        PORT_HIGH;
      }
      SREG = oldSREG;
 
      return *this;
    }
 
    uint8_t getNumber() {
      return _number;
    }
 
    uint8_t getOffset() {
      return _offset;
    }
 
    uint8_t getInverseOffset() {
      return _ioffset;
    }
 
    uint8_t getTimer() {
      return _timer;
    }
 
    volatile uint8_t* getPIN() {
      return _PIN;
    }
 
    volatile uint8_t* getPORT() {
      return _PORT;
    }
 
    volatile uint8_t* getDDR() {
      return _DDR;
    }
 
    uint8_t getMode() {
      if (DDR_ON) {
        return OUTPUT;
      } else {
        return INPUT;
      }
    }
 
    uint8_t getState() {
      if (PORT_ON) {
        return HIGH;
      } else {
        return LOW;
      }
    }
 
    uint8_t getValue() {
      if (PIN_ON) {
        return HIGH;
      } else {
        return LOW;
      }
    }
 
    uint16_t getAnalogValue() {
      return analogRead(_number);
    }
 
    void set(uint8_t mode, uint8_t state) {
      uint8_t oldSREG = SREG;
      cli();
      if (mode == INPUT) {
        DDR_LOW;
      } else {
        DDR_HIGH;
      }
      if (state == LOW) {
        PORT_LOW;
      } else {
        PORT_HIGH;
      }
      SREG = oldSREG;
    }
 
    void setMode(uint8_t mode) {
      uint8_t oldSREG = SREG;
      cli();
      if (mode == INPUT) {
        DDR_LOW;
      } else {
        DDR_HIGH;
      }
      SREG = oldSREG;
    }
 
    void setState(uint8_t state) {
      uint8_t oldSREG = SREG;
      cli();
      if (state == LOW) {
        PORT_LOW;
      } else {
        PORT_HIGH;
      }
      SREG = oldSREG;
    }
 
    void setInput() {
      uint8_t oldSREG = SREG;
      cli();
      DDR_LOW;
      SREG = oldSREG;
    }
 
    void setPullupOn() {
      uint8_t oldSREG = SREG;
      cli();
      PORT_HIGH;
      SREG = oldSREG;
    }
 
    void setPullupOff() {
      uint8_t oldSREG = SREG;
      cli();
      PORT_LOW;
      SREG = oldSREG;
    }
 
    void setInputPullupOn() {
      uint8_t oldSREG = SREG;
      cli();
      DDR_LOW;
      PORT_HIGH;
      SREG = oldSREG;
    }
 
    void setInputPullupOff() {
      uint8_t oldSREG = SREG;
      cli();
      DDR_LOW;
      PORT_LOW;
      SREG = oldSREG;
    }
 
    void setOutput() {
      uint8_t oldSREG = SREG;
      cli();
      DDR_HIGH;
      SREG = oldSREG;
    }
 
    void setHigh() {
      uint8_t oldSREG = SREG;
      cli();
      PORT_HIGH;
      SREG = oldSREG;
    }
 
    void setLow() {
      uint8_t oldSREG = SREG;
      cli();
      PORT_LOW;
      SREG = oldSREG;
    }
 
    void setOutputHigh() {
      uint8_t oldSREG = SREG;
      cli();
      DDR_HIGH;
      PORT_HIGH;
      SREG = oldSREG;
    }
 
    void setOutputLow() {
      uint8_t oldSREG = SREG;
      cli();
      DDR_HIGH;
      PORT_LOW;
      SREG = oldSREG;
    }
 
    void setDutyCycle(int value) {
      analogWrite(_number,value);
    }
 
    void toggleMode() {
      uint8_t oldSREG = SREG;
      cli();
      DDR_TOGGLE;
      SREG = oldSREG;
    }
 
    void toggleState() {
      uint8_t oldSREG = SREG;
      cli();
      PORT_TOGGLE;
      SREG = oldSREG;
    }
 
    volatile unsigned int rcTimer(volatile unsigned int count) {
      /*
      pin.setInput();
      for (; count > 0; count--) {
        if ((pin.getValue() == HIGH) || (count == 0)) {
          pin.setOutput();
          return count;
        }
      }
      */
 
      uint8_t status;
      asm volatile (
        // Save interupt status and disable interupts
        "in %[status], __SREG__ \n\t"  // Store current interupt status in variable 's'
        "cli \n\t"  // Disable interupts
 
        // Set Pin to input mode to start charging capacitor
        "ld __tmp_reg__, %a[_DDR] \n\t"  // Load the DDR register into r0 (__tmp_reg__)
        "and __tmp_reg__, %[_ioffset] \n\t"  // Apply the bit mask (offset) to r0 (__tmp_reg__)
        "st %a[_DDR], __tmp_reg__ \n\t"  // Store r0 (__tmp_reg__) in the DDR register
 
        // Count time before Pin becomes high
        "loop%=: \n\t"  // Label for looping
          "ld __tmp_reg__,%a[_PIN] \n\t"  // Load the PIN register into r0 (__tmp_reg__)
          "and __tmp_reg__, %[_offset] \n\t"  // Apply the bit mask (offset) to r0 (__tmp_reg__)
          "brne end%= \n\t"  // End the loop if r0 (__tmp_reg__) is not equal to zero by branching to label 'end'
          "dec %[count] \n\t"  // Decrement the value of 'count' by one
          "brne loop%= \n\t"  // If the value of 'count' is not equal to zero continue the loop by branching to label 'loop'
 
        // Done counting
        "end%=: \n\t"  // Label for ending loop
          // Set Pin to output mode to start discharging capacitor
          "ld __tmp_reg__, %a[_DDR] \n\t"  // Load the DDR register into r0 (__tmp_reg__)
          "or __tmp_reg__, %[_offset] \n\t"  // Apply the bit mask (offset) to r0 (__tmp_reg__)
          "st %a[_DDR], __tmp_reg__ \n\t"  // Store r0 (__tmp_reg__) in the PORT register
 
          // Restore interupt status
          "out __SREG__, %[status] \n\t"  // Load interupt status from variable 's'
 
        // Outputs
        :
          [count] "+r" (count),  // The value the counter was at when the pin went high
          [status] "=&r" (status)  // The interupt status
 
        // Inputs
        :
          [_DDR] "e" (_DDR),  // The address of the DDR register for the pin
          [_PIN] "e" (_PIN),  // The address of the PIN register for the pin
          [_offset] "r" (_offset),  // The bit mask used to access pin in registers
          [_ioffset] "r" (_ioffset)  // The inverse bit mask used to access pin in registers
      );
 
      return count;
    }
 
  private:
    uint8_t _number;
    uint8_t _offset;
    uint8_t _ioffset;
    uint8_t _timer;
    volatile uint8_t* _PIN;
    volatile uint8_t* _PORT;
    volatile uint8_t* _DDR;
};