Thorsten Kimmeskamp
Published © GPL3+

Glühwürmchen-Schwarm mit dem Calliope mini

Lass deine Calliopes als Glühwürmchen blinken (o. simuliere es auf einem Gerät). Mit der Zeit synchronisieren sie sich und blinken zusammen!

AdvancedFull instructions provided30 minutes454
Glühwürmchen-Schwarm mit dem Calliope mini

Things used in this project

Hardware components

Calliope mini
Calliope mini
×1

Story

Read more

Code

firefly_sync.js

JavaScript
let uhr = randint(0, 999) / 1000 // eigene Uhr jedes Glühwürmchens auf Zufallswert zw. 0 und 1 initialisieren
let schritt = 0.02 // Schrittgröße, mit der die eigene Uhr laufend weitergeschaltet wird
let schubs = 1.14 // Faktor, um den die eigene Uhr vorgestellt wird, wenn ein anderes Glühwürmchen blinkt
radio.setTransmitPower(7) // Sendeleistung ggf. reduzieren, damit nur Glühwürmchen in unmittelbare Nähe das Blinken mitbekommen

radio.onReceivedString(function (receivedString) {
    // wenn ein Glühwürmchen in der Nähe blinkt:
    uhr = uhr * schubs // eigene Uhr vorstellen
})

basic.forever(function () {
    if (uhr >= 1) {
        // wenn die eigene Uhr den Wert 1 erreicht:
        radio.sendString("blink") // andere Glühwürmchen benachrichtigen
        game.addScore(1) // Display aufblinken lassen
        uhr = 0 // eigene Uhr zurücksetzen
    } else {
		// ansonsten:
        uhr += schritt // eigene Uhr weiterschalten
    }
    basic.pause(6) // kurz warten
})

firefly_matrix.js

JavaScript
let uhren = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
let schritt = 0.01 // Schrittgröße, mit der alle Uhren laufend weitergeschaltet werden // 0.005 // 0.01
let schubs = 1.07 // Faktor, um den eine Uhr vorgestellt wird, wenn ein benachbartes Glühwürmchen blinkt // 1.035 // 1.07

// zufälliger Startwert für alle Uhren
for (let i = 0; i < 25; i++) {
    uhren[i] = Math.random()
}

basic.forever(() => {
	// "Blinken": LED anschalten, bis eigene Uhr 0.2 erreicht
    for (let i = 0; i < 25; i++) {
        if (uhren[i] < 0.2) {
            led.plot(i % 5, i / 5)
        } else {
            led.unplot(i % 5, i / 5)
        }
    }
   
	// alle Uhren laufend weiterschalten
    for (let i = 0; i < 25; i++) {
        uhren[i] += schritt
    }
    
	// für alle Glühwürmchen:
    for (let i = 0; i < 25; i++) {
		// rechter Nachbar
        let n1 = i + 1
        if (n1 % 5 == 0) {
			n1 -= 5
		}
		
		// linker Nachbar
        let n2 = i - 1
        if (n2 % 5 == 4) {
			n2 += 5
		}
		
		// unterer Nachbar
        let n3 = i + 5
        if (n3 > 24) {
			n3 -= 25
		}
		
		// oberer Nachbar
        let n4 = i - 5
        if (n4 < 0) {
			n4 += 25
		}
		
		// unten rechts
        let n5 = i + 6
        if (n5 > 25) {
			n5 -= 25
		}
        if (n5 % 5 == 0) {
			n5 -= 5
		}
		
		// unten links
        let n6 = i + 4
        if (n6 > 23) {
			n6 -= 25
		}
        if (n6 % 5 == 4) {
			n6 += 5
		}
		
		// oben rechts
        let n7 = i - 4
        if (n7 < 1) {
			n7 += 25
		}
        if (n7 % 5 == 0) {
			n7 -= 5
		}
		
		// oben links
        let n8 = i - 6
        if (n8 < -1) {
			n8 += 25
		}
        if (n8 % 4 == 4){
			n8 += 5
        }
		
		// eigene Uhr vorstellen (ggf. mehrfach), wenn Nachbarn blinken
        if (uhren[n1] >= 1) {
            uhren[i] *= schubs
        }
        if (uhren[n2] >= 1) {
            uhren[i] *= schubs
        }
        if (uhren[n3] >= 1) {
            uhren[i] *= schubs
        }
        if (uhren[n4] >= 1) {
            uhren[i] *= schubs
        }
		if (uhren[n5] >= 1) {
            uhren[i] *= schubs
        }
        if (uhren[n6] >= 1) {
            uhren[i] *= schubs
        }
        if (uhren[n7] >= 1) {
            uhren[i] *= schubs
        }
        if (uhren[n8] >= 1) {
            uhren[i] *= schubs
        }
    }

	// Uhren nach Blinken zurücksetzen
    for (let i = 0; i < 25; i++) {
        if (uhren[i] >= 1) {
            uhren[i] = 0
        }  
    }
})

firefly_cascade.js

JavaScript
input.onButtonPressed(Button.A, function () {
	// selbst blinken und andere Glühwürmchen benachrichtigen
	blink()
    radio.sendString("blink")
})

function blink() {
	// Animation: alle LEDs aufleuchten und dann langsam verblassen lassen
	let helligkeit = 255
	led.setBrightness(helligkeit)
    basic.showLeds(`
        # # # # #
        # # # # #
        # # # # #
        # # # # #
        # # # # #
        `)
    for (let i = 0; i < 10; i++) {
        helligkeit -= 25
        led.setBrightness(helligkeit)
        basic.pause(40)
    }
    basic.clearScreen()
}

radio.onReceivedString(function (receivedString) {
	// wenn Blinken eines anderen Glühwürmchens empfangen:
    basic.pause(randint(50, 350)) // zufällig zw. 50 und 350 ms warten
    blink() // selbst blinken
    if (Math.random() < 0.3) { // nur in 30 % der Fälle:
        basic.pause(500) // 500 ms warten
        radio.sendString("blink") // weitere Glühwürmchen benachrichtigen
    }
})

Credits

Thorsten Kimmeskamp
19 projects • 13 followers

Comments

Related channels and tags
  • Calliope mini