Sensoren des Calliope

Sensoren sind Bauteile des Calliope, die Licht, Töne, Temperatur, Lage, Bewegung oder Stromsignale messen können.

Strom-Sensor

Am Calliope gibt es außen 6 Stromanschlüsse. Oben rechts ist der Pluspol mit einer Spannung von 3,3 Volt gegenüber dem Minuspol oben links.

Wenn du mit der einen Hand den Minuspol und gleichzeitig mit der einen Hand einen der Anschlüsse 0 bis 3 berührst, dann kann der Calliope einen kleinen Strom messen, der durch dich hindurch fließt und bemerkt damit, dass man diese Ansschlüsse berührt hat (das ist völlig ungefährlich, weil die Spannung sehr klein ist: nur 3 Volt).

Das dargestellte Programm muss jetzt im Editor geschrieben werden. Du könntest dazu die Code-Blöcke, die oben abgebildet sind, abschreiben. Leichter geht es, wenn du den folgenden JavaScript-Code in den Calliope-Editor wie folgt kopierst:

Erstelle ein neues Projekt im Editor, indem du auf Projekte - Neues Projekt klickst und dann rechts auf JavaScript klickst. Du solltest folgendes sehen:

Ersetze den vorhandenen JavaScript-Code mit dem folgenden Code. Markiere dazu den unten stehenden Code und drücke die Tasten Strg und c gleichzeitig, der Code wird in den Zwischenspeicher kopiert. Klicke dann in den Editor, drücke dann Strg und a gleichzeitig, um den vorhandenen Code zu markieren und drücke dann Strg und v um den neuen Code einzufügen.

input.onPinPressed(TouchPin.P0, () => {
    basic.showNumber(0)
})
input.onPinPressed(TouchPin.P1, () => {
    basic.showNumber(1)
    music.playTone(262, music.beat(BeatFraction.Whole))
})
input.onPinPressed(TouchPin.P2, () => {
    basic.showNumber(2)
    music.playTone(262, music.beat(BeatFraction.Whole))
    music.rest(music.beat(BeatFraction.Whole))
    music.playTone(294, music.beat(BeatFraction.Whole))
})
input.onPinPressed(TouchPin.P3, () => {
    basic.showNumber(3)
    music.playTone(262, music.beat(BeatFraction.Whole))
    music.rest(music.beat(BeatFraction.Whole))
    music.playTone(294, music.beat(BeatFraction.Whole))
    music.rest(music.beat(BeatFraction.Whole))
    music.playTone(330, music.beat(BeatFraction.Whole))
})

Kopiere das Programm, wie du bereits gelernt hast, auf den Calliope.

Halte mit dem Daumen und dem Zeigefinger der einen Hand den Minuspol umschlossen und berühre mit einem Finger der anderen Hand kurz einen der Anschlüsse 0 bis 3. Je nachdem welchen Anschluß du berührst, sollte die Zahl des Anschlusses auf der LED-Anzeige angezeigt werden und Töne erklingen.

input.onPinPressed(TouchPin.P0, () => {
    basic.showLeds(`
        . # . # .
        . . . . .
        . . . . .
        . # # # .
        . # . # .
        `)
})
input.onPinPressed(TouchPin.P1, () => {
    basic.showLeds(`
        . # . # .
        . . . . .
        . . . . .
        . # # # .
        . . . . .
        `)
})
input.onPinPressed(TouchPin.P3, () => {
    basic.showLeds(`
        . # . # .
        . . . . .
        # . . . #
        . # # # .
        . . . . .
        `)
})
input.onPinPressed(TouchPin.P2, () => {
    basic.showLeds(`
        . # . # .
        . . . . .
        # . . . #
        # . . . #
        . # # # .
        `)
})
    

Schall-Sensor

Der Schall-Sensor ist ein Mikrofon. Damit kannst du die Lautstärke in einem Raum messen.

Du kannst dir auch gerne den Quellcode kopieren und in den JavaScript-Editor des Calliope einfügen:

basic.forever(() => {
    basic.showNumber(pins.analogReadPin(AnalogPin.MIC))
    if (pins.analogReadPin(AnalogPin.MIC) > 520) {
        basic.setLedColor(Colors.Red)
    } else {
        basic.setLedColor(Colors.Green)
    }
})

Wenn die Raumlautstärke zu groß wird, schaltet die RGB-LED von der Farbe grün zur Farbe rot.

