Published March 17, 2022 © GPL3+

Calliope mini Schwerelosigkeits-Detektor

Bringe deinem Calliope bei, zu erkennen, ob er schwerelos ist! Probier's aus, indem du ihn in die Luft wirfst und wieder auffängst!

IntermediateFull instructions provided1 hour105

Calliope mini Schwerelosigkeits-Detektor

Things used in this project

Hardware components

Calliope mini

Story

Kann der Calliope mini feststellen, ob er auf der ISS oder auf der Erde ist? Also z. B. das hier machen?

Dieses Projekt wurde im Rahmen eines Kurses der Junior Uni Essen beim CalliopEO-Wettbewerb eingereicht.

Und die Aufgabe klingt verdächtig simpel. Aber woran soll der Mini erkennen, wo er ist? Temperatur, Licht, Luft, Lautstärke, all das kann ja innerhalb der Raumstation nicht komplett anders sein, immerhin müssen die Astronaut*innen dort leben können. Einzig (dauerhafte) Schwerelosigkeit, die gibt’s bei uns nicht!

So, wie Detektive beweisen wollen, dass der Mörder am Tatort war, wollen wir also einen Beweis dafür bekommen, dass der Calliope schwerelos war bzw. ist! Dafür braucht er bestimmt seine Sensoren! Nachdem Mikrofon, Thermometer und Co. mit Schwerelosigkeit nicht viel zu tun haben, bleibt irgendwann der Kombi-Sensor aus Magnetometer, Gyroskop und Beschleunigungsmesser als Kandidat übrig... Aber wer von den Dreien kann uns helfen?

Der Kompass würde auf der ISS sicher die Himmelsrichtung anzeigen, das Magnetfeld der Erde reicht noch viel weiter ins All. Das ließe sich aber auch mit Hilfe eines Flugzeugs simulieren, welches den Kurs der ISS "nachfliegt". Man könnte den Calliope auch einfach mit der Hand drehen. Kein Beweis also.
Der Lagesensor müsste auf der ISS für jede Erdumrundung einen vollständigen "Kusselkopf" registrieren, weil die ISS immer mit der selben Seite zur Erde zeigt. So könnte man einen Zähler für Erdumrundungen bauen, aber der Calliope könnte auch hier auf der Erde von Hand gedreht werden, das wäre leider auch kein Beweis.
Also der Beschleunigungssensor…? ;-)

Mal schauen, was der Calliope für eine Beschleunigung anzeigt, wenn er flach auf dem Tisch liegt…

Also das ist doch komisch! Da wird eine Beschleunigung von -1 g auf der z-Achse angezeigt, obwohl der Calliope einfach nur auf dem Tisch liegt! Was soll das denn?

Die Erklärung ist: Der Calliope würde sich ja schon bewegen, wenn der Tisch nicht im Weg wäre! Was der Beschleunigungssensor anzeigt, ist offenbar, dass der Mini durch den Tisch davon abgehalten wird, das zu tun, was er normalerweise tun würde, nämlich wie alles andere auch in Richtung Erdmittelpunkt zu fallen. Nebenbei: Sogar die ISS würde vom Himmel stürzen, wenn sie nicht so schnell im Kreis um die Erde fliegen würde. Nur dadurch wird sie genauso sehr von der Erde weggeschleudert, wie sie von ihr nach unten gezogen wird. Der Beschleunigungssensor misst also relativ zum freien Fall! Das können wir gut gebrauchen :-)

Aber um welche Richtung geht es jetzt: x, y oder z? Die Antwort: nicht eine einzelne davon, denn wenn man den Calliope drehen würde, wären sie ja vertauscht. Man muss alle drei nehmen und zusammenrechnen, und das macht der Block „Stärke“. Man könnte es sogar selbst ausrechnen und sehen, dass der Satz des Pythagoras doch für etwas gut ist ;-). Das hier passiert nämlich „hinter den Kulissen:

Damit ist die Lösung klar! Wenn wir bei einem ruhenden Calliope die Stärke der Beschleunigung anzeigen, bekommen wir auf der Erde 1000 milli-g (also 1 g) zu sehen. Bei Schwerelosigkeit müssten 0 milli-g gemessen werden. Nehmen wir ein bisschen Messtoleranz, z. B. 200 milli-g, also ein Fünftel der Erdgravitation, sieht das komplette Programm so aus:

