Wie verstärkt das Muster auf der Antenne des Marco cubesat die Datenübertragung?

Es ist das elektrische Äquivalent eines Fresnel-Spiegels; der reflektierende Cousin einer Fresnel-Linse.

Jedes der kleinen quadratischen Muster ist eigentlich ein kleiner passiver Schaltkreis, der die einfallenden Mikrowellen mit einer anderen Phasenverschiebung reflektiert.

Es wird eine Reflectarray-Antenne genannt. Sie können mehr darüber in diesem Researchgate-Artikel A Deployable High-Gain Antenna Bound for Mars: Developing a new Folded-Panel Reflectarray for the first CubeSat mission to Mars lesen.

Paywalled: Die einsetzbare High-Gain-Antenne Mars Cube One

Open Access: Reflectarray-Antennen: Eine Überprüfung

Die Oberfläche emuliert einen konkaven Spiegel, daher muss die Mitte am "tiefsten" sein und daher verzögern die großen Quadrate die Reflexion am meisten. Aus der Mitte heraus verzögern sich die Muster immer weniger. Aber sobald Sie 360 ​​Grad erreicht haben, ist es das Gleiche wie Null, also kann es zur längsten Verzögerung zurückkehren.

Die elektrische Form emuliert eine außeraxiale Parabel, optisch sehr ähnlich wie moderne Satellitenantennen.

In der Zwischenzeit können Sie den Artikel in Hackaday lesen: Interview: Nacer Chahat entwirft Antennen für Mars-Cubesats und Sie können sich auch das Video unten ansehen.

In dieser Antwort können Sie auch mehr über MarCo-Hardwaresysteme lesen .

Quelle

oben: Quelle Für volle Größe anklicken

Die X-Band-Antenne, die zurück zur Erde sendet, lässt sich in drei Felder falten. Im eingesetzten Zustand ist das Reflektorarray breiter als hoch, sodass die Signalquelle auch über ein Array verfügt, um den vollen Reflektor zu nutzen. Interessanterweise hilft das Muster, das Sie auf dem Reflektorarray sehen können, dabei, dass die Flachbildschirme eher wie ein Parabolreflektor wirken. MarCO ist auch in der Lage, X-Band von der Erde zu empfangen, indem das Array verwendet wird, das auf der Vorderseite des oben gezeigten gefalteten Modells zu sehen ist. Diese CubeSats können nicht auf dem UHF-Band senden, sie empfangen nur die UHF-Kommunikation von Bodenfahrzeugen.

oben: Quelle „MarCO Cube Sat. X-Band Antenne“

Hier ist eine weitere Reflectarray-Antenne. Der Prototyp der Reflectarray-Antenne von DARPA bietet hohe Leistung in einem kleinen Gehäuse und Elektronen | DARPA R3D2 | Rocket Lab , obwohl sie nicht die Details des hier erforderlichen Musters zeigen:

Screenshot der Bereitstellungsdemonstration zur Reduzierung des Hochfrequenzrisikos (R3D2) :

So berechnen Sie die Pfadlängen und die erforderliche Phasenverschiebung, damit es funktioniert. Ich habe eine Cartoon-Darstellung von Quadraten hinzugefügt, die mit der erforderlichen Phasenverschiebung variieren, nur um zu zeigen, wie ein reales Szenario in Python berechnet werden könnte.

Ich habe die Abmessungen in diesem Bild in dieser Antwort und eine runde Zahl von 8,4 GHz verwendet, aber die Größen der Zonen stimmen nicht perfekt überein. Ich werde es so lassen, wie es ist, anstatt die Zahlen zu verfälschen, es ist ein interessantes Resträtsel!

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.patches as patches

halfpi, pi, twopi = [f*np.pi for f in (0.5, 1, 2)]
degs, rads = 180/pi, pi/180

clight     = 2.9979E+08      # m/s
d, h, w,   = [0.01 * thing for thing in (31.5, 33.5, 59.7)] # meters
nx, ny     = 51, 28
nn         = 15
nnx, nny   = [nn*n for n in (nx, ny)]
dx, dy     = w/nnx, h/nny

hh, hw     = 0.5 * h, 0.5 * w
hfeed      = hh - 0.01 * 13.2
freq       = 8.4E+09         # Hz, roughly
lam        = clight/freq     # meters

theta      = rads * 22.59

X_feed     = np.array([0, hfeed, -d])

print "w, h: ", w, h
print "nx, ny: ", nx, ny
print "dx, dy: ", dx, dy

y = dy * (np.arange(nny) + 0.5)
x = dx * (np.arange(nnx) - 0.5*(nnx-1))

Y, X = np.meshgrid(y, x, indexing='ij')
Z    = np.zeros_like(X)
XYZ  = np.stack((X, Y, Z), axis=2)

r_zero   = np.sqrt(((XYZ - X_feed)**2).sum(axis=2))

OPL      = r_zero - Y * np.sin(theta)
phase    = twopi * np.mod((OPL-OPL.min())/lam, 1)

iX  = nn/2 + nn*np.arange(nx)
iY  = nn/2 + nn*np.arange(ny)
pairs = sum([[(iy, ix) for ix in iX] for iy in iY], [])
vals  = phase[zip(*pairs)]

rects = []
for pair, val in zip(pairs, vals):
    w = (nn-6) * (1-val/twopi) + 4
    y0, x0 = pair[0] - nn/2, pair[1] - nn/2
    rect = patches.Rectangle((x0,y0),w,w,linewidth=1,edgecolor=None,facecolor='k')
    rects.append(rect)

if True:
    fig = plt.figure()
    ax  = fig.add_subplot(1, 1, 1)
    wow = ax.imshow(phase, origin='lower')
    plt.colorbar(wow)
    # ax.set_title('phase')
    for rect in rects:
        ax.add_patch(rect)
    ax.set_xticklabels([])
    ax.set_yticklabels([])
    plt.show()