basic.forever(() => {
  if (pins.analogReadPin(AnalogPin.MIC) > 600) {
      basic.setLedColor(basic.rgbw(
      255,
      255,
      255,
      0
      ))
      music.beginMelody(music.builtInMelody(Melodies.Baddy), MelodyOptions.Once)
    }
})
    

Temperatur-Sensor

Der Temperatur-Sensor (Thermometer) steckt im Prozessor des Calliope. Wenn du deinen Finger auf den Prozessor legst, wird dieser wärmer und die gemessene Temperatur sollte ansteigen.

Erklärung:

• Wenn der Knopf "A" gedrückt wird, dann zeige in der LED-Anzeige die aktuelle Temperatur an, welche der Temperatur-Sensor misst.
• Wiederhole ständig: Wenn die gemessene Temperatur größer als 28 ist, dann lasse die RGB-LED blau leuchten, sonst lasse sie gelb leuchten.

Wenn du das Programm auf dem "echten" Calliope gestartet hast, drücke einmal kurz auf die Taste "A" und merke dir die Zahl, die auf dem Display angezeigt wird. Die von dir abgelesene Zahl ist der Messwert des Calliope für die Temperatur. Gib anstelle des Wertes 28 in deinem Programm einen Wert ein, der etwas größer ist, als die Temperatur, die du gemessen hast.

Wenn du das mit deinem Wert angepasste Programm auf den Calliope übertragen hast, sollte die RGB-LED gelb leuchten. Wenn du den Prozessor mit einem Finger erwärmst, sollte die RGB-LED ihre Farbe in blau ändern, denn der Prozessor wird dadurch wärmer.

basic.forever(() => {
    if (input.temperature() > 26) {
        basic.showLeds(`
            . . # . .
            . . # . .
            . . # . .
            . . . . .
            . . # . .
            `)
        basic.showLeds(`
            . . . . .
            . . . . .
            . . . . .
            . . . . .
            . . . . .
            `)
        basic.showLeds(`
            . . # . .
            . . # . .
            . . # . .
            . . . . .
            . . # . .
            `)
        music.beginMelody(music.builtInMelody(Melodies.BaDing), MelodyOptions.Once)
    }
})
    

Zeit-Sensor

Der Zeit-Sensor (Stoppuhr) steckt im Prozessor des Calliope. Er misst die Zeit, die seit dem Start des Programms vergangen ist. Um den Zeitsensor wieder auf Null zu setzen, musst du den Reset-Knopf neben dem Micro-USB-Anschluss drücken.

Du kannst dir auch gerne den Quellcode kopieren und in den JavaScript-Editor des Calliope einfügen:

input.onButtonPressed(Button.A, () => {
    basic.showNumber(input.runningTime())
})
basic.forever(() => {
    if (input.runningTime() > 0 && input.runningTime() < 1500) {
        basic.setLedColor(Colors.Red)
    }
    if (input.runningTime() > 1500 && input.runningTime() < 3000) {
        basic.setLedColor(Colors.Orange)
    }
    if (input.runningTime() > 3000 && input.runningTime() < 4500) {
        basic.setLedColor(Colors.Yellow)
    }
    if (input.runningTime() > 4500 && input.runningTime() < 6000) {
        basic.setLedColor(Colors.Green)
    }
    if (input.runningTime() > 6000 && input.runningTime() < 7500) {
        basic.setLedColor(Colors.Blue)
    }
    if (input.runningTime() > 7500) {
        basic.setLedColor(Colors.Indigo)
    }
})

Erklärung:

• Wenn der Knopf "A" gedrückt wird, dann zeige in der LED-Anzeige die seit dem Programmstart vergangen ist an.
• Wiederhole ständig: Wenn die gemessene Zeit zwischen 0 und 1500 Millisekunden (= 1,5 Sekunden) ist, dann lasse die RGB-LED blau leuchten,... Wenn die gemessene Zeit größer als 7500 Millisekunden (= 7,5 Sekunden) ist, dann lasse die RGB-LED indigo leuchten.

 
let abweichung = 0
let zeitunterschied = 0
let stopzeit = 0
let startzeit = 0
let zahl = 0
input.onButtonPressed(Button.A, () => {
    startzeit = input.runningTime()
})
input.onButtonPressed(Button.B, () => {
    stopzeit = input.runningTime()
    zeitunterschied = stopzeit - startzeit
    abweichung = zahl * 1000 - zeitunterschied
    if (Math.abs(abweichung) < 500) {
        basic.setLedColor(Colors.Green)
    } else {
        basic.setLedColor(Colors.Red)
    }
})
zahl = Math.random(6)
if (zahl == 0) {
    zahl = 1
}
basic.showNumber(zahl)
    

