OpenAudio_ArduinoLibrary/UART_F32.h

/*
 * UART_F32
 * 10 JUne 2022 - Separated from FM Discriminator
 *
 * Copyright (c) 2022 Bob Larkin
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

/* This object takes a single audio input representing the baseband output
 * of a suitable detector such as frequency or phase.  The polarity of the
 * input is >0.0 for logic 1 as well as the the idle state and <0.0 for logic 0.
 * The timing of the UART is specified by the
 *   setUART(cTauI, cTauHalfI, nBits, nParity, nStop) function.  The first two
 * parameters are the data bit period measured in audio sample periods,
 * and half of that (roughly) that sets the number of audio sample periods between
 * between the 1-to-0 transition of the start bit and the middle of the start bit.
 * nBits can be between 1 and 32 (default 8). nParity can be PARITY_NONE,
 * PARITY_ODD or PARITY_EVEN. nStop is currently restricted to 1, but
 * this could change.
 *
 * Data is read using the functions
 *   int32_t getNDataBuffer() that returns the number of words available
 * and readUartData() that returns a pointer to the oldest UART data structure:
 *   struct uartData {
 *      uint32_t data;
 *      uint8_t error;    // Parity=01, Overrun=02, Underrun=04
 *      int32_t timeCrossings;}
 * Up to 16 of these structures can be buffered before creating
 * an ERR_OVERRUN.
 *
 * NOTE: Parity checking does nothing now.  Needs to be added using
 * the in-place function.  June 2022
 *
 * Time:    For T4.0, 7 microseconds for 128 data points.
 *
 */

#ifndef _uart_f32_h
#define _uart_f32_h

#include "AudioStream_F32.h"
#include "OpenAudio_ArduinoLibrary.h"

#define SERIAL_IDLE 0
#define SERIAL_DATA 1
#define SERIAL_DATA_FINISHED 2

#define PARITY_NONE 0
#define PARITY_ODD 1
#define PARITY_EVEN 2

#define ERR_FRAME 1;
#define ERR_OVERRUN 2
#define ERR_PARITY 4

struct uartData {
   uint32_t data;
   uint8_t  status;
   int32_t  timeCrossings;
   };

class UART_F32 : public AudioStream_F32 {
//GUI: inputs:1, outputs:0  //this line used for automatic generation of GUI node
//GUI: shortName: uart
public:
   // Default block size and sample rate:
   UART_F32(void) :  AudioStream_F32(1, inputQueueArray_f32) {
   }
   // Option of AudioSettings_F32 change to block size and/or sample rate:
   UART_F32(const AudioSettings_F32 &settings) : AudioStream_F32(1, inputQueueArray_f32) {
      sampleRate_Hz = settings.sample_rate_Hz;
      block_size = settings.audio_block_samples;
   }

   void setUART(uint32_t  _cTauI, uint32_t _cTauHalfI,
                uint16_t  _nBits, uint16_t _nParity, uint16_t  _nStop) {
   cTauI = _cTauI;
   cTauHalfI = _cTauHalfI;
   nBits = _nBits;
   nStop = _nStop;
   nTotal = 1 + nBits;
   if(nParity > 0)   nTotal++;
   }

   // Returns the number of unread data words
   int32_t getNDataBuffer(void)  {
	  delay(1);             // Why needed?? <<<<<<<<<<<<<<
      return (uartWriteIndex - uartReadIndex);
      }

   // Read UART data returns a pointer to the uartData structure.
   // This increments the index and thus can only be called once per
   // successful UART output word.  If no data is available, a NULL
   // pointer is returned.
   struct uartData* readUartData(void)  {
      if(uartReadIndex >= uartWriteIndex)  // Never should be greater
         return NULL;
      int32_t uri = uartReadIndex & uartDMask;
      // Circular increment of the read index
      uartReadIndex++;
      bufferSpace = 16 - uartWriteIndex + uartReadIndex;
      return &uartD[uri];
      }