Und mit diesem Grenzwert kann man das sogar auf der Erde testen. Wenn man den Calliope hochwirft und fallen lässt, ist er ja für einen Moment schwerelos! Er zeigt dann tatsächlich kurz „grün“ an. Lohnt sich, mal auszuprobieren (Auffangen nicht vergessen :-))! Auf der Erde leuchtet die LED ansonsten dauerhaft rot. Auf der ISS (aber nur dort!) müsste sie immer grün leuchten!

Alternativ zur Farb-LED könnte man auch im 5x5-Display den aktuellen g-Wert anzeigen, am besten gerundet auf ganze Zahlen, damit es nur eine einzige Ziffer ist. Normalerweise wird uns eine "1" angezeigt, beim Hochwerfen und Fallenlassen des Minis für eine kurze Zeit eine "0". Wenn wir ihn auffangen, manchmal auch eine "2", er wird ja dabei ziemlich stark abgebremst!

Oder noch schicker: Die Richtung der Schwerkraft in einem dreidimensionalen Koordinatensystem "plotten"! Auf der Erde zeigt die "Nadel" (so, wie ein Kompass nach Norden zeigt) immer nach "unten". Auf der ISS müsste nur der Punkt in der Mitte sichtbar sein:

Das sind jetzt einige Möglichkeiten und auch wenn ein Flug ins All für uns noch einige Zeit unerschwinglich bleiben wird: Solche Experiment bieten doch eine spannende Möglichkeit, auch auf der Erde an den Ausflügen der Menschen in den Weltraum teilzuhaben! Alle Programme sind im Anhang als Quelltext verfügbar.

...ein Update nachdem Matthias Maurer wieder auf der Erde gelandet ist und die Ergebnisse des Experiments vorliegen: Es hat tatsächlich geklappt! :-) Der Calliope mini hat wie vermutet Werte im niedrigen milli-g-Bereich auf allen drei Raumachsen gemessen und somit (annähernde) Schwerelosigkeit festgestellt:

Das Programm "gravity_iss_vs_erde.js" im Anhang enthält nun alle drei oben beschriebenen Anzeigen (3D-Plot, RGB-LED, Anzeige des g-Wertes), die sich mit Taste B umschalten lassen. Zusätzlich schaltet Taste A um zwischen den gerade "live" vom Calliope gemessen Werten und denen, die auf der ISS gemessen wurden und die im Programm ebenfalls gespeichert sind. So lässt sich quasi im "Playback" genau das sehen, was auch Matthias Maurer im Weltall angezeigt wurde! Das hier sind die unterschiedlichen "Modi" mit den entstehenden Anzeigen bei einem flach auf dem Tisch liegenden Mini:

Viel Spaß beim Ausprobieren!
Thorsten Kimmeskamp

let milliGX = 0 // Beschleunigung x-Achse
let milliGY = 0 // Beschleunigung y-Achse
let milliGZ = 0 // Beschleunigung z-Achse

input.setAccelerometerRange(AcceleratorRange.TwoG) // Empfindlichkeit auf 2 g einstellen

function zeigeX(wert: number) {	
	// uebergebenen Wert auf der x-Achse darstellen
	// (horizontal in der Mitte des Bildschirms):
	//
	// +-------+-------+-------+-------+-------+
	// | <= -2 |  -1   |   0   |   1   |  >= 2 |
	// +-------+-------+------------------------
	// | ..... | ..... | ..... | ..... | ..... |
	// | ..... | ..... | ..... | ..... | ..... |
	// | ###.. | .##.. | ..#.. | ..##. | ..### |
	// | ..... | ..... | ..... | ..... | ..... |
	// | ..... | ..... | ..... | ..... | ..... |
    // +-------+-------+-------+-------+-------+
	
	// mittleres Pixel in jedem Fall setzen
	led.plot(2, 2)

	// den Rest der Zeile loeschen
    led.unplot(0, 2)
    led.unplot(1, 2)
    led.unplot(3, 2)
    led.unplot(4, 2)
    
	// weitere Pixel rechts der Mitte setzen,
	// falls uebergebener Wert >= 1 bzw. >= 2
    if (wert >= 1) {
        led.plot(3, 2)
    }
    if (wert >= 2) {
        led.plot(4, 2)
    }
    
	// weitere Pixel links der Mitte setzen,
	// falls uebergebener Wert <= -1 bzw. <= -2	
	if (wert <= -1) {
        led.plot(1, 2)
    }
    if (wert <= -2) {
        led.plot(0, 2)
    }
}