Lage-Sensor

Im Calliope ist ein Lage-Sensor eingebaut, mit dem man den Calliope als Wasserwaage nutzen kann.

Du kannst dir auch gerne den Quellcode herunterladen und in den JavaScript-Editor des Calliope einfügen:

        let neigung = 0
        neigung = 0
        basic.forever(() => {
            neigung = input.rotation(Rotation.Pitch)
            if (Math.abs(neigung) > 15) {
                basic.setLedColor(Colors.Red)
            } else {
                basic.setLedColor(Colors.Green)
            }
        })

Wenn du das Programm auf den Calliope übertragen hast, leuchtet die RGB-LED grün solange der Calliope waagrecht gehalten wird. Wenn du ihn um die Achse zwischen den Anschlüssen 0 und 3 drehst, dann ändert sich die LED-Farbe auf rot, denn der Lagesensor erkennt, dass der Calliope nicht mehr horizontal ausgerichtet ist.

 
let neigung2 = 0
let neigung1 = 0
basic.forever(() => {
    neigung1 = input.rotation(Rotation.Pitch)
    neigung2 = input.rotation(Rotation.Roll)
    if (Math.abs(neigung1) < 15 && Math.abs(neigung2) < 15) {
        basic.showLeds(`
            . . . . .
            . . . . .
            . . . . .
            . . . . .
            . . . . .
            `)
    } else {
        music.playTone(262, music.beat(BeatFraction.Whole))
        basic.showLeds(`
            . . # . .
            . . # . .
            . . # . .
            . . . . .
            . . # . .
            `)
    }
})
    

Magnetfeld-Sensor

Im Calliope ist ein Magnetfeld-Sensor eingebaut, mit dem man den Calliope als Kompass nutzen kann.

Du kannst dir auch gerne den Quellcode kopieren und in den JavaScript-Editor des Calliope einfügen:

basic.forever(() => {
    if (input.compassHeading() > 315 && input.compassHeading() < 360 || input.compassHeading() > 0 && input.compassHeading() < 45) {
        basic.setLedColor(Colors.Red)
        basic.showString("N")
    }
    if (input.compassHeading() > 45 && input.compassHeading() < 135) {
        basic.setLedColor(Colors.Yellow)
        basic.showString("O")
    }
    if (input.compassHeading() > 135 && input.compassHeading() < 225) {
        basic.setLedColor(Colors.Green)
        basic.showString("S")
    }
    if (input.compassHeading() > 225 && input.compassHeading() < 315) {
        basic.setLedColor(Colors.Blue)
        basic.showString("W")
    }
})

Wenn du das Programm auf den Calliope übertragen hast, erkennt der Calliope, dass du den Magnetfeld-Sensor nutzen möchtest, da du im Programm die Kompassausrichtung abfragst. Bevor der Calliope die Himmelsrichtung erkennt, muss der Magnetfeldsensor erst kalibriert werden.

Dazu gehst du wie folgt vor:

• Warte ab, bis der Calliope folgende Meldung auf der LED-Anzeige ausgegeben hat: DRAW A CIRCLE = male einen Kreis.
• Wenn ein einzelner Punkt in der Mitte der LED-Anzeige erscheint, drehe den Calliope so um seine Achse, dass die äußeren LEDs wie ein Kreis leuchten. Wenn du das Ziel erreicht hast, wird kurz ein Smiley angezeigt.

• Jetzt ist der Magnetfeld-Sensor kalibriert und du kannst den Calliope als Kompass nutzen.
• Das Beispielprogramm zeigt je nach Himmelsrichtung einen der Buchstaben "N", "O", "S", "W" an und ändert je nach Himmelsrichtung der Farbe der LED

 
basic.forever(() => {
    if (input.compassHeading() > 338 && input.compassHeading() <= 360 || input.compassHeading() > 0 && input.compassHeading() <= 23) {
        basic.setLedColor(Colors.Red)
        basic.showString("N")
        music.playTone(131, music.beat(BeatFraction.Whole))
    }
    if (input.compassHeading() > 23 && input.compassHeading() <= 68) {
        basic.setLedColor(Colors.Orange)
        basic.showString("NO")
        music.playTone(175, music.beat(BeatFraction.Whole))
    }
    if (input.compassHeading() > 68 && input.compassHeading() <= 113) {
        basic.setLedColor(Colors.Yellow)
        basic.showString("O")
        music.playTone(247, music.beat(BeatFraction.Whole))
    }
    if (input.compassHeading() > 113 && input.compassHeading() <= 158) {
        basic.setLedColor(Colors.Indigo)
        basic.showString("SO")
        music.playTone(330, music.beat(BeatFraction.Whole))
    }
    if (input.compassHeading() > 158 && input.compassHeading() <= 203) {
        basic.setLedColor(Colors.Blue)
        basic.showString("S")
        music.playTone(440, music.beat(BeatFraction.Whole))
    }
    if (input.compassHeading() > 203 && input.compassHeading() <= 248) {
        basic.setLedColor(Colors.Violet)
        basic.showString("SW")
        music.playTone(587, music.beat(BeatFraction.Whole))
    }
    if (input.compassHeading() > 248 && input.compassHeading() <= 293) {
        basic.setLedColor(Colors.Blue)
        basic.showString("W")
        music.playTone(740, music.beat(BeatFraction.Whole))
    }
    if (input.compassHeading() > 293 && input.compassHeading() <= 338) {
        basic.setLedColor(Colors.Purple)
        basic.showString("NW")
        music.playTone(988, music.beat(BeatFraction.Whole))
    }
})
    

