Crazy Frog Game Project mit Stem Kit

Inhaltsverzeichnis

Verrücktes Froschspiel bezieht sich normalerweise auf ein Videospiel, das auf der Crazy Frog-Figur oder dem Lied basiert. Es ist auch als „The Annoying Thing“ bekannt und ein beliebtes Internetphänomen und eine Werbefigur. Er gilt als wilder und humorvoller Charakter und hat viele lustige und verrückte Abenteuerspiele inspiriert.

Diese Spiele gibt es in verschiedenen Genres wie Action, Rennen, Plattformspielen oder verschiedenen Minispielen. Die Spieler steuern den Charakter und versuchen, Hindernisse zu überwinden, an Wettkämpfen teilzunehmen oder Missionen abzuschließen.

Jedes Crazy Frog-Spiel kann sein eigenes einzigartiges Konzept und Gameplay haben, sodass die spezifischen Details eines Spiels, nach dem Sie sich erkundigen, möglicherweise zu unterschiedlichen Antworten führen. Im Allgemeinen zielen diese Spiele darauf ab, unterhaltsame und humorvolle Erlebnisse zu bieten und den Fans ein entzückendes Spielerlebnis zu bieten.

Verrücktes Froschspiel

Heute freuen wir uns, Ihnen ein unterhaltsames Projekt vorstellen zu können, das die Melodie des Originalsong von Crazy Frog, synchronisierte RGB-Lichter, die im Takt pulsieren, und ein niedliches Maskottchen, das eine Tanzeinlage vorführt OLED-Bildschirm. Das Crazy Frog-Spiel verspricht nicht nur ein unterhaltsames Erlebnis, sondern dient auch als Plattform zur Förderung von Kreativität, Konzentration und Beweglichkeit sowie zum Erwerb grundlegender Programmierkenntnisse. Dieses Unterfangen zielt nicht nur darauf ab, Sie zu unterhalten, sondern Ihnen auch wertvolle Fähigkeiten zu vermitteln. Lassen Sie uns tiefer in die Feinheiten des eintauchen verrückter tanzender Frosch!

Details und Algorithmus

Mit der Implementierung dieses Python-Codes starten wir ein spannendes Unterhaltungsprojekt unter Verwendung von PicoBricks. Wir haben die notwendigen Komponenten und Bibliotheken für ein OLED-Display etabliert, RGB-LED Streifen, und Summer. Unser Ziel ist es, optisch ansprechende Effekte und bezaubernde Maskottchenbilder zu erzeugen, indem wir Framebuffer-Objekte erstellen, die als unsere Leinwand für OLED-Visuals dienen. Die Noten und Tempi wurden sorgfältig ausgewählt, um die Essenz des Originalsongs von Crazy Frog einzufangen. Wir haben den Summer mit den Noten synchronisiert und diese Effekte auf dem angezeigt OLED-Bildschirm mit Pausen. Der RGB-LED-Streifen verleiht dem Gesamterlebnis eine faszinierende Lichtshow. Das OLED-Maskottchen verändert sich mit der Musik und verbessert so das visuelle und akustische Erlebnis zusätzlich. Zusammenfassend lässt sich sagen, dass dieser Code Anzeige, Ton und das nahtlos miteinander verbindet LED Streifen, um ein visuell fesselndes und musikalisch reizvolles Erlebnis zu schaffen.

Komponenten

1xPicoBricks

Sie können die Module von Picobricks ohne Verkabelung programmieren und betreiben. Wenn Sie die Module getrennt von der Platine verwenden möchten, sollten Sie die Modulverbindungen mit Grove-Kabeln herstellen.

Schaltplan

MicroBlocks-Codes des Crazy Frog-Spiels

MicroPython-Codes des Crazy Frog-Spiels

Der Micro-Python-Code wird unten angezeigt. Sie müssen eine separate Python-Datei für Ihre Bilddateien erstellen. Sie können diese Datei mit herunterladen Taste unter.

Laden Sie den gesamten Code herunter

Importzeit
Vom Maschinenimport Pin, I2C, PWM, ADC
Von Picobricks importieren Sie SSD1306_I2C
Framebuf importieren
import random #random bewirkt, dass das Neopixel zufällig ausgeführt wird.
Aus Picobricks importieren Sie die WS2812#ws8212-Bibliothek
from Crazyfrog_imgs import bar_0, bar_20, bar_50, bar_70, bar_90, bar_100, maskot_1, maskot_2, maskot_3, maskot_4 # Wir führen die imgs-Einstellung aus und erstellen eine der Optionen zum Konfigurieren von Bildern.
 