function zeigeY(wert: number) {
	// uebergebenen Wert auf der y-Achse darstellen
	// (diagonal von links unten nach rechts oben):
	//
	// +-------+-------+-------+-------+-------+
	// | <= -2 |  -1   |   0   |   1   |  >= 2 |
	// +-------+-------+------------------------
	// | ..... | ..... | ..... | ..... | ....# |
	// | ..... | ..... | ..... | ...#. | ...#. |
	// | ..#.. | ..#.. | ..#.. | ..#.. | ..#.. |
	// | .#... | .#... | ..... | ..... | ..... |
	// | #.... | ..... | ..... | ..... | ..... |
    // +-------+-------+-------+-------+-------+
	
	// mittleres Pixel in jedem Fall setzen
    led.plot(2, 2)

	// den Rest der Diagonale loeschen
    led.unplot(4, 0)
    led.unplot(3, 1)
    led.unplot(1, 3)
    led.unplot(0, 4)

	// weitere Pixel rechts oberhalb der Mitte setzen,
	// falls uebergebener Wert >= 1 bzw. >= 2
    if (wert >= 1) {
        led.plot(3, 1)
    }
    if (wert >= 2) {
        led.plot(4, 0)
    }
	
	// weitere Pixel links unterhalb der Mitte setzen,
	// falls uebergebener Wert <= -1 bzw. <= -2	
    if (wert <= -1) {
        led.plot(1, 3)
    }
    if (wert <= -2) {
        led.plot(0, 4)
    }
}

function zeigeZ(wert: number) {
	// uebergebenen Wert auf der z-Achse darstellen
	// (vertikal in der Mitte des Bildschirms):
	//
	// +-------+-------+-------+-------+-------+
	// | <= -2 |  -1   |   0   |   1   |  >= 2 |
	// +-------+-------+------------------------
	// | ..... | ..... | ..... | ..... | ..#.. |
	// | ..... | ..... | ..... | ..#.. | ..#.. |
	// | ..#.. | ..#.. | ..#.. | ..#.. | ..#.. |
	// | ..#.. | ..#.. | ..... | ..... | ..... |
	// | ..#.. | ..... | ..... | ..... | ..... |
    // +-------+-------+-------+-------+-------+
	
	// mittleres Pixel in jedem Fall setzen
    led.plot(2, 2)

	// den Rest der Spalte loeschen
    led.unplot(2, 0)
    led.unplot(2, 1)
    led.unplot(2, 3)
    led.unplot(2, 4)

	// weitere Pixel oberhalb der Mitte setzen,
	// falls uebergebener Wert >= 1 bzw. >= 2
    if (wert >= 1) {
        led.plot(2, 1)
    }
    if (wert >= 2) {
        led.plot(2, 0)
    }
	
	// weitere Pixel unterhalb der Mitte setzen,
	// falls uebergebener Wert <= -1 bzw. <= -2	
    if (wert <= -1) {
        led.plot(2, 3)
    }
    if (wert <= -2) {
        led.plot(2, 4)
    }
}

function zeige3D(x: number, y: number, z:number) {
	// uebergebenen Vektor (x, y, z) im Koordinatensystem zeichnen:
	
	// Beispiele:
	// ----------
	
	// +-----------------------+------------------------+------------------------+
    // | (x = 2, y = 2, z = 0) | (x = 0, y = 0, z = -2) | (x = 1, y = -2, z = 1) |
	// +-----------------------+------------------------+------------------------+
	// |         ....#         |         .....          |         .....          |
	// |         ...#.         |         .....          |         ..#..          |
	// |         ..###         |         ..#..          |         ..##.          |
	// |         .....         |         ..#..          |         .#...          |
	// |         .....         |         ..#..          |         #....          |
	// +-----------------------+------------------------+------------------------+
		
	zeigeX(x)
    zeigeY(y)
    zeigeZ(z)
}