Beschleunigungs-Sensor

Im Calliope ist ein Beschleunigungs-Sensor eingebaut, der erkennt, wenn der Calliope seine Geschwindigkeit ändert. Ein solcher Sensor löst z.B. in Autos den Airbag aus, wenn das Abbremsen so heftig ist, dass der Sensor davon ausgehen muss, dass gerade ein Unfall geschieht.

Du kannst dir auch gerne den Quellcode kopieren und in den JavaScript-Editor des Calliope einfügen:

let beschleunigung = 0
beschleunigung = 0
basic.forever(() => {
    beschleunigung = input.acceleration(Dimension.X)
    if (Math.abs(beschleunigung) > 200) {
        basic.setLedColor(Colors.Red)
        music.playTone(523, music.beat(BeatFraction.Double))
    } else {
        basic.setLedColor(Colors.Green)
    }
})

Bewege nun den Calliope. Wenn du ihn langsam genug bewegst, bleibt die RGB-LED grün. Sobald du den Calliope zu schnell bewegst wird ein Ton ausgegeben und die Farbe der LED wechselt auf rot. Im Auto wäre jetzt der Airbag ausgelöst worden.

 
let beschleunigung = 0
beschleunigung = 0
basic.forever(() => {
    beschleunigung = input.acceleration(Dimension.X)
    if (Math.abs(beschleunigung) > 100) {
        basic.showLeds(`
            . . . . .
            . . . . .
            . . # . .
            . . . . .
            . . . . .
            `)
        music.playTone(175, music.beat(BeatFraction.Sixteenth))
        basic.showLeds(`
            . . . . .
            . # # # .
            . # . # .
            . # # # .
            . . . . .
            `)
        music.playTone(349, music.beat(BeatFraction.Sixteenth))
        basic.showLeds(`
            # # # # #
            # . . . #
            # . # . #
            # . . . #
            # # # # #
            `)
        music.playTone(698, music.beat(BeatFraction.Sixteenth))
    } else {
        basic.showLeds(`
            . . . . .
            . . . . .
            . . . . .
            . . . . .
            . . . . .
            `)
    }
})
    

Licht-Sensor

Der Lichtsensor ist die LED-Anzeige mit den 25 LEDs. Eine LED kann nicht nur Licht aussenden, sondern mit geeigneter Elektronik kann eine LED auch messen, ob auf sie Licht scheint.

Erklärung:

• Wenn der Knopf "A" gedrückt wird, dann zeige in der LED-Anzeige die aktuelle Lichtstärke an, welche der LED-Sensor misst.
• Wiederhole ständig: Wenn die gemessene Lichtstärke größer als 50 ist, dann lasse die RGB-LED rot leuchten, sonst lasse sie grün leuchten.

Wenn du das Programm auf dem "echten" Calliope gestartet hast, drücke einmal kurz auf die Taste "A" und merke dir die Zahl, die auf dem Display angezeigt wird. Die von dir abgelesene Zahl ist der Messwert des Calliope für die Lichtstärke in deinem Raum. Gib anstelle des Wertes 50 in deinem Programm einen Wert ein, der etwas kleiner ist, als die Lichtstärke, die du gemessen hast.

Wenn du das mit deinem Wert angepasste Programm auf den Calliope übertragen hast, sollte die RGB-LED rot leuchten. Wenn du die LED-Anzeige z.B. mit einem Finger verdunkelst, sollte die RGB-LED ihre Farbe in grün ändern, denn du hast den Lichtsensor verdunkelt.