Thermometer-Spiel für zwei Spieler

Hier ist eine Zusammenfassung von MINT-Winteraktivität: Ein Picobricks-Mainboard mit Temperatur- und Feuchtigkeitssensoren misst die Umgebungstemperatur für Sie, hält sie aber vor den Spielern geheim. Dann geben die Spieler abwechselnd ihre Temperaturvorhersagen ein. Der nächste Tipp gewinnt das Spiel.

Hallo, zukünftige Meteorologen! Ich möchte Ihnen ein großartiges (im wahrsten Sinne des Wortes!) Projekt vorstellen, das nicht nur Spaß macht, sondern auch lehrreich ist: Thermometer Game powered by PicoBricks. Dieses Spiel ist die perfekte Mischung aus Technologie, Lernen und natürlich freundlichem Wettbewerb. Perfekt für kalte Wintertage, dieses Spiel ist ein MINT-Winteraktivität Das wärmt die Gehirnzellen richtig auf!

Warum dieses Spiel?

Lehrreich: Es ist eine praktische Möglichkeit, etwas über Sensoren und ihre Interaktion mit der Umgebung zu lernen.
Saisonaler Spaß: Dieses Spiel eignet sich besonders gut für den Winter und verleiht langen, kalten Tagen einen MINT-Touch.
Einheitenumrechnung leicht gemacht: Spieler lernen den Unterschied zwischen Celsius und Fahrenheit auf praktische und ansprechende Weise kennen.

Schaltplan

Wie man ... macht? Schritt für Schritt Anleitung

Schritt 1

Deine erste Mission? Installieren Sie den erforderlichen Code in Ihren PicoBricks. Sobald das erledigt ist, beginnt der Spaß.

Machen Sie sich keine Sorgen, wenn Sie nicht wissen, wie es geht. Um zu lernen, wie man Picobricks mit BricksIDE, ThonnyPhyton und Arduino C verwendet: Wie verwendet man Picobricks?

BricksIDE

Hier ist Bricks GEHT Code. Laden Sie den Code herunter und installieren Sie ihn auf Ihren PicoBricks.

Laden Sie den BricksIDE-Code herunter

MicroBlocks-Code

ThonnyPhyton-Code


von Zeit zu Zeit Schlaf importieren
Vom Maschinenimport Pin,PWM,I2C
Von Picobricks importieren Sie WS2812, DHT11, SSD1306_I2C
Importmaschine
Importzeit
Mathematik importieren



ws2812 = WS2812(6, Helligkeit = 1)
pin_button = machine.Pin(10, machine.Pin.IN)
dht_sensor = DHT11(Pin(11))

dht_read_time = time.time()

Temperatur = 0

def getTemp():
   globale dht_read_time
   globale Temp
   wenn time.time() - dht_read_time >= 3:
       dht_read_time = time.time()
       versuchen:
           dht_sensor.measure()
           temp = dht_sensor.temperatur
       außer Ausnahme als e:
           passieren
   Rücklauftemp

Mathematik importieren
pot = machine.ADC(26)
i2c = I2C(0, scl=Pin(5), sda=Pin(4), freq=200000)
oled = SSD1306_I2C(128, 64, i2c, addr=0x3c)

def SetTempF():
    global tempUnite, TemperatureValue, Player1Guess, Player2Guess, Player1Result, Counter, Player2Result
    tempUnite = Round(round( pot.read_u16() - 0 ) * ( 2 - 1 ) / ( 65535 - 0 ) + 1)
    wenn tempUnite == (1):
        oled.text("{}".format("celsius"), 20, 25)
    elif tempUnite == (2):
        oled.text("{}".format("Fahrenheit"), 20, 25)
    oled.show()
    oled.fill(0)

def start():
    global tempUnite, TemperatureValue, Player1Guess, Player2Guess, Player1Result, Counter, Player2Result
    oled.text("{}".format("Set the "), 20, 10)
    oled.text("{}".format("temperature"), 20, 20)
    oled.text("{}".format("unit by POT"), 20, 30)
    oled.show()

def countDown():
    global tempUnite, TemperatureValue, Player1Guess, Player2Guess, Player1Result, Counter, Player2Result
    für count in range((4)):
        oled.fill(0)
        oled.text("{}".format(counter), 55, 32)
        oled.show()
        Zähler -= 1
        time.sleep((1))


    oled.fill(0)
    oled.show()
    Zähler = 0