function zeigeKoord(milliGX: number, milliGY: number, milliGZ: number) {
	// ueberfuehrt in jeder der drei Raumdimensionen einen Wert in milli-g (milliGX, milliGY, milliGZ)
	// in eine ganzzahlige Skala von -2 bis 2 (px, py, pz) als Koordinate fuer die Anzeige am Bildschirm.

	// Die Grenzfaelle sind -600, -200, 200 und 600, so dass bei angenommenen Maximalwerten
	// von -1 g und +1 g jedes Element der Ziel-Skala einen gleich breiten Wertebereich von 400 milli-g abdeckt.
	// 
	// milli-g   :         -600      -200       200       600
	// Koordinate:     -2   )|[  -1   )|[   0   )|[   1   )|[    2
	//
	// Stellt diese Werte anschliessend in einem Koordinatensystem dar (Aufruf Funktion zeige3d)).
	// Beispiel: (milliGX, milliGY, milliGZ) = (314, -802, 200) -> zeige3d(1, -2,  1)

    let px = Math.trunc((milliGX + 1000) / (2000 / 5)) - 2
    let py = Math.trunc((milliGY + 1000) / (2000 / 5)) - 2
    let pz = Math.trunc((milliGZ + 1000) / (2000 / 5)) - 2
	
    zeige3D(px, py, pz)
}


basic.forever(function () {
    milliGX = input.acceleration(Dimension.X) // messe Beschleunigung x-Achse
    milliGY = input.acceleration(Dimension.Y) // messe Beschleunigung y-Achse
    milliGZ = input.acceleration(Dimension.Z) // messe Beschleunigung z-Achse
    
    zeigeKoord(milliGX, -milliGY, milliGZ)   // im Koordinatensystem anzeigen (y gespiegelt)
	// Normalerweise zeigt z nach oben, x nach rechts, y nach vorne. Bei y wirkt die Anzeige dann aber unnatuerlich.
})

let milliG = 0 // Staerke der Gesamtbeschleunigung (in milli-g)

input.setAccelerometerRange(AcceleratorRange.TwoG) // Empfindlichkeit auf 2 g einstellen

basic.forever(function () {
    milliG = input.acceleration(Dimension.Strength) // Staerke der Gesamtbeschleunigung messen
	
    if (milliG < 200) { // bei einem Wert unterhalb von 0,2 g Schwerelosigkeit unterstellen:
        basic.setLedColor(Colors.Green) // und die RGB-LED gruen faerben
    } else { // ansonsten:
        basic.setLedColor(Colors.Red) // RGB-LED rot faerben
    }
})

let milliGX = 0 // Beschleunigung x-Achse
let milliGY = 0 // Beschleunigung y-Achse
let milliGZ = 0 // Beschleunigung z-Achse
let milliG = 0 // // Gesamtstaerke

basic.forever(function () {
    milliGX = input.acceleration(Dimension.X) // messe Beschleunigung x-Achse
    milliGY = input.acceleration(Dimension.Y) // messe Beschleunigung y-Achse
    milliGZ = input.acceleration(Dimension.Z) // messe Beschleunigung z-Achse
    milliG = Math.sqrt(milliGX * milliGX + (milliGY * milliGY + milliGZ * milliGZ)) // berechne Gesamtstaerke
	
    basic.showNumber(Math.round(milliG / 1000)) // auf ganze Zahl gerundet in g anzeigen
})

let milliGX = 0 // Beschleunigung x-Achse
let milliGY = 0 // Beschleunigung y-Achse
let milliGZ = 0 // Beschleunigung z-Achse
let milliG = 0 // Gesamtstaerke

let playback = false // ISS-Messwerte oder aktuell gemessene Werte anzeigen
let i = 0 // Index fuer Array mit ISS-Messwerten
let anzeige = 0 // Art der Anzeige: 0 = 3D-Plot, 1 = RGB-LED, 2 = g-Wert gerundet

// ISS-Messwerte (Ausschnitt von 10 Sek.): [x0, y0, z0, x1, y1, z1, x2, y2, z2, x3, y3, z3...]
let messwerte_iss: number[] = [
54, 22, -10, 64, 24, 6, 64, 32, -10, 58, 20, 0, 58, 28, -2, 60, 36, -2, 64, 30, -10, 60, 22, -2, 54, 26, -2, 60, 24, -4,
60, 28, 14, 58, 24, -6, 58, 18, 10, 54, 20, -2, 54, 26, 12, 62, 26, -6, 64, 26, -4, 62, 22, 0, 62, 24, 0, 62, 22, 0,
62, 28, 6, 64, 26, 0, 58, 24, 16, 56, 32, 0, 58, 26, 2, 62, 18, 2, 54, 26, 22, 56, 28, -16, 60, 30, 0, 66, 22, -10,
60, 18, 14, 54, 26, -8, 58, 30, 6, 54, 16, 6, 62, 26, -12, 50, 24, 4, 54, 28, 0, 62, 28, -4, 60, 32, 10, 62, 8, -10,
62, 28, 4, 58, 24, -2, 56, 32, 8, 60, 24, 8, 56, 26, 4, 58, 22, 0, 56, 20, 2, 62, 24, 6, 58, 20, 16, 54, 24, 4,
56, 22, 12, 58, 26, 0, 58, 14, 10, 58, 30, 2, 58, 28, -4, 54, 18, 0, 66, 22, 6, 58, 22, 6, 56, 24, 0, 48, 38, 0,
62, 18, 0, 58, 36, 4, 58, 32, 2, 56, 26, 0, 60, 24, -2, 62, 30, 8, 64, 26, -4, 58, 26, 0, 62, 18, 0, 62, 24, 2,
54, 28, 6, 60, 22, -6, 56, 30, -8, 56, 24, 6, 54, 24, 4, 64, 26, -2, 60, 18, -2, 56, 16, 0, 64, 18, -6, 64, 18, 0,
58, 24, -2, 60, 28, 0, 60, 26, -10, 54, 28, 14, 58, 20, 10, 64, 18, 6, 48, 26, 0, 56, 16,-2, 54, 24, 12, 62, 34, 2,
56, 24, 4, 58, 34, 0, 56, 20, 0, 60, 30, 4, 60, 10, 6, 58, 30, 12, 54, 30, 2, 58, 26, 2, 60, 18, 4, 54, 32, -4
]

input.setAccelerometerRange(AcceleratorRange.TwoG) // Empfindlichkeit auf 2 g einstellen


input.onButtonPressed(Button.A, function () {
	// zwischen aktuellen und auf der ISS gemessenen Werten umschalten
	
    playback = !playback
})

input.onButtonPressed(Button.B, function () {
	// Art der Anzeige umschalten
	
    basic.clearScreen()
    basic.setLedColor(Colors.Off)
    if (anzeige < 2) {
        anzeige = anzeige + 1
    } else {
        anzeige = 0
    }
})


function zeigeX(wert: number) {	
	// uebergebenen Wert auf der x-Achse darstellen
	// (horizontal in der Mitte des Bildschirms):
	//
	// +-------+-------+-------+-------+-------+
	// | <= -2 |  -1   |   0   |   1   |  >= 2 |
	// +-------+-------+------------------------
	// | ..... | ..... | ..... | ..... | ..... |
	// | ..... | ..... | ..... | ..... | ..... |
	// | ###.. | .##.. | ..#.. | ..##. | ..### |
	// | ..... | ..... | ..... | ..... | ..... |
	// | ..... | ..... | ..... | ..... | ..... |
    // +-------+-------+-------+-------+-------+
	
	// mittleres Pixel in jedem Fall setzen
	led.plot(2, 2)

	// den Rest der Zeile loeschen
    led.unplot(0, 2)
    led.unplot(1, 2)
    led.unplot(3, 2)
    led.unplot(4, 2)
    
	// weitere Pixel rechts der Mitte setzen,
	// falls uebergebener Wert >= 1 bzw. >= 2
    if (wert >= 1) {
        led.plot(3, 2)
    }
    if (wert >= 2) {
        led.plot(4, 2)
    }
    
	// weitere Pixel links der Mitte setzen,
	// falls uebergebener Wert <= -1 bzw. <= -2	
	if (wert <= -1) {
        led.plot(1, 2)
    }
    if (wert <= -2) {
        led.plot(0, 2)
    }
}