WIDTH = 128 # Breite des OLED-Displays
HÖHE = 64 # Höhe des OLED-Displays
i2c = I2C(0, scl=Pin(5), sda=Pin(4), freq=200000) # I2C mit den Pins GP8 und GP9 initialisieren (Standard-I2C0-Pins)
oled = SSD1306_I2C(WIDTH, HEIGHT, i2c, addr=0x3c) # OLED-Anzeige initiieren
bar1 = Framebuf.FrameBuffer(Bar_0, 128,64, Framebuf.MONO_HLSB)
bar2 = Framebuf.FrameBuffer(bar_20, 128,64, Framebuf.MONO_HLSB)
bar3 = Framebuf.FrameBuffer(bar_50, 128,64, Framebuf.MONO_HLSB)
bar4 = Framebuf.FrameBuffer(Bar_70, 128,64, Framebuf.MONO_HLSB)
bar5 = Framebuf.FrameBuffer(bar_90, 128,64, Framebuf.MONO_HLSB)
bar6 = Framebuf.FrameBuffer(bar_100, 128,64, Framebuf.MONO_HLSB)
maskot1 = Framebuf.FrameBuffer(Maskot_1, 128,64, Framebuf.MONO_HLSB)
maskot2 = Framebuf.FrameBuffer(Maskot_2, 128,64, Framebuf.MONO_HLSB)
maskot3 = Framebuf.FrameBuffer(maskot_3, 128,64, Framebuf.MONO_HLSB)
maskot4 = Framebuf.FrameBuffer(maskot_4, 128,64, Framebuf.MONO_HLSB)
 
Notes = {"B0": 31, "C1": 33, "CS1": 35, "D1": 37, "DS1": 39, "E1": 41, "F1": 44, "FS1": 46 ,
         „G1“: 49, „GS1“: 52, „A1“: 55, „AS1“: 58, „B1“: 62, „C2“: 65, „CS2“: 69, „D2“: 73,
         „DS2“: 78, „E2“: 82, „F2“: 87, „FS2“: 93, „G2“: 98, „GS2“: 104, „A2“: 110,
         „AS2“: 117, „B2“: 123, „C3“: 131, „CS3“: 139, „D3“: 147, „DS3“: 156, „E3“: 165,
         „F3“: 175, „FS3“: 185, „G3“: 196, „GS3“: 208, „A3“: 220, „AS3“: 233, „B3“: 247,
         „C4“: 262, „CS4“: 277, „D4“: 294, „DS4“: 311, „E4“: 330, „F4“: 349, „FS4“: 370,
         „G4“: 392, „GS4“: 415, „A4“: 440, „AS4“: 466, „B4“: 494, „C5“: 523, „CS5“: 554,
         „D5“: 587, „DS5“: 622, „E5“: 659, „F5“: 698, „FS5“: 740, „G5“: 784, „GS5“: 831,
         „A5“: 880, „AS5“: 932, „B5“: 988, „C6“: 1047, „CS6“: 1109, „D6“: 1175,
         „DS6“: 1245, „E6“: 1319, „F6“: 1397, „FS6“: 1480, „G6“: 1568, „GS6“: 1661,
         „A6“: 1760, „AS6“: 1865, „B6“: 1976, „C7“: 2093, „CS7“: 2217, „D7“: 2349,
         „DS7“: 2489, „E7“: 2637, „F7“: 2794, „FS7“: 2960, „G7“: 3136, „GS7“: 3322,
         „A7“: 3520, „AS7“: 3729, „B7“: 3951, „C8“: 4186, „CS8“: 4435, „D8“: 4699,
         „DS8“: 4978}
 
Crazy_frog_melody = [
    Notizen['A4'], Notizen['C5'], Notizen['A4'], Notizen['A4'], Notizen['D5'], Notizen['A4'], Notizen['G4'],
    Notizen['A4'], Notizen['E5'], Notizen['A4'], Notizen['A4'], Notizen['F5'], Notizen['E5'], Notizen['C5'],
    Notizen['A4'], Notizen['E5'], Notizen['A5'], Notizen['A4'], Notizen['G4'], Notizen['G4'], Notizen['E4'],
    Notes['B4'], Notes['A4'],0,
   
    Notizen['A4'], Notizen['C5'], Notizen['A4'], Notizen['A4'], Notizen['D5'], Notizen['A4'], Notizen['G4'],
    Notizen['A4'], Notizen['E5'], Notizen['A4'], Notizen['A4'], Notizen['F5'], Notizen['E5'], Notizen['C5'],
    Notizen['A4'], Notizen['E5'], Notizen['A5'], Notizen['A4'], Notizen['G4'], Notizen['G4'], Notizen['E4'],
    Notes['B4'], Notes['A4'],0,
   
    Notes['A3'], Notes['G3'], Notes['E3'], Notes['D3'],
   
    Notizen['A4'], Notizen['C5'], Notizen['A4'], Notizen['A4'], Notizen['D5'], Notizen['A4'], Notizen['G4'],
    Notizen['A4'], Notizen['E5'], Notizen['A4'], Notizen['A4'], Notizen['F5'], Notizen['E5'], Notizen['C5'],
    Notizen['A4'], Notizen['E5'], Notizen['A5'], Notizen['A4'], Notizen['G4'], Notizen['G4'], Notizen['E4'],
    Notizen['B4'], Notizen['A4'],
]
 
