How to read differential voltage from a HX710 ADC using Arduino
This page demonstrates how to read differential voltage from a HX710 ADC using Arduino. I recently obtained some pressure sensor boards from Amazon for less than $3 each under names like 6pcs 3.3-5V Digital Barometric Air Pressure Sensor Module Liquid Water Level Controller Board 0-40KPa that use this ADC. Several years ago I worked on a precision pressure meter project based on an I2C temperature and pressure sensor (MS5611), and now that I see new inexpensive SPI pressure sensor modules on the consumer market I’m interested to learn more about their capabilities.
The ADC chip is easily identified as a HX710B 24-Bit Analog-to-Digital Converter (ADC) with Built-in Temperature Sensor. According to the datasheet it can be powered by a 3.3V or 5V supply, and the value it reports is the differential voltage between two input pins.
The datasheet indicates this device can be run from a 3.3V or 5V supply, it uses a built-in fixed-gain (128x) differential amplifier, and it can read up to 40 samples per second. The datasheet provides an example circuit demonstrating how this ADC can be used to measure weight from a scale sensor:
To get a better idea of how this sensor works it would be helpful to locate its product number. I had a hunch it was beneath the part so I desoldered it, and indeed I found part identification information.
The pressure sensor is labeled as a PSG010S but unfortunately I struggled to find a quality datasheet for it. I did find some now-deleted images from an AliExpress listing showing the differences between the base model and the R and S variants.
I found this PSG010R datasheet (curiously written in Comic Sans) indicating that maximum voltage is 5V and that the gauge pressure is 0 - 40KPa (0 - 5.8 PSI). This seems to be a fairly standard differential pressure sensor design using a pair of voltage dividers where the pressure is a function of the difference in voltage at the two mid-points (a Wheatstone bridge).
Update (2022-12-23): I received an email from somebody offering additional information about this component:
The PSG010 reports positive and negative pressures and can easily have its range shifted to almost double in one direction with almost none in the other. All that is needed is to lift the +V (2) or ground pin (5) and insert a surface mount 75R ±15R under it.
Lifting the ground side by 75R makes it double positive, while pushing the applied +V down makes it double negative (vacuum).
– bruceg
This code demonstrates how to measure HX710B values using Arduino and display the readings in the serial terminal sufficient to graph in real time using the serial plotter. The animated plot is what it looks like when I blow puffs of air on the sensor.
const int HX_OUT_PIN = 2;
const int HX_SCK_PIN = 3;
enum HX_MODE { NONE, DIFF_10Hz, TEMP_40Hz, DIFF_40Hz};
const byte HX_MODE = DIFF_40Hz;
void setup() {
pinMode(HX_SCK_PIN, OUTPUT);
pinMode(HX_OUT_PIN, INPUT);
Serial.begin(9600);
}
void loop() {
Serial.println(readHX());
}
unsigned long readHX() {
// pulse clock line to start a reading
for (char i = 0; i < HX_MODE; i++) {
digitalWrite(HX_SCK_PIN, HIGH);
digitalWrite(HX_SCK_PIN, LOW);
}
// wait for the reading to finish
while (digitalRead(HX_OUT_PIN)) {}
// read the 24-bit pressure as 3 bytes using SPI
byte data[3];
for (byte j = 3; j--;) {
data[j] = shiftIn(HX_OUT_PIN, HX_SCK_PIN, MSBFIRST);
}
data[2] ^= 0x80; // see note
// shift the 3 bytes into a large integer
long result;
result += (long)data[2] << 16;
result += (long)data[1] << 8;
result += (long)data[0];
return result;
}
Note: This code flips the most significant bit of the sensor reading. The sensor always returns this bit as 1, except for the case of an out-of-range error (see excerpt from datasheet below). By simply flipping the bit our reported values are a continuous range from 0 to 2^14-1, with the edge values representing out-of-range errors.
The output 24 bits of data is in 2’s complement format.
When input differential signal goes out of the 24 bit range, the output data will be saturated at 0x800000 (MIN) or 0x7FFFFF (MAX)
until the input signal comes back to the input range.
– HX710 datasheet
Update (2022-12-23): I received an email from someone offering feedback about this code:
This code works in a loop, but perhaps by accident. The strongly worded statements in the HX710 datasheet about 25 - 27 clocks per readout imply that it is risky to rely on this. It may be that hanging clocks induce unwanted sleep modes or over-run into the next read cycle, etc. There is simply no real explanation in what is shown, so best to be safe - always set the next mode immediately AFTER collecting a reading and then always poll for new data ready before attempting a collection. Your ‘pulse clock line to start a reading’ loop before a reading should be ‘add next mode’ after a reading to comply with the timing specification. This will ensure that the next conversion will be available rather than the next scheduled conversion AFTER the mode is eventually sent.
– bruceg
Although some libraries are available which facilitate interacting with the HX710, here I engage with it discretely to convey each step of the conversion and measurement process. I found that many libraries use the 10 Hz mode by default, whereas I certainly prefer the 40 Hz mode. More frustratingly, code in many libraries refer to this as gain, which is incorrect. The datasheet indicates gain is fixed at 128 and cannot be changed in software.
Update (2022-12-23): I received an email explaining why people often use “gain” and “mode” when referring to the HX710:
The HX711 is similar to the HX710 but it has user selectable gain AND user selectable sample rates BUT only certain combinations are allowed, so setting mode WILL also select its matched gain value.
The HX710 uses most of the same internals, but with just 3 modes - reading the Wheatstone Bridge always using 128 gain at 10 or 40Hz while swapping to Avolt (HX710A) or internal Temperature (HX710B) uses a lower gain and less digits. So for people familiar with the HX711 there is no ambiguity in mixing mode and gain.
– bruceg
How to create a bitmap and set pixel colors in memory and save the result to disk or convert it to a traditional image format
This project how to represent bitmap data in a plain old C object (POCO) to create images from scratch using C# and no dependencies.
Common graphics libraries like SkiaSharp, ImageSharp, System.Drawing, and Maui.Graphics can read and write bitmaps in memory, so a POCO that stores image data and converts it to a bitmap byte allows creation of platform-agnostic APIs that can be interfaced from any graphics library.
This page demonstrates how to use C# (.NET 6.0) to create bitmap images from scratch. Bitmap images can then be saved to disk and viewed with any image editing program, or they can consumed as a byte array in memory by a graphics library. There are various bitmap image formats (grayscale, indexed colors, 16-bit, 32-bit, transparent, etc.) but code here demonstrates the simplest common case (8-bit RGB color).
The following struct represents RGB color as 3 byte values and has helper methods for creating new colors.
public struct RawColor
{
public readonly byte R, G, B;
public RawColor(byte r, byte g, byte b)
{
(R, G, B) = (r, g, b);
}
public static RawColor Random(Random rand)
{
byte r = (byte)rand.Next(256);
byte g = (byte)rand.Next(256);
byte b = (byte)rand.Next(256);
return new RawColor(r, g, b);
}
public static RawColor Gray(byte value)
{
return new RawColor(value, value, value);
}
}
A color class like this could be extended to support additional niceties. Refer to SkiaSharp’s SKColor.cs, System.Drawing’s Color.cs, and Maui.Graphics’ Color.cs for examples and implementation details. I commonly find the following features useful include when writing a color class:
- A static class with named colors e.g.,
RawColors.Blue
- Conversion to/from ARGB e.g.,
RawColor.FromAGRB(123456)
- Conversion to/from HTML e.g.,
RawColor.FromHtml(#003366)
- Conversion between RGB and HSL/HSV
- Helper functions to
Lighten() and Darken()
- Helper functions to
ShiftHue()
- Extension methods to convert to common other formats like
SKColor
This is the entire image class and it serves a few specific roles:
- Store image data in a byte array arranged identically to how it will be exported in the bitmap
- Provide helper methods to get/set pixel color
- Provide a method to return the image as a bitmap by adding a minimal header
public class RawBitmap
{
public readonly int Width;
public readonly int Height;
private readonly byte[] ImageBytes;
public RawBitmap(int width, int height)
{
Width = width;
Height = height;
ImageBytes = new byte[width * height * 4];
}
public void SetPixel(int x, int y, RawColor color)
{
int offset = ((Height - y - 1) * Width + x) * 4;
ImageBytes[offset + 0] = color.B;
ImageBytes[offset + 1] = color.G;
ImageBytes[offset + 2] = color.R;
}
public byte[] GetBitmapBytes()
{
const int imageHeaderSize = 54;
byte[] bmpBytes = new byte[ImageBytes.Length + imageHeaderSize];
bmpBytes[0] = (byte)'B';
bmpBytes[1] = (byte)'M';
bmpBytes[14] = 40;
Array.Copy(BitConverter.GetBytes(bmpBytes.Length), 0, bmpBytes, 2, 4);
Array.Copy(BitConverter.GetBytes(imageHeaderSize), 0, bmpBytes, 10, 4);
Array.Copy(BitConverter.GetBytes(Width), 0, bmpBytes, 18, 4);
Array.Copy(BitConverter.GetBytes(Height), 0, bmpBytes, 22, 4);
Array.Copy(BitConverter.GetBytes(32), 0, bmpBytes, 28, 2);
Array.Copy(BitConverter.GetBytes(ImageBytes.Length), 0, bmpBytes, 34, 4);
Array.Copy(ImageBytes, 0, bmpBytes, imageHeaderSize, ImageBytes.Length);
return bmpBytes;
}
public void Save(string filename)
{
byte[] bytes = GetBitmapBytes();
File.WriteAllBytes(filename, bytes);
}
}
The following code uses the bitmap class and color struct above to create test images
RawBitmap bmp = new(400, 300);
Random rand = new();
for (int x = 0; x < bmp.Width; x++)
for (int y = 0; y < bmp.Height; y++)
bmp.SetPixel(x, y, RawColor.Random(rand));
bmp.Save("random-rgb.bmp");
RawBitmap bmp = new(400, 300);
Random rand = new();
for (int x = 0; x < bmp.Width; x++)
{
for (int y = 0; y < bmp.Height; y++)
{
byte r = (byte)(255.0 * x / bmp.Width);
byte g = (byte)(255.0 * y / bmp.Height);
byte b = (byte)(255 - 255.0 * x / bmp.Width);
RawColor color = new(r, g, b);
bmp.SetPixel(x, y, color);
}
}
bmp.Save("rainbow.bmp");
RawBitmap bmp = new(400, 300);
Random rand = new();
for (int i = 0; i < 1000; i++)
{
int rectX = rand.Next(bmp.Width);
int rectY = rand.Next(bmp.Height);
int rectWidth = rand.Next(50);
int rectHeight = rand.Next(50);
RawColor color = RawColor.Random(rand);
for (int x = rectX; x < rectX + rectWidth; x++)
{
for (int y = rectY; y < rectY + rectHeight; y++)
{
if (x < 0 || x >= bmp.Width) continue;
if (y < 0 || y >= bmp.Height) continue;
bmp.SetPixel(x, y, color);
}
}
}
bmp.Save("rectangles.bmp");
The following functions can be added to the RawBitmap class to add drawing common operations
Here’s a simple (not optimized) method for drawing lines. Users interested in high quality drawing methods will find Bresenham’s line algorithm and Bresenham’s circle algorithm useful. There’s also A Rasterizing Algorithm for Drawing Curves which has extensive information about anti-aliasing and drawing Bézier splines.
public void DrawLine(int x1, int y1, int x2, int y2, Color color)
{
int xMin = Math.Min(x1, x2);
int xMax = Math.Max(x1, x2);
int yMin = Math.Min(y1, y2);
int yMax = Math.Max(y1, y2);
int xSpan = xMax - xMin;
int ySpan = yMax - yMin;
if (xSpan == 0)
{
for (int y = yMin; y <= yMax; y++)
SetPixel(xMin, y, color);
}
else if (ySpan == 0)
{
for (int x = xMin; x <= xMax; x++)
SetPixel(x, yMin, color);
}
else if (ySpan > xSpan)
{
for (int y = yMin; y <= yMax; y++)
{
double frac = (y - yMin) / (double)ySpan;
if (y2 < y1)
frac = 1 - frac;
int x = (int)(frac * xSpan + xMin);
SetPixel(x, y, color);
}
}
else
{
for (int x = xMin; x <= xMax; x++)
{
double frac = (x - xMin) / (double)xSpan;
if (x2 < x1)
frac = 1 - frac;
int y = (int)(frac * ySpan + yMin);
SetPixel(x, y, color);
}
}
}
public void DrawRect(Rectangle rect, Color color)
{
DrawLine(rect.Left, rect.Top, rect.Right, rect.Top, color);
DrawLine(rect.Right, rect.Top, rect.Right, rect.Bottom, color);
DrawLine(rect.Right, rect.Bottom, rect.Left, rect.Bottom, color);
DrawLine(rect.Left, rect.Bottom, rect.Left, rect.Top, color);
}
public void FillRect(Rectangle rect, Color color)
{
for (int y = rect.YMin; y < rect.YMax; y++)
{
for (int x = rect.XMin; x < rect.XMax; x++)
{
SetPixel(x, y, color);
}
}
}
The following code demonstrates how to load the bitmap byte arrays generated above into common graphics libraries and save the result as a JPEG file. Although the bitmap byte array can be written directly to disk as a .bmp file, these third-party libraries are required to encode images in additional formats like JPEG.
using System.Drawing;
static void SaveBitmap(byte[] bytes, string filename = "demo.jpg")
{
using MemoryStream ms = new(bytes);
using Image img = Bitmap.FromStream(ms);
img.Save(filename);
}
using SkiaSharp;
static void SaveBitmap(byte[] bytes, string filename = "demo.jpg")
{
using SKBitmap bmp = SKBitmap.Decode(bytes);
using SKFileWStream fs = new(filename);
bmp.Encode(fs, SKEncodedImageFormat.Jpeg, quality: 95);
}
using SixLabors.ImageSharp;
using SixLabors.ImageSharp.Formats.Jpeg;
static void SaveBitmap(byte[] bytes, string filename = "demo.jpg")
{
using Image img = Image.Load(bytes);
JpegEncoder encoder = new() { Quality = 95 };
img.Save(filename, encoder);
}
How to encode and decode PSK-31 messages using C#
PSK-31 is a narrow-bandwidth digital mode which encodes text as an audio tone that varies phase at a known rate. To learn more about this digital mode and solve a challenging programming problem, I’m going to write a PSK-31 encoder and decoder from scratch using the C# programming language. All code created for this project is open-source, available from my PSK Experiments GitHub Repository, and released under the permissive MIT license. This page documents my progress and notes things I learn along the way.
-
PSK31 messages have a continuous carrier tone
-
Symbols are represented by “symbols”, each 1/31.25 seconds long
-
If a symbol changes phase from its previous symbol it is a 0, otherwise it is a 1
Although a continuous phase-shifting tone of constant amplitude can successfully transmit PSK31 data, the abrupt phase transitions will cause splatter. If you transmit this you will be heard, but those trying to communicate using adjacent frequencies will be highly disappointed.
| Hard phase transitions (splatter) |
Soft phase transitions (cleaner) |
 |
 |
To reduce spectral artifacts that result from abruptly changing phase, phase transitions are silenced by shaping the waveform envelope as a sine wave so it is silent at the transition. This way the maximum rate of phase shifts is a sine wave with a period of half the baud rate. This is why the opening of a PSK31 message (a series of logical 0 bits) sounds like two tones: It’s the carrier sine wave with an envelope shaped like a sine wave with a period of 31.25/2 Hz. These two tones separated by approximately 15 Hz are visible in the spectrogram (waterfall).
Unlike ASCII (8 bits per character) and RTTY (5 bits per character), BPSK uses Varicode (1-10 bits per character) to encode text. Consecutive zeros 00 separate characters, so character codes must not contain 00 and they must start ane end with a 1 bit. Messages are flanked by a preamble (repeated 0 bits) and a postamble (repeated 1 bits).
NUL 1010101011
SOH 1011011011
STX 1011101101
ETX 1101110111
EOT 1011101011
ENQ 1101011111
ACK 1011101111
BEL 1011111101
BS 1011111111
HT 11101111
LF 11101
VT 1101101111
FF 1011011101
CR 11111
SO 1101110101
SI 1110101011
DLE 1011110111
DC1 1011110101
DC2 1110101101
DC3 1110101111
DC4 1101011011
NAK 1101101011
SYN 1101101101
ETB 1101010111
CAN 1101111011
EM 1101111101
SUB 1110110111
ESC 1101010101
FS 1101011101
GS 1110111011
RS 1011111011
US 1101111111
SP 1
! 111111111
" 101011111
# 111110101
$ 111011011
% 1011010101
& 1010111011
' 101111111
( 11111011
) 11110111
* 101101111
|
+ 111011111
, 1110101
- 110101
. 1010111
/ 110101111
0 10110111
1 10111101
2 11101101
3 11111111
4 101110111
5 101011011
6 101101011
7 110101101
8 110101011
9 110110111
: 11110101
; 110111101
< 111101101
= 1010101
> 111010111
? 1010101111
@ 1010111101
A 1111101
B 11101011
C 10101101
D 10110101
E 1110111
F 11011011
G 11111101
H 101010101
I 1111111
J 111111101
K 101111101
L 11010111
M 10111011
N 11011101
O 10101011
P 11010101
Q 111011101
R 10101111
S 1101111
T 1101101
U 101010111
|
V 110110101
X 101011101
Y 101110101
Z 101111011
[ 1010101101
\ 111110111
] 111101111
^ 111111011
_ 1010111111
. 101101101
/ 1011011111
a 1011
b 1011111
c 101111
d 101101
e 11
f 111101
g 1011011
h 101011
i 1101
j 111101011
k 10111111
l 11011
m 111011
n 1111
o 111
p 111111
q 110111111
r 10101
s 10111
t 101
u 110111
v 1111011
w 1101011
x 11011111
y 1011101
z 111010101
{ 1010110111
| 110111011
} 1010110101
~ 1011010111
DEL 1110110101
|
Now that we’ve covered the major steps of PSK31 message composition and modulation, let’s go through the steps ot generate a PSK31 message in code.
Here’s the gist of how I store my varicode table in code. Note that the struct has an additional Description field which is useful for decoding and debugging.
public struct VaricodeSymbol
{
public readonly string Symbol;
public string BitString;
public int[] Bits;
public readonly string Description;
public VaricodeSymbol(string symbol, string bitString, string? description = null)
{
Symbol = symbol;
BitString = bitString;
Bits = bitString.ToCharArray().Select(x => x == '1' ? 1 : 0).ToArray();
Description = description ?? string.Empty;
}
}
static VaricodeSymbol[] GetAllSymbols() => new VaricodeSymbol[]
{
new("NUL", "1010101011", "Null character"),
new("LF", "11101", "Line feed"),
new("CR", "11111", "Carriage return"),
new("SP", "1", "Space"),
new("a", "1011"),
new("b", "1011111"),
new("c", "101111"),
// etc...
};
I won’t show how I do the message-to-varicode lookup, but it’s trivial. Here’s the final function I use to generate Varicode bits from a string:
static int[] GetVaricodeBits(string message)
{
List<int> bits = new();
// add a preamble of repeated zeros
for (int i=0; i<20; i++)
bits.Add(0);
// encode each character of a message
foreach (char character in message)
{
VaricodeSymbol symbol = Lookup(character);
bits.AddRange(symbol.Bits);
bits.AddRange(CharacterSeparator);
}
// add a postamble of repeated ones
for (int i=0; i<20; i++)
bits.Add(1);
return bits.ToArray();
}
Now that we have our Varicode bits, we need to generate an array to indicate phase transitions. A transition occurs every time a bit changes value form the previous bit. This code returns phase as an array of double given the bits from a Varicode message.
public static double[] GetPhaseShifts(int[] bits, double phase1 = 0, double phase2 = Math.PI)
{
double[] phases = new double[bits.Length];
for (int i = 0; i < bits.Length; i++)
{
double previousPhase = i > 0 ? phases[i - 1] : phase1;
double oppositePhase = previousPhase == phase1 ? phase2 : phase1;
phases[i] = bits[i] == 1 ? previousPhase : oppositePhase;
}
return phases;
}
These constants will be used to define the shape of the waveform:
public const int SampleRate = 8000;
public const double Frequency = 1000;
public const double BaudRate = 31.25;
This minimal code generates a decipherable PSK-31 message, but it does not silence the phase transitions so it produces a lot of splatter. This function must be refined to shape the waveform such that phase transitions are silenced.
public double[] GetWaveformBPSK(double[] phases)
{
int totalSamples = (int)(phases.Length * SampleRate / BaudRate);
double[] wave = new double[totalSamples];
for (int i = 0; i < wave.Length; i++)
{
double time = (double)i / SampleRate;
int frame = (int)(time * BaudRate);
double phaseShift = phases[frame];
wave[i] = Math.Cos(2 * Math.PI * Frequency * time + phaseShift);
}
return wave;
}
This is the same function as above, but with extra logic for amplitude-modulating the waveform in the shape of a sine wave to silence phase transitions.
public double[] GetWaveformBPSK(double[] phases)
{
int baudSamples = (int)(SampleRate / BaudRate);
double samplesPerBit = SampleRate / BaudRate;
int totalSamples = (int)(phases.Length * SampleRate / BaudRate);
double[] wave = new double[totalSamples];
// create the amplitude envelope sized for a single bit
double[] envelope = new double[(int)samplesPerBit];
for (int i = 0; i < envelope.Length; i++)
envelope[i] = Math.Sin((i + .5) * Math.PI / envelope.Length);
for (int i = 0; i < wave.Length; i++)
{
// phase modulated carrier
double time = (double)i / SampleRate;
int frame = (int)(time * BaudRate);
double phaseShift = phases[frame];
wave[i] = Math.Cos(2 * Math.PI * Frequency * time + phaseShift);
// envelope at phase transitions
int firstSample = (int)(frame * SampleRate / BaudRate);
int distanceFromFrameStart = i - firstSample;
int distanceFromFrameEnd = baudSamples - distanceFromFrameStart + 1;
bool isFirstHalfOfFrame = distanceFromFrameStart < distanceFromFrameEnd;
bool samePhaseAsLast = frame == 0 ? false : phases[frame - 1] == phases[frame];
bool samePhaseAsNext = frame == phases.Length - 1 ? false : phases[frame + 1] == phases[frame];
bool rampUp = isFirstHalfOfFrame && !samePhaseAsLast;
bool rampDown = !isFirstHalfOfFrame && !samePhaseAsNext;
if (rampUp)
wave[i] *= envelope[distanceFromFrameStart];
if (rampDown)
wave[i] *= envelope[distanceFromFrameEnd];
}
return wave;
}
I wrapped the functionality above in a Windows Forms GUI that allows the user to type a message, specify frequency, baud rate, and whether or not to refine the envelope to reduce splatter, then either play or save the result. An interactive ScottPlot Chart allows the user to inspect the waveform.
These audio files encode the text The Quick Brown Fox Jumped Over The Lazy Dog 1234567890 Times! in 1kHz BPSK at various baud rates.
Let’s see what PSK-3 sounds like. This mode encodes data at a rate of 3 bits per second. Note that Varicode characters may require up to ten bits, so this is pretty slow. On the other hand the side tones are closer to the carrier and the total bandwidth is much smaller. The message here has been shortened to just my callsign, AJ4VD.
After implementing the C# encoder described above I created a JavaScript version (as per Atwood’s Law).
Considering all the steps for encoding PSK-31 transmissions are already described on this page, it doesn’t require too much additional effort to create a decoder using basic software techniques. Once symbol phases are detected it’s easy to work backwards: detect phase transitions (logical 0s) or repeats (logical 1s), treat consecutive zeros as a character separator, then look-up characters according to the Varicode table. The tricky bit is analyzing the source audio to generate the array of phase offsets.
The simplest way to decode PSK-31 transmissions leans on the fact that we already know the baud rate: 31.25 symbols per second, or one symbol every 256 samples at 8kHz sample rate. The audio signal can be segregated into many 256-sample bins, and processed by FFT. Once the center frequency is determined, the FFT power at this frequency can be calculated for each bin. Signal offset can be adjusted to minimize the imaginary component of the FFTs at the carrier frequency, then the real component will be strongly positive or negative, allowing phase transitions to be easily detected.
There are more advanced techniques to improve BPSK decoding, such as continuously adjusting frequency and phase alignment (synchronization). A Costas loop can help lock onto the carrier frequency while preserving its phase. Visit Simple BPSK31 Decoding with Python for an excellent demonstration of how to decode BPSK31 using these advanced techniques.
A crude C# implementation of a BPSK decoded is available on GitHub in the PSK Experiments repository
Since BPSK is just a carrier that applies periodic 180º phase-shifts, it’s easy to generate in hardware by directly modulating the signal source. A good example of this is KA7OEI’s PSK31 transmitter which feeds the output of an oscillator through an even or odd number of NAND gates (from a 74HC00) to produce two signals of opposite phase.
Unlike the 0º and 180º phases of binary phase shift keying (BPSK), quadrature phase shift keying (QPSK) encodes extra data into each symbol by uses a larger number of phases. When QPSK-31 is used in amateur radio these extra bits aren’t used to send messages faster but instead send them more reliably using convolutional coding and error correction. These additional features come at a cost (an extra 3 dB SNR is required), and in practice QPSK is not used as much by amateur radio operators.
QPSK encoding/decoding and convolutional encoding/decoding are outside the scope of this page, but excellent information exists on the Wikipedia: QPSK and in the US Naval Academy’s EC314 Lesson 23: Digital Modulation document.
After all that, it turns out PSK-31 isn’t that popular anymore. These days it seems the FT-8 digital mode with WSJT-X software is orders of magnitude more popular ??
This page describes how I achieve signal resampling with spline interpolation in pure C# without any external dependencies.
Cubic spline interpolation can be used to modify the sample rate of time series data. This page describes how I achieve signal resampling with spline interpolation in pure C# without any external dependencies. This technique can be used to:
-
Convert unevenly-sampled data to a series of values with a fixed sample rate
-
Convert time series data from one sample rate to another sample rate
-
Fill-in missing values from a collection of measurements
To simulate unevenly-sampled data I create a theoretical signal then sample it at 20 random time points.
// this function represents the signal being measured
static double f(double x) => Math.Sin(x * 10) + Math.Sin(x * 13f);
// randomly sample values from 20 time points
Random rand = new(123);
double[] sampleXs = Enumerable.Range(0, 20)
.Select(x => rand.NextDouble())
.OrderBy(x => x)
.ToArray();
double[] sampleYs = sampleXs.Select(x => f(x)).ToArray();
I then generate an interpolated spline using my sampled data points as the input.
(double[] xs, double[] ys) = Cubic.Interpolate1D(sampleXs, sampleYs, count: 50);
The generated points line-up perfectly with the sampled data.
There is slight deviation from the theoretical signal (and it’s larger where there is more missing data) but this is an unsurprising result considering the original samples had large gaps of missing data.
public static class Interpolation
{
public static (double[] xs, double[] ys) Interpolate1D(double[] xs, double[] ys, int count)
{
if (xs is null || ys is null || xs.Length != ys.Length)
throw new ArgumentException($"{nameof(xs)} and {nameof(ys)} must have same length");
int inputPointCount = xs.Length;
double[] inputDistances = new double[inputPointCount];
for (int i = 1; i < inputPointCount; i++)
inputDistances[i] = inputDistances[i - 1] + xs[i] - xs[i - 1];
double meanDistance = inputDistances.Last() / (count - 1);
double[] evenDistances = Enumerable.Range(0, count).Select(x => x * meanDistance).ToArray();
double[] xsOut = Interpolate(inputDistances, xs, evenDistances);
double[] ysOut = Interpolate(inputDistances, ys, evenDistances);
return (xsOut, ysOut);
}
private static double[] Interpolate(double[] xOrig, double[] yOrig, double[] xInterp)
{
(double[] a, double[] b) = FitMatrix(xOrig, yOrig);
double[] yInterp = new double[xInterp.Length];
for (int i = 0; i < yInterp.Length; i++)
{
int j;
for (j = 0; j < xOrig.Length - 2; j++)
if (xInterp[i] <= xOrig[j + 1])
break;
double dx = xOrig[j + 1] - xOrig[j];
double t = (xInterp[i] - xOrig[j]) / dx;
double y = (1 - t) * yOrig[j] + t * yOrig[j + 1] +
t * (1 - t) * (a[j] * (1 - t) + b[j] * t);
yInterp[i] = y;
}
return yInterp;
}
private static (double[] a, double[] b) FitMatrix(double[] x, double[] y)
{
int n = x.Length;
double[] a = new double[n - 1];
double[] b = new double[n - 1];
double[] r = new double[n];
double[] A = new double[n];
double[] B = new double[n];
double[] C = new double[n];
double dx1, dx2, dy1, dy2;
dx1 = x[1] - x[0];
C[0] = 1.0f / dx1;
B[0] = 2.0f * C[0];
r[0] = 3 * (y[1] - y[0]) / (dx1 * dx1);
for (int i = 1; i < n - 1; i++)
{
dx1 = x[i] - x[i - 1];
dx2 = x[i + 1] - x[i];
A[i] = 1.0f / dx1;
C[i] = 1.0f / dx2;
B[i] = 2.0f * (A[i] + C[i]);
dy1 = y[i] - y[i - 1];
dy2 = y[i + 1] - y[i];
r[i] = 3 * (dy1 / (dx1 * dx1) + dy2 / (dx2 * dx2));
}
dx1 = x[n - 1] - x[n - 2];
dy1 = y[n - 1] - y[n - 2];
A[n - 1] = 1.0f / dx1;
B[n - 1] = 2.0f * A[n - 1];
r[n - 1] = 3 * (dy1 / (dx1 * dx1));
double[] cPrime = new double[n];
cPrime[0] = C[0] / B[0];
for (int i = 1; i < n; i++)
cPrime[i] = C[i] / (B[i] - cPrime[i - 1] * A[i]);
double[] dPrime = new double[n];
dPrime[0] = r[0] / B[0];
for (int i = 1; i < n; i++)
dPrime[i] = (r[i] - dPrime[i - 1] * A[i]) / (B[i] - cPrime[i - 1] * A[i]);
double[] k = new double[n];
k[n - 1] = dPrime[n - 1];
for (int i = n - 2; i >= 0; i--)
k[i] = dPrime[i] - cPrime[i] * k[i + 1];
for (int i = 1; i < n; i++)
{
dx1 = x[i] - x[i - 1];
dy1 = y[i] - y[i - 1];
a[i - 1] = k[i - 1] * dx1 - dy1;
b[i - 1] = -k[i] * dx1 + dy1;
}
return (a, b);
}
}
This is the source code I used to generate the figures on this page.
Plots were generated using ScottPlot.NET.
// this function represents the signal being measured
static double f(double x) => Math.Sin(x * 10) + Math.Sin(x * 13f);
// create points representing randomly sampled time points of a smooth curve
Random rand = new(123);
double[] sampleXs = Enumerable.Range(0, 20)
.Select(x => rand.NextDouble())
.OrderBy(x => x)
.ToArray();
double[] sampleYs = sampleXs.Select(x => f(x)).ToArray();
// use 1D interpolation to create an evenly sampled curve from unevenly sampled data
(double[] xs, double[] ys) = Interpolation.Interpolate1D(sampleXs, sampleYs, count: 50);
var plt = new ScottPlot.Plot(600, 400);
double[] theoreticalXs = ScottPlot.DataGen.Range(xs.Min(), xs.Max(), .01);
double[] theoreticalYs = theoreticalXs.Select(x => f(x)).ToArray();
var perfectPlot = plt.AddScatterLines(theoreticalXs, theoreticalYs);
perfectPlot.Label = "theoretical signal";
perfectPlot.Color = plt.Palette.GetColor(2);
perfectPlot.LineStyle = ScottPlot.LineStyle.Dash;
var samplePlot = plt.AddScatterPoints(sampleXs, sampleYs);
samplePlot.Label = "sampled points";
samplePlot.Color = plt.Palette.GetColor(0);
samplePlot.MarkerSize = 10;
samplePlot.MarkerShape = ScottPlot.MarkerShape.openCircle;
samplePlot.MarkerLineWidth = 2;
var smoothPlot = plt.AddScatter(xs, ys);
smoothPlot.Label = "interpolated points";
smoothPlot.Color = plt.Palette.GetColor(3);
smoothPlot.MarkerShape = ScottPlot.MarkerShape.filledCircle;
plt.Legend();
plt.SaveFig("output.png");
The interpolation method described above only considered the horizontal axis when generating evenly-spaced time points (1D interpolation). For information and code examples regarding 2D and 3D cubic spline interpolation, see my previous blog post: Spline Interpolation with C#
How to add a progress bar to your client-side Blazor WebAssembly app to indicate page load progress.
Today I created a Blazor WebAssembly app that shows a progress bar while the page loads. This is especially useful for users on slow connections because Blazor apps typically require several megabytes of DLL and DAT files to be downloaded before meaningful content appears on the page.
Live Demo: LJPcalc (source code)
Edit index.html and identify your app’s main div:
<div id="app">Loading...</div>
Add a progress bar inside it:
<div id="app">
<h2>Loading...</h2>
<div class="progress mt-2" style="height: 2em;">
<div id="progressbar" class="progress-bar progress-bar-striped progress-bar-animated"
style="width: 10%; background-color: #204066;"></div>
</div>
<div>
<span id="progressLabel" class="text-muted">Downloading file list</span>
</div>
</div>
See Bootstrap’s progressbar page for extensive customization and animation options and best practices when working with progress indicators. Also ensure the version of Bootstrap in your Blazor app is consistent with the documentation/HTML you are referencing.
Edit index.html and identify where your app loads Blazor resources:
<script src="https://swharden.com/static/2022/05/29/_framework/blazor.webassembly.js"></script>
Update that script so it does not download automatically:
<script src="https://swharden.com/static/2022/05/29/_framework/blazor.webassembly.js" autostart="false"></script>
Add a script to the bottom of the page to start Blazor manually, identifying all the resources needed and incrementally downloading them while updating the progressbar along the way.
<script>
function StartBlazor() {
let loadedCount = 0;
const resourcesToLoad = [];
Blazor.start({
loadBootResource:
function (type, filename, defaultUri, integrity) {
if (type == "dotnetjs")
return defaultUri;
const fetchResources = fetch(defaultUri, {
cache: 'no-cache',
integrity: integrity,
headers: { 'MyCustomHeader': 'My custom value' }
});
resourcesToLoad.push(fetchResources);
fetchResources.then((r) => {
loadedCount += 1;
if (filename == "blazor.boot.json")
return;
const totalCount = resourcesToLoad.length;
const percentLoaded = 10 + parseInt((loadedCount * 90.0) / totalCount);
const progressbar = document.getElementById('progressbar');
progressbar.style.width = percentLoaded + '%';
const progressLabel = document.getElementById('progressLabel');
progressLabel.innerText = `Downloading ${loadedCount}/${totalCount}: ${filename}`;
});
return fetchResources;
}
});
}
StartBlazor();
</script>
