/* * radioCESSB_Z_transmit_F32.cpp * This version of CESSB is intended for Zero-IF hardware. * * Bob Larkin, in support of the library: * Chip Audette, OpenAudio, Dec 2022 * * MIT License, Use at your own risk. * * See radioCESSB_Z_transmit_F32.h for technical info. * */ // NOTE: 96 ksps sample rate not yet implemented #include "radioCESSB_Z_transmit_F32.h" void radioCESSB_Z_transmit_F32::update(void) { audio_block_f32_t *blockIn, *blockOutI, *blockOutQ; // Temporary storage. At an audio sample rate of 96 ksps, the used // space will be half of the declared space. float32_t HilbertIn[32]; float32_t workingDataI[128]; float32_t workingDataQ[128]; float32_t delayedDataI[64]; // Allows batching of 64 data points float32_t delayedDataQ[64]; float32_t diffI[64]; float32_t diffQ[64]; if(sampleRate!=SAMPLE_RATE_44_50 && sampleRate!=SAMPLE_RATE_88_100) return; // Get all needed resources, or return if not available. blockIn = AudioStream_F32::receiveReadOnly_f32(); if (!blockIn) { return; } blockOutI = AudioStream_F32::allocate_f32(); // a block for I output if (!blockOutI) { AudioStream_F32::release(blockIn); return; } blockOutQ = AudioStream_F32::allocate_f32(); // and for Q if (!blockOutQ) { AudioStream_F32::release(blockOutI); AudioStream_F32::release(blockIn); return; } // The audio input peak levels for start of CESSB are -1.0, 1.0 // when gainIn==1.0. /* // A +/- pulse to test timing of various delays // PULSE TEST for diagnostics only for(int kk=0; kk<128; kk++) { uint16_t y=(ny & 1023); // pulse max at is just starting to clip if (y>=100 && y<115) blockIn->data[kk] = 4.189f; else if(y>=115 && y<130) blockIn->data[kk] = -4.189f; else blockIn->data[kk] = 0.0f; ny++; // Serial.println(blockIn->data[kk]); } */ // uint32_t ttt=micros(); // Decimate 48 ksps to 12 ksps, 128 to 32 samples // or 96 ksps to 12 ksps, 128 to 16 samples arm_fir_decimate_f32(&decimateInst, &(blockIn->data[0]), &HilbertIn[0], 128); // We now have nW=32 (for 48 ksps) or 16 (for 96 ksps) samples to process // Apply the Hilbert transform FIR. arm_fir_f32(&firInstHilbertI, &HilbertIn[0], &workingDataI[0], nW); /* ======= Sidebar: Circular 2^n length delay arrays ======== * * The length of the array, N, * must be a power of 2. For example N=2^6 = 64. The minimum * delay possible is the trivial case of 0 up to N-1. * As in C, let i be the index of the N array elements which * would range from 0 to N-1. If p is an integer, that is a power * of 2 also, with p >= n, it can serve as an index to the * delay array by "ANDing" it with (N-1). That is, * i = p & (N-1). It can be convenient if the largest * possible value of the integer p, plus 1, is an integer multiple * of the arrray size N, as then the rollover of p will not cause * a jump in i. For instance, if p is an uint8_t with a maximum * value of pmax=255, (pmax+1)/N = (255+1)/64 = 4, which is an * integer. This combination will have no problems from rollover * of p. * * The new data point is entered at index p & (N - 1). To * achieve a delay of d, the output of the delay array is taken * at index ((p-d) & (N-1)). The index is then incremented by 1. * * There are three delay lines of this construction below, starting * with delayHilbertQ * ========================================================== */ // Circular delay line for signal to align data with Hilbert FIR output // nW (32 for 48ksps) points into and out of the delay array for(uint16_t i=0; i maxMag0) maxMag0 = vWD; // Peak envelope countPower0++; } // Interpolate by 2 up to 24 ksps rate for(int k=0; k 1.0f) // This the clipping, scaled to 1.0, desired max { workingDataI[kk] /= mag; workingDataQ[kk] /= mag; } } // clipperIn needs spectrum control, so LP filter it. // Both BW of the signal and the sample rate have been doubled. arm_fir_f32(&firInstClipperI, workingDataI, workingDataI, nC); arm_fir_f32(&firInstClipperQ, workingDataQ, workingDataQ, nC); // Ready to compensate for filter overshoots for (int k=0; k eMax) // Data point just entered eMax = osEnv[(indexOsEnv) & 0X03]; if(osEnv[(indexOsEnv-1) & 0X03] > eMax) // Entered one before eMax = osEnv[(indexOsEnv-1) & 0X03]; if(osEnv[(indexOsEnv-2) & 0X03] > eMax) // Entered one before that eMax = osEnv[(indexOsEnv-2) & 0X03]; if(eMax < 1.0f) eMax = 1.0f; // Below clipping region indexOsEnv++; // Clip the signal to 1.0. -2 allows 1 look ahead on signal. float32_t eCorrectedI = osDelayI[(indexOsDelay - 2) & 0X3F] / eMax; float32_t eCorrectedQ = osDelayQ[(indexOsDelay - 2) & 0X3F] / eMax; // Filtering is linear, so we only need to filter the difference between // the signal and the clipper output. This needs less filtering, as the // difference is many dB below the signal to begin with. Hershberger 2014 diffI[k] = osDelayI[(indexOsDelay - 2) & 0X3F] - eCorrectedI; diffQ[k] = osDelayQ[(indexOsDelay - 2) & 0X3F] - eCorrectedQ; } // End, for k=0 to 63 // Filter the differences, osFilter has 123 taps and 61 delay arm_fir_f32(&firInstOShootI, diffI, diffI, nC); arm_fir_f32(&firInstOShootQ, diffQ, diffQ, nC); // Do the overshoot compensation for(int k=0; k maxMag1) maxMag1 = vWD; // Peak envelope countPower1++; } // Optional corrections to compensate for external hardware errors if(useIQCorrection) { for(int k=0; kdata[0], 128); arm_fir_f32(&firInstInterpolate2Q, workingDataQ, &blockOutQ->data[0], 128); // Voltage gain from blockIn->data to here for small sine wave is 1.0 AudioStream_F32::transmit(blockOutI, 0); // send the outputs AudioStream_F32::transmit(blockOutQ, 1); AudioStream_F32::release(blockIn); // Release the blocks AudioStream_F32::release(blockOutI); AudioStream_F32::release(blockOutQ); jjj++; //For test printing // Serial.println(micros() - ttt); } // end update()