   // The input is a floating point value, centered on 0.0.  One source of this
   // could be a discriminator base-band output.  If the input signal is offset
   // from zero, it can be corrected with this function.  This inputOffset is
   // added to the input and can be + or - in value.
   void setInputOffset(float32_t _inputOffset) {
      inputOffset = _inputOffset;
      }

   void setSampleRate_Hz(float32_t _sampleRate_Hz) {
      sampleRate_Hz = _sampleRate_Hz;
      }

   virtual void update(void);

private:
   // One input data pointer
   audio_block_f32_t *inputQueueArray_f32[1];
   float32_t sampleRate_Hz = AUDIO_SAMPLE_RATE_EXACT;
   uint16_t block_size = AUDIO_BLOCK_SAMPLES;

   // BFSK decode clock variables
   // Always 1 start bit.
   uint16_t  nBits = 8;          // Data bits
   uint16_t  nParity = PARITY_NONE;
   uint16_t  nStop = 1;          // Fixed for now
   uint16_t  nTotal = 9;         // 1+nBits+Parity
   uint32_t  cTauI = 40UL;
   uint32_t  cTauHalfI = 20UL;

   struct uartData uartD[16];   // Circular buffer of UART data

   float32_t inputOffset = 0.0f;  // Offset of input data

   // These next 2 indices are the index, mod 16, where we wil write
   // data to next, or read data from next (if available).
   // If the two are equal, no data is available to read.
   int32_t   uartReadIndex = 0L;  // Both indices continue to grow, unbounded
   int32_t   uartWriteIndex = 0L;

   const int32_t uartDMask = 0B1111; // Mask for 16 word buffer
   int32_t   bufferSpace = 16L; // 16 - uartWriteIndex + uartReadIndex
   uint16_t  serialState = SERIAL_IDLE;
   uint8_t   saveStatus;
   float32_t yData = 0.0f;
   float32_t yLast = -0.01f;
   float32_t yClock = -1.0f;
   float32_t errorClock = 0.0f;
   uint32_t  sClock = 0UL;   // Counted in audio sample units
   uint32_t  lastTime = 0UL;  // Last zero crossing
   uint32_t  timeStartBit= 0UL;
   uint32_t  timeLastTransition = 0UL;
   uint32_t  cSampleNext = 0UL;
   uint8_t   bitCount = 0UL;   // Where we are at in receiving word
   uint32_t  bitMask = 1;      // Values 1, 2, 4, 8, 16,...  tracks bitCount
   uint32_t  dataWord = 0UL;
   uint32_t  elapsedTime = 0UL;

void initUartData(uint n) {
   uartD[n].data = 0UL;
   uartD[n].status = 0;          // including data ready, overrun, parity and framing errors
   uartD[n].timeCrossings = 0;
   }

// Write an output word for Serial BFSK modem
void writeUartData(uint32_t _data, uint8_t _status, int32_t _timeCrossings)  {
   bufferSpace = 16L - uartWriteIndex + uartReadIndex;  //0 to 16 amount of space available
   if(bufferSpace > 0)
      {
      uartD[uartWriteIndex&uartDMask].data = _data;
      uartD[uartWriteIndex&uartDMask].status = _status;
      uartD[uartWriteIndex&uartDMask].timeCrossings = _timeCrossings;
      uartWriteIndex++;    // Bump write index
      saveStatus &= ~ERR_OVERRUN;   // Clear overrun bit, it has finally been sent
      }
   else      // No room in buffer
      {
      saveStatus |= ERR_OVERRUN;  // Error gets sent when overrun is cleared
      }
   bufferSpace = 16L - uartWriteIndex + uartReadIndex;
   }

// Thanks svicent.   NEEDS TO BE ADDED TO  writeUartData() <<<----
uint8_t oddParity(uint32_t ino)  {
   uint8_t n8 = 0;
   while(ino != 0)
      {
      n8++;
      ino &= (ino-1); // the loop will execute once for each bit of ino set
      }
   /* if n8 is odd, least significant bit will be 1 */
   return (n8 & 1);
   }

};   // End class UART_F32
#endif