function zeigeY(wert: number) {
	// uebergebenen Wert auf der y-Achse darstellen
	// (diagonal von links unten nach rechts oben):
	//
	// +-------+-------+-------+-------+-------+
	// | <= -2 |  -1   |   0   |   1   |  >= 2 |
	// +-------+-------+------------------------
	// | ..... | ..... | ..... | ..... | ....# |
	// | ..... | ..... | ..... | ...#. | ...#. |
	// | ..#.. | ..#.. | ..#.. | ..#.. | ..#.. |
	// | .#... | .#... | ..... | ..... | ..... |
	// | #.... | ..... | ..... | ..... | ..... |
    // +-------+-------+-------+-------+-------+
	
	// mittleres Pixel in jedem Fall setzen
    led.plot(2, 2)

	// den Rest der Diagonale loeschen
    led.unplot(4, 0)
    led.unplot(3, 1)
    led.unplot(1, 3)
    led.unplot(0, 4)

	// weitere Pixel rechts oberhalb der Mitte setzen,
	// falls uebergebener Wert >= 1 bzw. >= 2
    if (wert >= 1) {
        led.plot(3, 1)
    }
    if (wert >= 2) {
        led.plot(4, 0)
    }
	
	// weitere Pixel links unterhalb der Mitte setzen,
	// falls uebergebener Wert <= -1 bzw. <= -2	
    if (wert <= -1) {
        led.plot(1, 3)
    }
    if (wert <= -2) {
        led.plot(0, 4)
    }
}

function zeigeZ(wert: number) {
	// uebergebenen Wert auf der z-Achse darstellen
	// (vertikal in der Mitte des Bildschirms):
	//
	// +-------+-------+-------+-------+-------+
	// | <= -2 |  -1   |   0   |   1   |  >= 2 |
	// +-------+-------+------------------------
	// | ..... | ..... | ..... | ..... | ..#.. |
	// | ..... | ..... | ..... | ..#.. | ..#.. |
	// | ..#.. | ..#.. | ..#.. | ..#.. | ..#.. |
	// | ..#.. | ..#.. | ..... | ..... | ..... |
	// | ..#.. | ..... | ..... | ..... | ..... |
    // +-------+-------+-------+-------+-------+
	
	// mittleres Pixel in jedem Fall setzen
    led.plot(2, 2)

	// den Rest der Spalte loeschen
    led.unplot(2, 0)
    led.unplot(2, 1)
    led.unplot(2, 3)
    led.unplot(2, 4)

	// weitere Pixel oberhalb der Mitte setzen,
	// falls uebergebener Wert >= 1 bzw. >= 2
    if (wert >= 1) {
        led.plot(2, 1)
    }
    if (wert >= 2) {
        led.plot(2, 0)
    }
	
	// weitere Pixel unterhalb der Mitte setzen,
	// falls uebergebener Wert <= -1 bzw. <= -2	
    if (wert <= -1) {
        led.plot(2, 3)
    }
    if (wert <= -2) {
        led.plot(2, 4)
    }
}

function zeige3D(x: number, y: number, z:number) {
	// uebergebenen Vektor (x, y, z) im Koordinatensystem zeichnen:
	
	// Beispiele:
	// ----------
	
	// +-----------------------+------------------------+------------------------+
    // | (x = 2, y = 2, z = 0) | (x = 0, y = 0, z = -2) | (x = 1, y = -2, z = 1) |
	// +-----------------------+------------------------+------------------------+
	// |         ....#         |         .....          |         .....          |
	// |         ...#.         |         .....          |         ..#..          |
	// |         ..###         |         ..#..          |         ..##.          |
	// |         .....         |         ..#..          |         .#...          |
	// |         .....         |         ..#..          |         #....          |
	// +-----------------------+------------------------+------------------------+
		
	zeigeX(x)
    zeigeY(y)
    zeigeZ(z)
}