Crazy_frog_tempo = [
    2,4,4,8,4,4,4,
    2,4,4,8,4,4,4,
    4,4,4,8,4,8,4,4,
    1,4,
   
    2,4,4,8,4,4,4,
    2,4,4,8,4,4,4,
    4,4,4,8,4,8,4,4,
    1,4,
   
    8,4,4,4,
   
    2,4,4,8,4,4,4,
    2,4,4,8,4,4,4,
    4,4,4,8,4,8,4,4,
    1,
]
oled.blit(bar1, 0, 0)
oled.show()
time.sleep(1)
oled.blit(bar2, 0, 0)
oled.show()
time.sleep(1)
oled.blit(bar3, 0, 0)
oled.show()
time.sleep(1)
oled.blit(bar4, 0, 0)
oled.show()
time.sleep(1)
oled.blit(bar5, 0, 0)
oled.show()
time.sleep(1)
oled.blit(bar6, 0, 0)
oled.show()
time.sleep(1)
 
Summer = PWM(Pin(20))
Buzzer.duty_u16(0)
 
neo = WS2812(6, Helligkeit=0,4)
 
maskot_position = 0
 
def Buzz(Frequenz, Länge):
#erstellen Sie die Funktion „buzz“ und geben Sie ihr die Tonhöhe und Dauer ein
    if(Frequenz==0):
        time.sleep(length)
        zurückkehren
 
    Buzzer.duty_u16(4000)
    Buzzer.freq(Frequenz)
    time.sleep(length)
    Buzzer.duty_u16(0)
 
def play(melody,tempo,pause,pace=0.7):
    globale maskot_position
    für i in range(0, len(melody)):
        # Lied abspielen
        noteDuration = Tempo/Tempo[i]
        Buzz(melody[i],noteDuration) # Ändern Sie die Frequenz entlang der Songnote
        pauseBetweenNotes = noteDuration * Pause
        time.sleep(pauseBetweenNotes)
neo.pixels_fill((random.randint(0,255),
                         random.randint(0,255),
                         random.randint(0,255)))
        neo.pixels_show()
        wenn maskot_position == 0:
            oled.blit(maskot1, 0, 0)
            maskot_position = 1
        elif maskot_position == 1:
            oled.blit(maskot2, 0, 0)
            maskot_position = 2
        elif maskot_position == 2:
            oled.blit(maskot3, 0, 0)
            maskot_position = 3
        elif maskot_position == 3:
            oled.blit(maskot4, 0, 0)
            maskot_position = 0
        oled.show()
 
play(crazy_frog_melody, Crazy_frog_tempo, 0.1)

Arduino C-Codes für PicoBricks

#define BUZZER_PIN 20
#define NOTE_E4 330
#define NOTE_A5 880
#define NOTE_F5 698
#define NOTE_E5 659
#define NOTE_G4 392
#define NOTE_D5 587
#define NOTE_C5 523
#define NOTE_A4 440
#define NOTE_B4 494

const int CrazyFrogMelody[] = {
  NOTE_A4, NOTE_C5, NOTE_A4, NOTE_A4, NOTE_D5, NOTE_A4, NOTE_G4,
  NOTE_A4, NOTE_E5, NOTE_A4, NOTE_A4, NOTE_F5, NOTE_E5, NOTE_C5,
  NOTE_A4, NOTE_E5, NOTE_A5, NOTE_A4, NOTE_G4, NOTE_G4, NOTE_E4, NOTE_B4,
  HINWEIS_A4, 0,
};

const int CrazyFrogTempo[] = {
  2, 4, 4, 8, 4, 4, 4,
  2, 4, 4, 8, 4, 4, 4,
  4, 4, 4, 8, 4, 8, 4, 4,
  1, 4,
};

void setup() {
  pinMode(BUZZER_PIN, OUTPUT);
}

void loop() {
  int size = sizeof(crazyFrogTempo) / sizeof(int);
  for (int note = 0; note < size; note++) {
    int Dauer = 1000 / CrazyFrogTempo[Note];
    Tone(BUZZER_PIN, CrazyFrogMelody[Note], Dauer);
    int pauseBetweenNotes = Dauer * 1,30;
    Verzögerung(pauseBetweenNotes);
    noTone(BUZZER_PIN);
  }
}

Stichworte:

Crazy Frog-Spielprojekt