7. Interrupt Service Routine

(We have received an interrupt signal, what should we do?)

7.1 handleInterrupt()

Passes off responsibility for the interrupt to the active object.

inline void SDI12::handleInterrupt(){
  if (_activeObject) _activeObject->receiveChar();
}

7.2 receiveChar()

This function quickly reads a new character from the data line in to the buffer. It takes place over a series of key steps.

7.2.1 - Check for the start bit. If it is not there, interrupt may be from interference or an interrupt we are not interested in, so return.

7.2.2 - Make space in memory for the new character "newChar".

7.2.3 - Wait half of a SPACING to help center on the next bit. It will not actually be centered, or even approximately so until delayMicroseconds(SPACING) is called again.

7.2.4 - For each of the 8 bits in the payload, read wether or not the line state is HIGH or LOW. We use a moving mask here, as was previously demonstrated in the writeByte() function.

The loop runs from i=0x1 (hexadecimal notation for 00000001) to i<0x80 (hexadecimal notation for 10000000). So the loop effectively uses the masks following masks: 00000001 00000010 00000100 00001000 00010000 00100000 01000000 and their inverses.

Here we use an if / else structure that helps to balance the time it takes to either a HIGH vs a LOW, and helps maintain a constant timing.

7.2.5 - Skip the parity bit. There is no error checking.

7.2.6 - Skip the stop bit.

7.2.7 - Check for an overflow. We do this by checking if advancing the tail would make it have the same index as the head (in a circular fashion).

7.2.8 - Save the byte into the buffer if there has not been an overflow, and then advance the tail index.

void SDI12::receiveChar()
{
  if (digitalRead(_dataPin))			// 7.2.1 - Start bit?
  {
  	uint8_t newChar = 0;			// 7.2.2 - Make room for char.
  	
    delayMicroseconds(SPACING/2);		// 7.2.3 - Wait 1/2 SPACING

    for (uint8_t i=0x1; i<0x80; i <<= 1)	// 7.2.4 - read the 7 data bits
    {
      delayMicroseconds(SPACING);
      uint8_t noti = ~i;
      if (!digitalRead(_dataPin))
        newChar |= i;
      else 
        newChar &= noti;
    }
    
    delayMicroseconds(SPACING);				// 7.2.5 - Skip the parity bit. 
	delayMicroseconds(SPACING);			// 7.2.6 - Skip the stop bit. 

							// 7.2.7 - Overflow? If not, proceed.
    if ((_rxBufferTail + 1) % _BUFFER_SIZE == _rxBufferHead) 
    { _bufferOverflow = true; 
    } else {						// 7.2.8 - Save char, advance tail. 
      _rxBuffer[_rxBufferTail] = newChar; 
      _rxBufferTail = (_rxBufferTail + 1) % _BUFFER_SIZE;
    }
  }
}

7.3 Interrupt Vectors

Check if the various interrupt vectors are defined. If they are the ISR is instructed to call _handleInterrupt() when they trigger.

#if defined(PCINT0_vect)
ISR(PCINT0_vect){ SDI12::handleInterrupt(); }
#endif

#if defined(PCINT1_vect)
ISR(PCINT1_vect){ SDI12::handleInterrupt(); }
#endif

#if defined(PCINT2_vect)
ISR(PCINT2_vect){ SDI12::handleInterrupt(); }
#endif

#if defined(PCINT3_vect)
ISR(PCINT3_vect){ SDI12::handleInterrupt(); }
#endif