The topology is shown in the image, there are 12 faces, 20 nodes and 30 edges. I started with node 1 as the pole, and compute the resistance at all other nodes with 1000 Ω resistors along the edges. The same MATLAB program found 5 possible solutions:

Category 1: drain at nodes 2,3 and 4: 633 1/3 Ω

Category 2: drain at nodes 5,6,7,8,9 and 10: 900 Ω

Category 3: drain at nodes 11,13,14,17,19: 1066 2/3 Ω

Category 4: drain at nodes 12,15,18: 1133 1/3 Ω

Category 5: drain at node 20: 1166 2/3 Ω

I guess the code is sufficiently debugged now, the answer agree with what I found on the internet.

If you can do the cube, then you can also do the icosaeder, the topology is as follows:

Enter the topology in the program that I used for the cube, and of course, the Kirchhoff conditions are automatically generated. With 1000 Ω resistors I found:

Configuration 1: From node 1 to node 12 : 500 Ω

Configuration 2: From node 1 to node 6 : 366 2/3 Ω

Configuration 3: From node 1 to node 7 : 466 2/3 Ω

For configuration 1 the current solution shows zero ampere between nodes 2-3, 3-4, 4-5, 5-6 and 6-2 and also between nodes 7-8, 8-9, 9-10, 10-11 and 11-7. For the other configurations this is not the case.

Are there volunteers to solder the “resistor icosaeder” and verify the answers?

What is the replacement resistance of this resistor network? There are three possible answers, the original problem I found on stackexchange (and other websites) was like this:

All resistors are the same value, the answer is 5/6 times the value of each resistor. The are also other answers, namely, the resistance along one side or the resistance across a face between two corner nodes.

How to solve this problem

Your friends for this problem are Ohm’s and Kirchhoff’s laws. Both laws are linear and you can build a system of linear equations to be solved. So how does this work? In a network of resistors there are voltage nodes, they are numbered in black, at which there are voltages, and there are currents along links between the nodes, the resistors numbers are in red. The voltage difference between two nodes A and B over a resistor R results in the linear condition Vb – Va = I * R. Also at a node you have the condition that the sum of all incoming currents equals to the sum of all outgoing currents. This is all you need together with two boundary conditions, namely a prescribed voltage at the entrance of the network (node 1) and 0 volt at the exit (node 7). The entrance point is called the source, and the exit point is called the drain.

In the resistor cube problem there are 8 nodes, and 12 links. The MATLAB code creates the matrix A and the vector y and it solves A x = y so that x in the end returns all the voltages and currents in the network. Due to the boundary conditions you need to remove two Kirchhoff law equations. The rationale is that we set voltage of 1 at node 1 and at node 7 we ground the system. The sum of the currents that connect to node 1 results in the replacement resistance for the cube. For the problem posted on stackexchange it becomes 5/6 times the resistors in the cube.

MATLAB code for the problem

In the follow code the Ohm law equations are hand coded, also the Kirchhoff conditions and the boundary conditions are manually inserted.

The outcome of this problem not only depends on the value of the resistors, but also on how we define the boundary conditions of the system. But we can change that, lets keep for simplicity the source at node 1, but select difference nodes where we ground the system. I found this for 1000 Ω resistors along the cube:

Ground at node 2, 4, or 5 and the replacement resistance becomes 583 1/3 Ω

Ground at node 3, 6, or 8 and the replacement resistance becomes 750 Ω

Ground at node 7 and the replacement resistance becomes 833 1/3 Ω

In other words, the problem is very symmetrical and there are only three possible answers.

Automate a part of the equations

Want to play around with code that automatically generates the Kirchhoff and boundary conditions so that you only need to specify the current paths? Try this code, in principle it should be expandable to something like SPICE which is a general tool:

%
% Cube with resistors, all R=1000 Ohm,
% Calculate the replacement resistance depending on the boundary conditions
%
clear
R = 1000;
%
% Here are the voltage nodes and the current links
%
vnode = [1 2 3 4 5 6 7 8]; nv = 8;
inode = [1 2 3 4 5 6 7 8 9 10 11 12];
inode = inode + 8; ni = 12;
nlink = 0; njoint = 0; ne = 0;
%
% topology: you only need to specify the voltage current relations
%
nlink = nlink + 1; link(nlink,:) = [vnode(1) vnode(2) inode(1)]; resistor(nlink) = R;
nlink = nlink + 1; link(nlink,:) = [vnode(2) vnode(3) inode(2)]; resistor(nlink) = R;
nlink = nlink + 1; link(nlink,:) = [vnode(3) vnode(4) inode(3)]; resistor(nlink) = R;
nlink = nlink + 1; link(nlink,:) = [vnode(4) vnode(1) inode(4)]; resistor(nlink) = R;
nlink = nlink + 1; link(nlink,:) = [vnode(5) vnode(6) inode(5)]; resistor(nlink) = R;
nlink = nlink + 1; link(nlink,:) = [vnode(6) vnode(7) inode(6)]; resistor(nlink) = R;
nlink = nlink + 1; link(nlink,:) = [vnode(7) vnode(8) inode(7)]; resistor(nlink) = R;
nlink = nlink + 1; link(nlink,:) = [vnode(8) vnode(5) inode(8)]; resistor(nlink) = R;
nlink = nlink + 1; link(nlink,:) = [vnode(5) vnode(1) inode(9)]; resistor(nlink) = R;
nlink = nlink + 1; link(nlink,:) = [vnode(2) vnode(6) inode(10)]; resistor(nlink) = R;
nlink = nlink + 1; link(nlink,:) = [vnode(3) vnode(7) inode(11)]; resistor(nlink) = R;
nlink = nlink + 1; link(nlink,:) = [vnode(8) vnode(4) inode(12)]; resistor(nlink) = R;
%
% define here the boundary conditions (where is the source/drain)
%
bc = zeros(nv,1);
bc(vnode(1)) = 2; Vset(2) = 1; % this is the source condition
bc(vnode(7)) = 1; Vset(1) = 0; % this is the drain condition <<<<< change the drain condition here
to = zeros(1,10); sense = zeros(1,10);
%
% automatically generate the joints (the Kirchhoff relations)
%
njoint = 0;
for i=1:nv,
if ( bc(vnode(i)) == 0 ),
from = vnode(i);
idx = find( (link(:,1) == from) | (link(:,2) == from) );
nidx = size(idx,1);
if (nidx > 1),
nto = 0;
for jdx = 1:nidx,
p = idx(jdx);
if (from == link(p,1)),
nto = nto + 1;
to(nto) = link(p,2);
sense(nto) = 1;
ipath(nto) = link(p,3);
end
if (from == link(p,2)),
nto = nto + 1;
to(nto) = link(p,1);
sense(nto) = -1;
ipath(nto) = link(p,3);
end
end
% [from to(1:nto) sense(1:nto) ipath(1:nto)];
njoint = njoint + 1;
joint(njoint,:) = ipath(1:nto); flow(njoint,:) = -sense(1:nto);
end
end
end
%
% Insert the Ohm and Kirchhoff relations in the A matrix, add the boundary
% conditions
%
for i=1:nlink,
ne = ne + 1;
idx = [link(i,1) link(i,2) link(i,3)];
A(ne,idx) = [-1 1 resistor(i)];
end
for i=1:njoint,
ne = ne + 1;
idx = [joint(i,1) joint(i,2) joint(i,3)];
A(ne,idx) = [flow(i,1) flow(i,2) flow(i,3)];
end
y=zeros((ne+2),1);
for i=1:nv,
j = vnode(i);
if (bc(j) ~= 0),
ne = ne + 1; A(ne,j) = 1;
if (bc(j) == 1),
y(ne) = Vset(1);
end
if (bc(j) == 2),
y(ne) = Vset(2);
end
end
end
%
% The A matrix and the y vector should be complete here
%
fprintf('Number of links/joints/equations = %d %d %d\n',nlink,njoint,ne);
x = A\y;
voltages = x(vnode)'
currents = x(inode)'
Ical = -x(inode(4))+x(inode(1))-x(inode(9));
Replacement = (Vset(2)-Vset(1))/Ical;
fprintf('R= %f, Replacement resistance = %f\n',R,Replacement);

Are my answers correct?

In order to check the model I made a resistor cube from twelve 270 Ω resistors. Next you take the multi-meter and start to measure a sufficient number of resistances so that the mean and the standard deviation can be determined. With 95% probability I found:

225.50 +/- 0.16 Ω for node 1 to 7 like combination

203.04 +/- 0.34 Ω for node 1 to 3 like combinations

157.88 +/- 0.48 Ω for node 1 to 2 like combinations

The resistors are according to me somewhat larger than 270 Ω, probably they are closer to 271 Ω, in any case, the model predicts:

For 270 Ω resistors you get: 225, 202.5 and 157.5 Ω

For 271 Ω resistors you get: 225.83, 203.25 and 158.08 Ω

For 270.5 Ω resistors you get: 225.42, 202.88 and 157.79 Ω

The last guess is closest to the measured values. The conclusion is that model and data seem to be in agreement.

Get a Raspberry pi 3 (rsp3) and you own a 1 Gb ram 8 Gb flash memory Debian linux box that talks to the internet via wifi and/or wired ethernet. I configured it to run as a headless rsp3, initially you need a HDMI monitor, a USB mouse and a keyboard, and access to a wired ethernet. Once you got ssh to run on the rsp3 you can access it from anywhere on your local area network (LAN) or beyond when you forward ports on your router.