pin_led = machine.Pin(7, machine.Pin.OUT)
Summer = PWM(Pin(20))

def buttonFunc():
    global tempUnite, TemperatureValue, Player1Guess, Player2Guess, Player1Result, Counter, Player2Result
    pin_led.on()
    Buzzer.freq(300)
    Buzzer.duty_u16(100)
    Schlaf(0,25)
    Buzzer.duty_u16(0)
    pin_led.off()

def player1():
    global tempUnite, TemperatureValue, Player1Guess, Player2Guess, Player1Result, Counter, Player2Result
    while (pin_button.value()) == (0) und counter == (0):
        player1guess = Round(round( pot.read_u16() - 0 ) * ( 212 - -20 ) / ( 65535 - 0 ) + -20)
        oled.text("{}".format("Player 1: "), 5, 25)
        oled.text("{}".format(player1guess), 85, 25)
        oled.show()
        oled.fill(0)
        print(temperaturWert)

    buttonFunc()
    Zähler += 1
    wenn (temperatureValue > 0) und (player1guess > 0):
        player1result = TemperatureValue - player1guess
    elif (temperatureValue > 0) und (player1guess < 0):
        player1result = TemperatureValue + (-1) * player1guess
    elif (temperatureValue < 0) und (player1guess > 0):
        player1result = (-1) * TemperatureValue + player1guess
    elif (temperatureValue < 0) und (player1guess < 0):
        player1result = (-1) * TemperatureValue - (-1) * player1guess
    wenn player1result < 0:
        Spieler1Ergebnis = Spieler1Ergebnis * (-1)
    print(temperaturWert)
    print(player1result)

def player2():
    global tempUnite, TemperatureValue, Player1Guess, Player2Guess, Player1Result, Counter, Player2Result
    while (pin_button.value()) == (0) und counter == (1):
        player2guess = Round(round( pot.read_u16() - 0 ) * ( 212 - -20 ) / ( 65535 - 0 ) + -20)
        oled.text("{}".format("Player 2: "), 5, 25)
        oled.text("{}".format(player2guess), 85, 25)
        oled.show()
        oled.fill(0)

    print(temperaturWert)
    buttonFunc()
    Zähler += 1
    wenn (temperatureValue > 0) und (player2guess > 0):
        player2result = TemperatureValue - player2guess
    elif (temperatureValue > 0) und (player2guess < 0):
        player2result = TemperatureValue + (-1) * player2guess
    elif (temperatureValue < 0) und (player2guess > 0):
        player2result = (-1) * TemperatureValue + player2guess
    elif (temperatureValue < 0) und (player2guess < 0):
        player2result = (-1) * TemperatureValue - (-1) * player2guess
    wenn player2result < 0:
        Spieler2Ergebnis = Spieler2Ergebnis * (-1)

def control():
    global tempUnite, TemperatureValue, Player1Guess, Player2Guess, Player1Result, Counter, Player2Result
    oled.fill(0)
    oled.text("{}".format("WINNER"), 40, 0)
    wenn Spieler1Ergebnis >= Spieler2Ergebnis:
        oled.text("{}".format("Player 2"), 40, 20)
        ws2812.pixels_fill((51, 204, 0))
        ws2812.pixels_show()
    elif player1result <= player2result:
        oled.text("{}".format("Player1"), 40, 20)
        ws2812.pixels_fill((51, 204, 0))
        ws2812.pixels_show()
    anders:
        oled.fill(0)
        oled.text("{}".format("scoreless"), 40, 20)
    oled.text("{}".format("Temp:"), 10, 40)
    oled.text("{}".format(temperatureValue), 60, 40)
    wenn tempUnite == (1):
        oled.text("{}".format("Celcius"), 20, 50)
    elif tempUnite == (2):
        oled.text("{}".format("Fahrenheit"), 20, 50)
    oled.show()
    Zähler += 1

ws2812.pixels_fill((0 ,0 ,0 ))
ws2812.pixels_show()
Temperaturwert = 0
Spieler1Ergebnis = 0
player2result = 0
tempUnite = 0
Zähler = 3
player2guess = 0
player1guess = 0
while (pin_button.value()) == (0):
    Start()
    print(getTemp())

