====== www: Makerspaceder SAS - CodeWeek 2024======
===== Teil 1 3D-Druck =====

  * Konstruktion mit BlocksCAD
    * Namensschild
    * Ampel

  * [[https://www.blockscad3d.com/editor/?lang=de|BlocksCAD]]
  * [[https://www.youtube.com/watch?v=wVX0cMV4s74|Einführung]]

====== INFO: BlocksCAD - Ampel ======

{{:www-fuer-alle:blockscad-ampel.png?400|}}

  - Erstelle einen Quader
  - schneide drei verschobene Zylinder heraus
  - schneide zwei Quader heraus, so dass ein Ampelmast entsteht
  - füge einen verschobenen Quader als Ampelfuß hinzu
===== Teil 2 ARDUINO - Lärmampel =====

===== Arduino lernen =====

==== 3.1 Grundstruktur für einen Sketch ====

<code>
int LED = 9;
int helligkeit = 0;
int x = 5;

void setup() {
  // put your setup code here, to run once:
  pinMode(LED, OUTPUT);
}

void loop() {
  // put your main code here, to run repeatedly:
  analogWrite(LED, helligkeit);
  helligkeit = helligkeit + x;
  delay(25);
  if (helligkeit == 0 || helligkeit ==255)
    {
      x = -x;
    }
}

</code>


==== Workshop ====

=== 1. Verbindungstest ===

  - der Rechner ist gestartet und Du bist angemeldet
  - starte die ARDUINO IDE 2
  - lade: Datei - Beispile - 01.Basics - Blink
    - {{:www-fuer-alle:ide-nano-blink.png?400|}}
  - Stelle das richtige Board und den richtigen USB-Port ein: NANO
  - {{:www-fuer-alle:ide-nano-usb.png?400|}}
  - Nun muss die richtige Variante des NANO eingestellt werden
    - Bootloader: 328 oder 328 old oder 168
    - {{:www-fuer-alle:ide-nano-bootloader.png?400|}} {{:www-fuer-alle:ide-nano-bootloader-auswahl.png?400|}}
  - Prüfe und lade den Code hoch
    - {{:www-fuer-alle:ide-nano-pruefen-hochladen.png?400|}}

=== 2. Schaltungsaufbau ===
  Baue die Musterschaltung nach
  
{{:info:laermampe-2024-10-12l.png?400|}}

=== 3. die blinkende Ampel ===

ACHTUNG: Es gibt verschiedene ARDUINO-NANO-Varianten - Bootloader einstellen - siehe oben!


<code>
void setup() {
  // initialize digital pin LED_BUILTIN as an output.
  pinMode(2, OUTPUT);
  pinMode(4, OUTPUT);
  pinMode(7, OUTPUT);
}

// the loop function runs over and over again forever
void loop() {
    digitalWrite(2, HIGH);          // turn the LED on (HIGH is the voltage level)
  delay(1000);                      // wait for a second
   digitalWrite(2, LOW);            // turn the LED off by making the voltage LOW
  delay(1000);                      // wait for a second
}


</code>

  * Ersetze die 2 durch 4 und beobachte
  * Ersetze die 4 durch 7 und beobachte

=== 4. gesteuerte Lichtzeichenanlage ===

  - live...

=== 5.Eine komplexe Variante zum Mitnehmen ===

<code>
const int sampleWindow = 50;                       // Sample window width in mS (50 mS = 20Hz)
int const AMP_PIN = A0;                            // Preamp output pin connected to A0
unsigned int sample;

unsigned long startMillis = 0;
unsigned int peakToPeak = 0;                       // peak-to-peak level

unsigned int signalMax = 0;
unsigned int signalMin = 1024;

float mittelwert;                                  // Erstellen einer Variable für den Mittelwert aus den Messungen

const int led_rot     = 2;                         // PINs an Digital-Ausgängen für die LEDs definieren        
const int led_gelb    = 4;                
const int led_gruen   = 7; 

const float grenze_rot   = 300.0;                  // Grenzen für Pegelanzeigen mit LEDs festlegen - je kleiner die Abstände, desto sensibler die Anzeige
const float grenze_gelb  = 80.1;               

int w;                                             // Erstellen von Variablen für die "zu-Fuß-Berechnung" des Mittelwertes  

void setup()
{
  Serial.begin(9600);
  ausgaenge_definieren();                          // Funktion zur Definition der PINs der LEDs als Ausgänge aufrufen
  ampelstufen_anzeigen();                          // Status der Grenzen der LEDs auf seriellem Monitor anzeigen
}

void loop(){
  startMillis = millis();                          // Start of sample window
  peakToPeak = 0;                                  // peak-to-peak level
  signalMax = 0;
  signalMin = 1024;
  Messung();
  w = peakToPeak; 
  mittelwert = (w+2*mittelwert)/3;   
  Serial.print("    Mittelwert: ");
  Serial.print(mittelwert);
  ampelstufen_anzeigen();
  Serial.println();
  if (mittelwert > grenze_rot) {alarmrot();}
    else { if  (mittelwert > grenze_gelb) {alarmgelb();}
       else {alarmgruen();}
  }
}

void Messung() {                                   // Messung der maximalen Amblitude
  while (millis() - startMillis < sampleWindow)  {
    sample = analogRead(AMP_PIN);
    if (sample < 1024)    {                        // toss out spurious readings
      if (sample > signalMax) {
        signalMax = sample;                        // save just the max levels
      }
      else if (sample < signalMin) {
        signalMin = sample;                        // save just the min levels
      }
    }
  }
  peakToPeak = signalMax - signalMin;              // max - min = peak-peak amplitude
}

void ausgaenge_definieren(){                       // Hier werden die PINs als Ausgang definiert
  pinMode(led_rot,   OUTPUT);      
  pinMode(led_gelb,  OUTPUT);        
  pinMode(led_gruen, OUTPUT);
}

void ampelstufen_anzeigen(){                       // Mit dieser Funktion können Grenzwerte der Ampelstufen angezeigt werden
  Serial.print("  ");  
  Serial.print("grenze_rot: ");
  Serial.print(grenze_rot);
  Serial.print("  grenze_gelb: ");
  Serial.print(grenze_gelb);
  delay (150);
}

void alarmrot() {
  digitalWrite(led_gruen, LOW);        
  digitalWrite(led_gelb, LOW);       
  digitalWrite(led_rot, HIGH);
}

void alarmgelb() {
  digitalWrite(led_gruen, LOW);        
  digitalWrite(led_gelb, HIGH);       
  digitalWrite(led_rot, LOW);
}

void alarmgruen() {
  digitalWrite(led_gruen, HIGH);        
  digitalWrite(led_gelb, LOW);       
  digitalWrite(led_rot, LOW);
}
</code>

==== eigene Varianten ====

  * Füge weiter Zwischenstufen ein:
    * statt GRÜN - GELB - ROT
    * GRÜN - **GRÜN und GELB** - GELB - **GELB und ROT** - ROT