function zeigeKoord(milliGX: number, milliGY: number, milliGZ: number) {
	// ueberfuehrt in jeder der drei Raumdimensionen einen Wert in milli-g (milliGX, milliGY, milliGZ)
	// in eine ganzzahlige Skala von -2 bis 2 (px, py, pz) als Koordinate fuer die Anzeige am Bildschirm.

	// Die Grenzfaelle sind -600, -200, 200 und 600, so dass bei angenommenen Maximalwerten
	// von -1 g und +1 g jedes Element der Ziel-Skala einen gleich breiten Wertebereich von 400 milli-g abdeckt.
	// 
	// milli-g   :         -600      -200       200       600
	// Koordinate:     -2   )|[  -1   )|[   0   )|[   1   )|[    2
	//
	// Stellt diese Werte anschliessend in einem Koordinatensystem dar (Aufruf Funktion zeige3d)).
	// Beispiel: (milliGX, milliGY, milliGZ) = (314, -802, 200) -> zeige3d(1, -2,  1)

    let px = Math.trunc((milliGX + 1000) / (2000 / 5)) - 2
    let py = Math.trunc((milliGY + 1000) / (2000 / 5)) - 2
    let pz = Math.trunc((milliGZ + 1000) / (2000 / 5)) - 2
	
    zeige3D(px, py, pz)
}


basic.forever(function () {
    if (playback) {
		milliGX = messwerte_iss[3*i] // lese Beschleunigung x-Achse aus auf der ISS gespeicherten Daten
        milliGY = messwerte_iss[3*i+1] // lese Beschleunigung y-Achse aus auf der ISS gespeicherten Daten
        milliGZ = messwerte_iss[3*i+2] // lese Beschleunigung z-Achse aus auf der ISS gespeicherten Daten
        if (i < messwerte_iss.length/3-1) {
            i++ // naechsten Datensatz auswaehlen
        } else {
            i = 0 // am Ende zurueck zum ersten springen
        }
    } else {
        milliGX = input.acceleration(Dimension.X) // messe Beschleunigung x-Achse
		milliGY = input.acceleration(Dimension.Y) // messe Beschleunigung y-Achse
		milliGZ = input.acceleration(Dimension.Z) // messe Beschleunigung z-Achse
    }
    milliG = Math.sqrt(milliGX * milliGX + (milliGY * milliGY + milliGZ * milliGZ)) // berechne Gesamtstaerke
    
    if (anzeige == 0) { // 3D-Plot
		zeigeKoord(milliGX, -milliGY, milliGZ)   // im Koordinatensystem anzeigen (y gespiegelt)
		// Normalerweise zeigt z nach oben, x nach rechts, y nach vorne. Bei y wirkt die Anzeige dann aber unnatuerlich.
    } else if (anzeige == 1) { // RGB-LED
        if (milliG < 200) { // bei einem Wert unterhalb von 0,2 g Schwerelosigkeit unterstellen:
            basic.setLedColor(Colors.Green) // und die RGB-LED gruen faerben
        } else { // ansonsten:
            basic.setLedColor(Colors.Red) // RGB-LED rot faerben
        }
    } else if (anzeige == 2) { // g-Wert gerundet
        basic.showNumber(Math.round(milliG / 1000)) // auf ganze Zahl gerundet in g anzeigen
    }
})

Credits

Thorsten Kimmeskamp

19 projects • 12 followers

Calliope mini Schwerelosigkeits-Detektor

Things used in this project

Hardware components

Story

Code

gravity_3d

gravity_led

gravity_printg

gravity_iss_vs_erde

Credits

Thorsten Kimmeskamp

Comments

Embed the widget on your own site

Calliope mini Schwerelosigkeits-Detektor

Calliope mini Schwerelosigkeits-Detektor

Things used in this project

Hardware components

Story

Code

gravity_3d

gravity_led

gravity_printg

gravity_iss_vs_erde

Credits

Thorsten Kimmeskamp

Comments

Related channels and tags