time.sleep((0.3))
buttonFunc()
while (pin_button.value()) == (0):
    oled.fill(0)
    SetTempF()
    print(getTemp())

buttonFunc()
wenn tempUnite == (1):
    TemperatureValue = getTemp()
elif tempUnite == (2):
    Temperaturwert = ((9) * (getTemp())) / (5) + (32)
Countdown()
print(temperaturWert)
Spieler1()
time.sleep((0.5))
Spieler2()
Kontrolle()

Arduino C-Code


#enthalten
#include „ACROBOTIC_SSD1306.h“
#enthalten
#enthalten

#PIN 6 festlegen
#define NUMPIXEL 1

#define DHTPIN 11
#define DHTTYPE DHT11

#POTENTIOMETER 26 definieren
#define BUTTON_PIN 10

#SUMMER 20 definieren

#define LED 7

DHT dht(DHTPIN, DHTTYPE);
Adafruit_NeoPixel Pixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);


int Temperaturwert = 0;
int player1result = 0;
int player2result = 0;
int tempUnite = 0;
int counter = 3;
int player1guess = 0;
int player2guess = 0;


void setup() {

  Serial.begin(9600);
  Wire.begin();
  oled.init();
  oled.clearDisplay();
  pixels.begin();
  pixels.clear();
  pinMode(BUTTON_PIN, INPUT);
  pinMode(POTENTIOMETER, EINGANG);
  pinMode(SUMMER, AUSGANG);
  pinMode(LED, AUSGANG);
}

void loop() {
  while (digitalRead(BUTTON_PIN) == 0) {
    oled.setTextXY(1, 2);
    oled.putString("Setzen Sie das ");
    oled.setTextXY(2, 2);
    oled.putString("temperature");
    oled.setTextXY(3, 2);
    oled.putString("unit by POT");
    getTemp();
  }

  Verzögerung (300);
  buttonFunc();

  oled.clearDisplay();
  SetTempF();
  getTemp();

  buttonFunc();

  if (tempUnite > 1023 / 2 ) {
    Temperaturwert = getTemp();
  }
  if (tempUnite <= 2) {
    Temperaturwert = ((9) * (getTemp())) / (5) + (32);
  }

  Countdown();

  Spieler1();
  Verzögerung (500);
  Spieler2();
  
  Kontrolle();
}

int getTemp() {
  TemperatureValue = dht.readTemperature();
  Serial.println(temperatureValue);
  Rückgabetemperaturwert;
}

void buttonFunc() {
  for (int i = 0 ; i < 4 ; i++) {
    digitalWrite(LED, HIGH);
    Ton (SUMMER, 500);
    Verzögerung (500);
    noTone(SUMMER);
    digitalWrite(LED, LOW);
  }
}

void SetTempF() {
  while (digitalRead(BUTTON_PIN) == 0) {
    tempUnite = map( analogRead(POTENTIOMETER), 0, 1023, 0, 1);
    if (tempUnite == 0 ) {
      oled.setTextXY(3, 2);
      oled.putString("Celsius");
    }
    if (tempUnite == 1 ) {
      oled.setTextXY(3, 2);
      oled.putString("Fahrenheit");
    }
    Verzögerung (300);
    oled.clearDisplay();
  }
}

void countDown() {
  for (int i = 0 ; i < 4 ; i++) {
    oled.clearDisplay();
    oled.setTextXY(3, 5);
    oled.putString(String(i));
    Zähler -= 1;
    Verzögerung (1000);
  }
  oled.clearDisplay();
  Zähler = 0;
}

void player1() {
  int TemperatureValue = getTemp();
  while (digitalRead(BUTTON_PIN) == 0 && counter == 0) {
    player1guess = map( analogRead(POTENTIOMETER), 0, 1023, -20, 212);
    oled.setTextXY(2, 0);
    oled.putString("Spieler 1: ");
    oled.setTextXY(2, 8);
    oled.putString(String(player1guess));
    Serial.println(temperatureValue);
  }
  buttonFunc();
  Zähler += 1;
  if (temperatureValue > 0 && player1guess > 0) {
    player1result = TemperatureValue - player1guess;
  }
  if (temperatureValue > 0 && player1guess < 0) {
    player1result = TemperatureValue + (-1) * player1guess;
  }
  if (temperatureValue < 0 && player1guess > 0) {
    player1result = (-1) * TemperatureValue + player1guess;
  }
  if (temperatureValue < 0 && player1guess < 0) {
    player1result = (-1) * TemperatureValue - (-1) * player1guess;
  }
  if (player1result < 0) {
    Spieler1Ergebnis = Spieler1Ergebnis * (-1);
  }
  Serial.println(temperatureValue);
  Serial.println(player1result);
}