Plug in the airspy and try to run spyserver, initially sdrsharp crashed on a device busy warning. I added airspyone_host-master installed their libraries from github, set the device-type to the airspy you it starts to work, great support via their forums, thanks! Next run sdrsharp on any PC, and configure the input to be the sdr://192.168.0.16:5555/ device on your lan. IP 192.186.0.8 is the wifi access to my rsp3, and IP 192.186.0.16 is the wired rsp3. The network bandwidth is restricted to 100 MBps by the rsp3 although my network could handle the 10 folds (which is handy if you’ve got children watching youtube).

Bandwidth is a somewhat a concern on your LAN, so tweak the Bandwidth and the IQ format checkboxes in sdrsharp and change it so that the connection is confortable, see also the images below. This setup works both in wifi and wired, the latter allows a bit more bandwidth and is more stable because my WiFi to the access point has an overall bandwidth limitation of 10 MB/s which is shared by everyone in the house.

The benefit for hamradio is that a remote receiver can be set-up in your neighbood, away from the QRM (radio frequency interference, demonstrated in this movie) in your shack. If you live in an apartment building with access to the roof, then try to get the receiver and the antenna to the roof and control everything remotely over the LAN. Often this is easier than installing coax cable over many meters, and oftentimes the LAN UTP cables are already there.

Bandwidth

The SDR generates IQ data that is scrutinized by the PC, your PC is fast enough, the RSP3 is also fast enough, but the bandwidth of the local area network (LAN) is often the main limitation. If bandwidth is already an issue on your LAN, then it will certainly be a greater problem when it goes beyond your LAN. This is one of the main limitations of any WebSDR, it may need a lot of bandwidth. But all airspy’s were designed to efficiently handle the compression of IQ data.

The checkbox “Use full IQ” directly under the spyserver select box in image 1 will open up when the connection to the spyserver is closed, the C button right of the select box opens and closes the connection, click it a few times until the “Use full IQ” checkbox is can be selected. With this you tell the spyserver on the RSP3 to compress the IQ data so that a typical 5 to 10 MB/s is reduced to often less than 100 kB/s.

Reduced IQ data has a consequence for the resolution of the spectrum and the waterfall plot resolution displayed in sdrsharp, but the quality of the audio seems unaffected. Other options are the bandwidth and the IQ format which can be selected on the fly. Both also determine the bandwidth over your LAN.

Remember that all data packages on your LAN directly go to the router before they will arrive at their destination, unlike traffic over a USB cable between the SDR and your PC. A gigabit router and CAT6 cabling is advisable in my opinion. Although the RSP3 box and the SDR are physically seen no more than a meter away from your PC, the router is 30m down the cable, while the LAN is shared by some 20 devices because nearly all gadgets in the house carry WiFi these days.

Tried various bands (MF, 160m, 80m and 40m) overnight where I was in receive mode with the active antenna, cross-mode setting. Receiver was the airspy HF+ and apparently there are good band conditions:

The mapping part of WSPR gave me errors, so I could only manage to make some quick resolution shots.

Since the airspy HF+ comes with an 18 bit ADC rather than the 12 bit ADC for the airspy the dynamic range is extended. The dynamic range in dB is computed as 20 log10( 2^n ) where n is the number of bits of the ADC, this is 108 dB for 18 bits, and it is 72 dB for 12 bits. For the first SDR I once got it was 8 bits, so 48 dB. For the noise floor measurement it means that I have more possibilities to test the SNR than with all earlier software defined receivers.

For the airspy HF+ I measured the SNR of a known signal near 10 MHz which is directly into the receiver. The source is 120 mV rms over a 50 Ohm dummy load, this is attenuated with 42 dB (I need to find something larger actually) and I got an SNR of 69 dB over 500 Hz bandwidth. This corresponds to -146 dB per 500 Hz, add 30 to get dBm, thus -116 dBm over 500 Hz. The noise floor is therefore -143 dBm/Hz, we are 30 dB over the thermal noise floor at room temperature of -173 dbm/Hz, the excess noise is probably around 30dB. The vertical scale in SDRsharp looks like it is in dBm over a 500 Hz bandwidth.

The -116dBm over 500 Hz can be improved by decimating the IQ data, everything was measured at 768 kHz BW for the SDR, and the following steps are 384, 192, 96 and 48 kHz, with each decimation step you yield 3 dB in the noise floor, there are 4 steps so we win 12 dB. In this way I end up at -128 dBm over a 500 Hz window where the SDR decimation is step to 48 kHz.

Work to be done:

My results are different compared to what you find on the airspy website, they mention -140 dBm where the bandwidth is not mentioned.

The other possibility is that I need to repeat the test with a different signal source, because intermodulation and carrier phase noise of the test source may affect my results.