I have a dual-band handheld radio for the 2m and 70cm bands. The so-called rubber-duck antenna that comes with it performs ok but it isn’t ideal. I could get into my local repeaters which are about 10mi away with enough power to break the squelch, but my audio was weak and quality was poor. Naturally, I decided I should put up an antenna!

To Build or to Buy?

You can buy antennas on the web or at local shops like my local (and fantastic) GigaParts, however in true geeky-nerd style, I have to DIY an antenna to feel I truly understand what is going on.

Self-Education

I’ll be the first to admit, prior to starting this DIY antenna journey, I didn’t have a great understanding of how antenna theory related to an actual antenna. I understood the general 1/2 wave, 1/4 wave relation to the designed frequency of an antenna, but until digging in, I didn’t get the math behind it. I found this website to be invaluable for a plain-language (plain to someone with a bit of an engineering tilt) introduction to the core concepts and how to apply them.

What kind of antenna should I build?

This was the next question I needed to answer. My antenna only had a few real requirements, namely:

1. Support the 2m band
2. Support the 70cm band
3. Be outdoor-mountable
4. Be home-manufacturable

This list ruled out a standard di-pole, because although I have learned you can “load” a dipole to make it multi-band, I didn’t feel I had the mounting capability at present for that. I also ruled out a ladder-line j-pole, because I couldn’t find ladder-line anywhere near me. It used to be more common I suppose when OTA TV used it for their antennas, but no more. I ruled out a Yagi also, based on the complicated layout, and I didn’t necessarily want a directional antenna. After scouring the web, I settled on a standard J-pole.

J-Pole: what is it and how does it work?

If you navigate to the Wikipedia entry for J-pole antenna , you will notice there are many “form-factors,” but they all follow the similar J shape, hence the name. But looking at the typical design, I couldn’t understand how the feed point (which separated only by a short distance) doesn’t just ruin the antenna performance. Take a look at the image below, credit ZyMOS.

I found the most useful explanation in a YouTube video (an aside: you can anything on YT these days) which I will link.

How it works, condensed version

A little prerequisite knowledge will help the understanding of how this antenna works.

1. The impedance in the middle of a 1/2 wave dipole is very low
2. The impedance at the ends of a 1/2 wave dipole is very high
3. The impedance somewhere between “very low” and “very high” is our magical 50Ω
4. We can end-feed a 1/2 wave antenna, but the impedance is very high (as seen in item #2)

Basically, the bottom U part of the j-pole is where the feed-point is adjusted to 50Ω (or thereabouts), and at the ends the impedance is very high, which is perfect to end-feed our 1/2 wave antenna (the long part of the J). As a result of this configuration, it really doesn’t matter which “leg” of the antenna is tied to shield vs. conductor for the feed-point.

But this is still for a single band, right?

Yes, but conveniently, the “long” side of the j-pole for 70cm band is pretty darn close to the “short” side of the j-pole for the 2m band, and since it doesn’t matter which element is our “radiating” element, we can essentially reuse one of our elements. See the rough diagram below for an example of this.

Let’s Build It!

So I had armed myself with the knowledge (at least the theory) and now I just needed to create a plan. Like any good engineer, I looked around the web for any prior work in this area (no reason to reinvent the wheel!) and much to my delight, someone had posted a PDF of an easy build process for such an antenna. Following this guide, I was able to construct my first dual-band j-pole.

Tuning the antenna

This step is very important, and can be made easier by the use of SWR meters or in my case a Vector Network Analyzer. I purchased the NanoVNA (wonderful tool, works like a charm) and was able to adjust the elements of my new antenna to achieve a great SWR and feed-point impedance in the 2m band, and pretty good SWR and impedance in the 70cm band. See captures below.

2m Tuning Results

70cm Tuning Result

Some notes on the 70cm performance

You’ll notice the oscillatory nature of the SWR and impedance in the 70cm band. I do not completely understand this, and may return to tweak the antenna a little more. I get decent performance in several “buckets” of the 70cm band, so it’s workable, but not ideal. I have a couple of theories as to why this is, but I don’t know for sure. If any readers have some comments on this, I’d love to hear it, please comment or send me some email!

Element Diameter

The elements in the 70cm legs of the antenna are 3/8″ rod as opposed to 3/4″ EMT conduit. I suspect that the deep V around 441MHz is the center frequency for these stubs, and the antenna just has a narrow bandwidth because the elements are small. I will likely try to build another one with all 3/4″ elements to see if the antenna is improved.

Element Smoothness

I’m not sure that this has an impact or not, but the 3/8″ rod is threaded at 24-TPI and the 3/4″ elements are smooth EMT conduit. I wonder if this interplays with the skin effect?

The End Result

I mounted this antenna up on the roof, and boy-oh-boy does it work great! I am able to be heard at least 17mi away by an APRS digipeater, which was not possible with the rubber duck antenna. I can now full-quiet the local repeaters and my voice is loud and clear. Also, mounting the antenna outside has greatly reduce computer and monitor based interference, which was a pleasant surprise. All said, I’d say this was a great learning experience and fun project to boot!

Thanks for reading!

The post J-Pole Antennas for Ham Radio appeared first on Jacob N Calvert.

I’ll give an example of what I mean by “internalize and restate it”.

To understand orbital motion (things like planets, moons, satellites), the mathematics to get a precise understanding of the shape and speed of an object in motion (Kepler’s First and Second Laws) can be fairly intimidating. For me, the breakthrough in highschool Physics class was comparing the speed and motion of an orbiting body to paddle ball toy. If you sling the ball part of a paddle ball toy while fixing the paddle part flat on a table, the elastic in the string will cause the ball to move slower the further away from the paddle it gets, and as it returns the elastic causes it to move faster.

Now this example doesn’t compare apples to apples because the elastic force in my example and gravitational forces in the physical world mathematically do not work the same way, but it’s an easy way to visualize the concept. PS: for a neat visualization with computer graphics, see here.

Back to the calculus now: I have found a book from the early 1910s called Calculus Made Easy, by Silvanus Thompson. Thompson’s approach to demystifying the concepts in basic calculus are the most straightforward I’ve ever read. He uses simple, relatable concepts to help the reader internalize and restate the problems in a domain that most have a keen understanding of, and as a result, the concepts become much less scary and much more useful! This book is freely available online as a PDF from Project Gutenbergm and a dedicated website. Both linked below for convenience.

Whether you’re learning calculus for the first time, need a basic refresher, or just want to reinforce your understanding of the concepts, I highly recommend giving it a look.

Project Gutenberg Link

Website Link

The post Calculus Made Simple appeared first on Jacob N Calvert.

Artificial intelligence, also sometimes referred to as machine intelligence (MI), is a burgeoning field of Computer Science which has ties to many, many other fields. AI is the application of neural networks in various forms to allow a machine to imitate or give the impression of natural cognition. This is quite a feat since it is not only a field which brings about great opportunity, but it is also a field which brings about great moral and ethical dilemmas, the least of which is the application of Rene Descartes’ “Cogito ergo sum” reasoning. The underpinning of AI however, is a set of mathematical beginnings that start with the humble neural network. I am not well educated on the ins-and-outs of neural network methodologies and the math behind it, but I have found the following videos from 3Blue1Brown incredibly helpful for boosting my understanding of the basics of neural networks.

Also check out the Tiny Neural Network library on GitHub from glouw. It’s a 200-line dependency free neural network that is easy enough to understand and play with on your own.

Thanks for reading!

The post Neural Networks and How They Work appeared first on Jacob N Calvert.

First Matrix Approx.

The idea was to use the coefficients in the matrix on the left to scale the incoming data (R_S, G_S, B_S) and produce an output that could be used to identify that color. This works in theory because of color mixing. However, due to imperfect reflection, imperfect lighting, and other types of imperfection, this was not as reliable as I wanted.
The next logical step was to “train” the coefficients by some manner. This was accomplished by taking a block of each color and wiggling it in front of the sensor at varying heights and angles and recording the RGB values from the sensor. I took 10,000 samples of each color and proceeded to do some post-processing in FreeMAT (a MATLAB clone). The post-processing proceeded in the following manner:

1. For each set of 10,000 samples, separate the RGB components, and take the mean of each component.
2. Assemble those generated means into a three-component array and divide by the 2-norm, thereby normalizing the array
3. Repeat the first two steps for each of the the color samples

The arrays that are generated are your coefficients for the previously shown matrix.
This method turned out to be very effective. I also found that if the colors change, it is as simple as regenerating the coefficients to compensate. Then the system will be able to identify the colors again. I am quite confident that this method can be used to identify many other colors as well, however I have only tested on the four colors.
I have attached my .m script below for further exploration. 
coeff_make.m

The post Reliably identifying discrete colors from an RGB color sensor appeared first on Jacob N Calvert.

An interesting thing to note about the Fibonacci sequence is that the ratio of one Fib number to its predecessor approaches the Golden Ratio as the Fib numbers get higher and higher. For example:

Golden Ratio =  1.61803398875

2/1 = 2

3/2 = 1.5

5/3 = 1.667

8/5 = 1.6

.
.
.

55/34 = 1.617647059
.
.
.
987/610 = 1.618032787

This is a very interesting point to me. However, I learned a few days ago that there is another sequence like the Fibonacci sequence. If you take any two positive integers as the starting of the sequence, and the apply the Fibonacci method, the same approach to the Golden Ratio occurs, with a twist. Let’s test this:

Take the first number = 1234
Take the second number = 1588


1588/1234 = 1.286871961

1588+1234 = 2822

2822/1588 = 1.777078086

2822+1588 = 4410

4410/2822 = 1.562721474

from here, I will just show the divisions...

7232/4410 = 1.639909297

11642/7232 = 1.60978923

18874/11642 = 1.621199107

30516/18874 = 1.616827382

It seems as though the ratio is “hovered around” as the sequence grows. To cut down on the number of hand calculations, I wrote a python script which I have attached to this post. I took three samples and recorded the output. Sample1 I used A = 1234 and B = 1588, Sample 2 I used A = 10 and B = 20 and Sample 3 I used A = 13 and B = 17. I used L = 10000000000 for all three. They each settled down to approximately the Golden Ratio after about 20 iterations of the algorithm. I do not know the mathematical proof of this sequence however I find it interesting that they each reach the same result in a similar numbers of iterations. I’ve attached the python file and my three sample outputs if you’re interested in playing with the sequence! I’ve also linked some articles about this subject in case you want to read more technical descriptions.

More on this subject

Fibonacci Numbers
Golden Ratio

Downloads

interesting_sequence.py

Sample3 Sample2 Sample1
Thanks for reading!

The post Interesting Numbers appeared first on Jacob N Calvert.

But to multiply really big numbers, we represent the two multiplicands as polynomials where each term is in the form cxⁿ, where x is the base in the number system, c is its coefficent modifier and n is the power to which the base is modified. For example, we can represent 4587 as 4x³ + 5x² + 8x¹ + 7x⁰, where x = 10.
Now, two numbers in this polynomial base representation can be multiplied to give the result. Here’s a small example:

321 = 3*10^2 + 2*10^1 + 1*10^0 ==> 3x^2 + 2x + 1

123 = 1*10^2 + 2*10^1 + 3*10^0 ==> 1x^2 + 2x + 3

321 * 123 = (3x^2 + 2x + 1)*(1x^2 + 2x + 3) = 3x^4 + 6x^3 + 9x^2 + 2x^3 + 4x^2 + 6x + x^2 +2x + 3 
= 3x^4 + 8x^3 + 14x^2 + 8x + 3

Now plugging in x = 10 ==>  3(10)^4 + 8(10)^3 + 14(10)^2 + 8(10) + 3 = 39483

Now verify with a calculator that 123*321 = 39483

Cool, huh?

We can use this knowledge to multiply some really, really big numbers. Since we have a way to calculate them product using polynomials, the question now is this: how do we multiply these polynomials when the order is large (like order-50 or order-n)? This is where the Toom-k algorithm becomes helpful.
First, let’s represent the polynomials as arrays where the position i indicates the power and the value at i represents the coefficient.

3x^2 + 2x + 1

will be represented as

[1, 2, 3]

Toom-k states that we can divide the polynomial array into sub-arrays of length (n/k) and perform (2*k)-1 recursive calls on those sub-arrays, then recombine them in O(n) time, and have a solution. For this article I want to focus on Toom-3, or otherwise called the Toom-Cook algorithm. To simplfiy the algorithm, we’ll require the length of our input arrays to be divisible by 3. Call the two input polynomials P and Q. P and Q get partitioned into n/3 or otherwise stated, they are divided into thirds. Call these sub-arrays A, B, C, D, E, and F where these are each of size n/3. Create 5 more arrays of size n/3 called G, H, J, L, M. Their values are as follows:
G = A+C, H = D+F, J = G-B, K = H-E, L = 2(J+A)-C, M = 2(K+D)-F
Here comes some serious math.
In this method of representing polynomials as arrays, an order-n polynomial takes up an array of length (n+1). Like in our previous example:

3x^2 + 2x + 1 is order-2

so n = 2, but its array representation takes up (n+1) = 3 length

[1, 2, 3]

Since this is known, then we can determine that multiplying two polynomials together of any order-n will generate in our system of representation an array of length (2*n)-1.
Ok, back to the Toom-3. We now create 5 more arrays of length (2*n)-1 named R, S, T, U, V. They are defined as R = AD, S = CF, T = (G+B)(H+E), U = JK, V = LM.
One more set of arrays of length (2*n/3)-1 named W, X, Y, Z and are defined as W = (V-T)/3, X = (T-U)/2, Y = U-S, Z = (Y-W)/2 + 2R.
Now we need to recombine these arrays into the final solution form. The product P*Q is defined as follows:
P*Q = Rx^(4n/3) + Zx^n + (X+Y-R)x^(2n/3) + (X-Z)x^(n/3) + S
This formula can look confusing, but it makes sense with some code to go with it:

BigInt* make_array(BigInt size)
{
	BigInt*res = new BigInt[size];
	for(BigInt i = 0; i < size; i ++)
	{
		res[i] = 0;
	}
	return res;
}
BigInt* Toom3(BigInt* P, BigInt*Q, BigInt n)
{
	BigInt pq_size = (2*n) -1 ;
	BigInt *PQ_Res = make_array(pq_size);
	BigInt sub_eq_size = n/3;
	BigInt *A = new BigInt[sub_eq_size], *B =new BigInt[sub_eq_size], *C=new BigInt[sub_eq_size], *D=new BigInt[sub_eq_size], *E=new BigInt[sub_eq_size], *F=new BigInt[sub_eq_size];
	memcpy(C,&P[0], sizeof(BigInt) * sub_eq_size);
	memcpy(B,&P[sub_eq_size], sizeof(BigInt) * sub_eq_size);
	memcpy(A,&P[sub_eq_size*2], sizeof(BigInt) * sub_eq_size);
	memcpy(F,&Q[0], sizeof(BigInt) * sub_eq_size);
	memcpy(E,&Q[sub_eq_size], sizeof(BigInt) * sub_eq_size);
	memcpy(D,&Q[sub_eq_size*2], sizeof(BigInt) * sub_eq_size);

	BigInt *G = new BigInt[sub_eq_size], *H =new BigInt[sub_eq_size], *J =new BigInt[sub_eq_size], *K =new BigInt[sub_eq_size], *L =new BigInt[sub_eq_size],*M =new BigInt[sub_eq_size];
	BigInt* GpB=new BigInt[sub_eq_size], *HpE=new BigInt[sub_eq_size];
	for(BigInt i = 0; i < sub_eq_size; i++)
	{
		G[i] = A[i] + C[i];
		H[i] = D[i] + F[i];
		J[i] = G[i] - B[i];
		K[i] = H[i] - E[i];
		L[i] = (2* (J[i] + A[i])) - C[i];
		M[i] = (2* (K[i] + D[i])) - F[i];
		GpB[i] = G[i] + B[i];
		HpE[i] = H[i] + E[i];
	}
	BigInt *R, *S, *T, *U, *V; //finally!
	R = mult(A, D, sub_eq_size, sub_eq_size);
	S = mult(C, F, sub_eq_size, sub_eq_size);
	U = mult(J, K, sub_eq_size, sub_eq_size);
	V = mult(L, M, sub_eq_size, sub_eq_size);
	T = mult(GpB, HpE, sub_eq_size, sub_eq_size);
	
	BigInt *W=new BigInt[2*n/3 -1], *X=new BigInt[2*n/3 -1], *Y=new BigInt[2*n/3 -1], *Z=new BigInt[2*n/3 -1]; // i just thought i was done.
	for(BigInt i = 0; i < 2*n/3 -1; i++)
	{
		W[i] = (V[i] - T[i])/3;
		X[i] = (T[i] - U[i])/2;
		Y[i] = U[i] - S[i];
		Z[i] = ((Y[i] - W[i])/2) + (2*R[i]);
	}
	for(BigInt i = 0; i < 2*n/3 -1; i++)
	{
		PQ_Res[i] 		+= S[i];
		PQ_Res[i + (n/3)]	+= (X[i] - Z[i]);
		PQ_Res[i + (2*n/3)] 	+= (X[i] + Y[i] - R[i]);
		PQ_Res[i + (n)] 	+= Z[i];
		PQ_Res[i + (4*n)/ 3] 	+= R[i];
	}
	return PQ_Res;
}

This method can be analyzed in its runtime using the Master Recurrence Theorem. Take Toom-3 for example. Its running time is T(n) = θ(1) + 5T(n/3) + θ(n). Using the Recurrence theorem we can show that the running time of Toom-3 is n^log₃5.For any general Toom-k, it can be shown that since we do (2*k) – 1 recursions and we split the arrays in to sub-arrays of size (n/k), the running time of Toom-k is T(n) = θ(1) + ((2*k)-1)T(n/k) + θ(n) which when used against the Recurrence theorem we show that it is of n^log_k(2*k)-1 time complexity. I found this very interesting and I hope you do too!!

The post Toom-k Polynomial Multiplication appeared first on Jacob N Calvert.

Who would have guessed such interesting characteristics could come of this sequence? I am inspired by John Conway’s insight into things as simple as this basic sequence. See the video below:

The post Look and Say Numbers Sequence appeared first on Jacob N Calvert.