void player2() {
  int TemperatureValue = getTemp();
  while (digitalRead(BUTTON_PIN) == 0 && counter == 0) {
    player2guess = map( analogRead(POTENTIOMETER), 0, 1023, -20, 212);
    oled.setTextXY(2, 0);
    oled.putString("Spieler 1: ");
    oled.setTextXY(2, 8);
    oled.putString(String(player2guess));
    Serial.println(temperatureValue);
  }
  buttonFunc();
  Zähler += 1;
  if (temperatureValue > 0 && player1guess > 0) {
    player2result = TemperatureValue - player2guess;
  }
  if (temperatureValue > 0 && player1guess < 0) {
    player2result = TemperatureValue + (-1) * player2guess;
  }
  if (temperatureValue < 0 && player1guess > 0) {
    player2result = (-1) * TemperatureValue + player2guess;
  }
  if (temperatureValue < 0 && player1guess < 0) {
    player2result = (-1) * TemperatureValue - (-1) * player2guess;
  }
  if (player1result < 0) {
    Spieler2Ergebnis = Spieler2Ergebnis * (-1);
  }
  Serial.println(temperatureValue);
  Serial.println(player1result);
}

void control() {
  oled.clearDisplay();
  oled.setTextXY(0, 4);
  oled.putString("GEWINNER");

  if (player1result >= player2result) {
    oled.setTextXY(2, 4);
    oled.putString("Spieler 2");
    pixels.setPixelColor(0, pixels.Color(51, 204, 0));
    pixels.show();
  }
  sonst wenn (player1result <= player2result) {
    oled.setTextXY(2, 4);
    oled.putString("Player1");
    pixels.setPixelColor(0, pixels.Color(51, 204, 0));
    pixels.show();
  }
  anders {
    oled.clearDisplay();
    oled.setTextXY(2, 4);
    oled.putString("scoreless");
  }

  oled.setTextXY(4, 1);
  oled.putString("Temp:");
  oled.setTextXY(4, 6);
  oled.putString(String(temperatureValue));

  if (tempUnite == 0) {
    oled.setTextXY(5, 2);
    oled.putString("Celcius");
  }
  sonst if (tempUnite == 1) {
    oled.setTextXY(5, 2);
    oled.putString("Fahrenheit");
  }
  Zähler += 1;
}

Schritt 2: Celsius oder Fahrenheit wählen?

Schalten Sie die PicoBricks ein und Sie werden das sehen OLED-Bildschirm leuchten mit zwei Optionen: Celsius und Fahrenheit. Dieser Teil ist interaktiv und lehrreich! Je nachdem, mit welcher Temperatureinheit Sie vertrauter sind (oder Sie einfach nur neugierig sind), verwenden Sie die Potentiometer um zwischen den beiden Optionen umzuschalten. Haben Sie Ihre Wahl getroffen? Großartig! Schlagen Sie einfach auf Taste um es einzusperren.

Schritt 3: Zeit zum Raten!

Kommen wir nun zum Kern des Spiels. Spieler Eins, Sie sind an der Reihe, die Umgebungstemperatur zu erraten. Drehen Sie das Potentiometer und beobachten Sie den OLED-Bildschirm, während Sie Ihre Schätzung abgeben. Sperren Sie es ein und geben Sie es an Spieler Zwei weiter, der dann auf die gleiche Weise seine Vermutung anstellt.

Schritt 4: Und der Gewinner ist...

Sobald beide Vermutungen bestätigt sind, ist die Stunde der Wahrheit gekommen. Die PicoBricks vergleichen Ihre Schätzungen mit der tatsächlichen Temperatur, die sie zuvor heimlich gemessen haben. Derjenige, der am ehesten geraten ist, gewinnt und auf dem Bildschirm wird eine feierliche Nachricht für den Gewinner angezeigt!

Stichworte: