Vergest den Beitrag nehmt einen EPS8266 oder Wemos D1 mini. Alles drauf billiger und läuft in der ArduinoIDE

Mit Arduino ins Netzwerk oder sogar ins Internet kein Problem.

In den Beisplielen muss lediglich die IP-Adresse an Euer Netzwerk angepasst werden.
Auch die MAC-Adresse wird über das Programm gesetzt (Das hat mich überrascht). Es muss darauf geachtet werden, das sie genau wie die IP nicht schon mal im Netztwerk existiert.
In den Examples unter Ethernet ist das Programm "Webserver"  Es gibt den Wert der Analogschnittstellen  in HTML aus.
Weiterhin in den Examples unter SD ein Programm, mit dem sich die SD-Karte (nicht im Lieferunfang) testen lässt.
Ethernetshield für Arduino


Hier vorab ein Programm mit dem sich ein Led an Digital 8 ein und ausschalten lässt.  Die Libary ist in dem Standarddownload von der Arduinoseite enthalten. 

#include <SPI.h>
#include <Ethernet.h>

byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress ip(192,168,1, 177);

EthernetServer server(80);

void setup()
{
  Serial.begin(9600);    
  pinMode(8, OUTPUT);    
  Ethernet.begin(mac, ip);
  server.begin();
}

void loop()
{
 
  EthernetClient client = server.available();
  if (client) {
    boolean currentLineIsBlank = true;
    String buffer = "";  
    while (client.connected()) {
      if (client.available()) {
        char c = client.read();
        Serial.print(c);   
        buffer+=c;       
        if (c == '\n' && currentLineIsBlank) {
          
          client.println("HTTP/1.1 200 OK");
          client.println("Content-Type: text/html");
          client.println();

          if (digitalRead(8)){  
            client.print(" LED is <font color='red'>OFF</font>");
          }else{
            client.print(" LED is <font color='green'>ON</font>");
          }
          client.println("<br />");
          
          
          client.print("<FORM action=\"http://192.168.1.177\" >");
          client.print("<P> <INPUT type=\"radio\" name=\"status\" value=\"0\">Off");
          client.print("<P> <INPUT type=\"radio\" name=\"status\" value=\"1\">On");
          client.print("<P> <INPUT type=\"submit\" value=\"Submit\"> </FORM>");
            
          break;
        }
        if (c == '\n') {
          
          currentLineIsBlank = true;
          buffer="";       
        } else if (c == '\r') {            
          if(buffer.indexOf("GET /?status=0")>=0)
            digitalWrite(8,HIGH);  
          
          if(buffer.indexOf("GET /?status=1")>=0)
            digitalWrite(8,LOW);  
        }
        else {
          
          currentLineIsBlank = false;
        }
      }
    }
    
    delay(1);
    
    client.stop();
  }
}

Das Funktioniert im lokalem Netztwerk. Um den Zugriff übers Internet zu ermöglichen muss der Port ( meistens) 80 auf die dem Ethershield zugeordnete IP-Adresse geroutet werden. Findet man bei einigen Routern unter Firewalleinstellungen oder virtuell Server.
Da die meisten von Euch ja die öffentliche IP-Adresse von Ihrem Provider dynamisch zugewiesen bekommen, muss hier auch noch Dyn Dns aktiviert werden.

Leider ist der amerikanische DynDns.org nicht mehr kostenlos.
Wenn ich eine Lösung gefunden habe teile ich das hier mit.

 

 

 

 

Ethershield 1.1 Yes it works.

Es wird noch ein anderes Ethershield angeboten für das es eine andere Libary gibt.

#include "etherShield.h"
#include "ETHER_28J60.h"

static uint8_t mac[6] = {
  0x54, 0x55, 0x58, 0x10, 0x00, 0x24};                                                     
static uint8_t ip[4] = {
  192, 168, 1,15};
static uint16_t port = 80;

ETHER_28J60 e;
int ledPin = 5;
void setup()


{
  pinMode(ledPin, OUTPUT);
  e.setup(mac, ip, port);
  analogReference(INTERNAL);
  Serial.begin(9600);
}

void loop()
{
  float analog = analogRead(0);
  float temp = (analog * 1.1/1024*100);
  delay(10);
  char celsius[4];
  dtostrf(temp,4,1,(celsius));


  if (e.serviceRequest())
  {
    e.print("<html><head><title>Temperatur TEST</title><meta http-equiv='Refresh' content='1'></head><body>");
    e.print("<h2><center>Temperatur in Celsius: ");
   
    e.print (celsius);
    e.print("<br>");
    e.print("<br>LED ein bei 26");
    if (temp >= 26) {
      digitalWrite(ledPin,HIGH);
      e.print("<br><img src='http://ebay.jkrumm.de/lichtan.png'></img>");
      }
    else {
      digitalWrite(ledPin,LOW);
      e.print("<br><img src='http://ebay.jkrumm.de/lichtaus.png'></img>");
          
    }
    e.respond();
  }
  if (temp >= 26) {
    digitalWrite(ledPin,HIGH);
  }
  else {
    digitalWrite(ledPin,LOW);
  }


  delay(10);
}


 

 

Hier ein Sketch der einen LM35 auswertet, abhängig von der Temperatur ein Led ein und ausschaltet.

 

 

 

 

 

 

 

 

 

smr200

 

BMP 085  Barometric Modul

Hier das ältere Breakoutboard BMP085.

BMP 085 Digital Barometric Modul

bmp085Links zeigt das Modul mit dem Sensor von Bosch. Zwei 4K7 Widerstände im I²C Bus sind schon integriert. es Scheint auch ein Spannungsregler auf der Platine zu sein. Auf älteren Beschreibungen steht zwar 3,3 Volt. Mit 5Volt werde ich aber nicht testen zumal der Arduino ja auch 3,3V hergibt.

Rechts die Anschlüsse. Neben der Betriebspannung wird nur SCA und SCL benötigt.

 

 

 

 Hier ein kleines Programm von Ladyada zum testen. Das Bild rechts zeigt sie Ausgabe der Messwerte auf das Terminal. Es wird auch die Temperatur gemessen.BMP085 Messwerte

#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BMP085_U.h>

/* This driver uses the Adafruit unified sensor library (Adafruit_Sensor),
   which provides a common 'type' for sensor data and some helper functions.
   
   To use this driver you will also need to download the Adafruit_Sensor
   library and include it in your libraries folder.

   You should also assign a unique ID to this sensor for use with
   the Adafruit Sensor API so that you can identify this particular
   sensor in any data logs, etc.  To assign a unique ID, simply
   provide an appropriate value in the constructor below (12345
   is used by default in this example).
   
   Connections
   ===========
   Connect SCL to analog 5
   Connect SDA to analog 4
   Connect VDD to 3.3V DC
   Connect GROUND to common ground
    
   History
   =======
   2013/JUN/17  - Updated altitude calculations (KTOWN)
   2013/FEB/13  - First version (KTOWN)
*/
   
Adafruit_BMP085_Unified bmp = Adafruit_BMP085_Unified(10085);

/**************************************************************************/
/*
    Displays some basic information on this sensor from the unified
    sensor API sensor_t type (see Adafruit_Sensor for more information)
*/
/**************************************************************************/
void displaySensorDetails(void)
{
  sensor_t sensor;
  bmp.getSensor(&sensor);
  Serial.println("------------------------------------");
  Serial.print  ("Sensor:       "); Serial.println(sensor.name);
  Serial.print  ("Driver Ver:   "); Serial.println(sensor.version);
  Serial.print  ("Unique ID:    "); Serial.println(sensor.sensor_id);
  Serial.print  ("Max Value:    "); Serial.print(sensor.max_value); Serial.println(" hPa");
  Serial.print  ("Min Value:    "); Serial.print(sensor.min_value); Serial.println(" hPa");
  Serial.print  ("Resolution:   "); Serial.print(sensor.resolution); Serial.println(" hPa");  
  Serial.println("------------------------------------");
  Serial.println("");
  delay(500);
}

/**************************************************************************/
/*
    Arduino setup function (automatically called at startup)
*/
/**************************************************************************/
void setup(void)
{
  Serial.begin(9600);
  Serial.println("Pressure Sensor Test"); Serial.println("");
 
  /* Initialise the sensor */
  if(!bmp.begin())
  {
    /* There was a problem detecting the BMP085 ... check your connections */
    Serial.print("Ooops, no BMP085 detected ... Check your wiring or I2C ADDR!");
    while(1);
  }
 
  /* Display some basic information on this sensor */
  displaySensorDetails();
}

/**************************************************************************/
/*
    Arduino loop function, called once 'setup' is complete (your own code
    should go here)
*/
/**************************************************************************/
void loop(void)
{
  /* Get a new sensor event */
  sensors_event_t event;
  bmp.getEvent(&event);
 
  /* Display the results (barometric pressure is measure in hPa) */
  if (event.pressure)
  {
    /* Display atmospheric pressue in hPa */
    Serial.print("Pressure:    ");
    Serial.print(event.pressure);
    Serial.println(" hPa");
    
    /* Calculating altitude with reasonable accuracy requires pressure    *
     * sea level pressure for your position at the moment the data is     *
     * converted, as well as the ambient temperature in degress           *
     * celcius.  If you don't have these values, a 'generic' value of     *
     * 1013.25 hPa can be used (defined as SENSORS_PRESSURE_SEALEVELHPA   *
     * in sensors.h), but this isn't ideal and will give variable         *
     * results from one day to the next.                                  *
     *                                                                    *
     * You can usually find the current SLP value by looking at weather   *
     * websites or from environmental information centers near any major  *
     * airport.                                                           *
     *                                                                    *
     * For example, for Paris, France you can check the current mean      *
     * pressure and sea level at: http://bit.ly/16Au8ol                   */
     
    /* First we get the current temperature from the BMP085 */
    float temperature;
    bmp.getTemperature(&temperature);
    Serial.print("Temperature: ");
    Serial.print(temperature);
    Serial.println(" C");

    /* Then convert the atmospheric pressure, SLP and temp to altitude    */
    /* Update this next line with the current SLP for better results      */
    float seaLevelPressure = SENSORS_PRESSURE_SEALEVELHPA;
    Serial.print("Altitude:    ");
    Serial.print(bmp.pressureToAltitude(seaLevelPressure,
                                        event.pressure,
                                        temperature));
    Serial.println(" m");
    Serial.println("");
  }
  else
  {
    Serial.println("Sensor error");
  }
  delay(1000);
}


 

 Die Ergebnisse  decken sich mit den vom deutschen Wetterdienst.

Hier der Dowload der Adafruitlybrary.

Der BMP180 hat den BMP085 abgelöst.

Die Library ist aber kompatibel geblieben. Es wird aber immer noch BMP085 als Sensor angezeigt. Das sollte aber nicht stören da die Messwerte nicht abweichen. Auf dem Breakoutboard ist ein Spannungsregler und auch zwei 4k7 Pullupwiderstände. Ich habe diesmal mit 5V getestet.

Hier nochmal die Vorder und Rückansicht des BMP180.

 BMP180 von vornbmp180b

 

Jetzt aktuell der BMP280

 

BMP280

 

 

Der Bmp180 wurde nochmals überarbeiet und ist jetzt der BMP280. Was neu ist ist mir unbekannt.
Die Breakouts die ich jetzt bekommen habe bestehen auch nur aus dem Sensor und 4 Widerständen.
Achtung kein Spannungsregler. Es müssen unbedingt 3,3V sein.
Er funktioniert einwandfrei mit Anschluss an SPI in Verbindung mit dem Adafruit Treiber.

Normalerweise ist für den I2C Adresse 0x77 Standard.
Bei diesem hier ist es 0x76. Das muss in die Library Adafruit_BMP280.h geändert werden.
#define BMP280_ADDRESS     
(0x76)     Dann funktioniert es auch mit I2C

 

 

 Download BMP280 Library
 Download Sensor Library

 

 

 


Hier nochmal der Sketch oberhalbs des Setup habe ich den SPI aktiviert

 #include <Wire.h>
#include <SPI.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BMP280.h>

#define BMP_SCK 13
#define BMP_MISO 12
#define BMP_MOSI 11
#define BMP_CS 10

//Adafruit_BMP280 bme; // I2C
//Adafruit_BMP280 bme(BMP_CS); // hardware SPI
Adafruit_BMP280 bme(BMP_CS, BMP_MOSI, BMP_MISO, BMP_SCK);

void setup() {
Serial.begin(9600);
Serial.println(F("BMP280 test"));

if (!bme.begin()) {
Serial.println(F("Could not find a valid BMP280 sensor, check wiring!"));
while (1);
}
}

void loop() {
Serial.print(F("Temperature = "));
Serial.print(bme.readTemperature());
Serial.println(" *C");

Serial.print(F("Pressure = "));
Serial.print(bme.readPressure());
Serial.println(" Pa");

Serial.print(F("Approx altitude = "));
Serial.print(bme.readAltitude(1013.25)); // this should be adjusted to your local forcase
Serial.println(" m");

Serial.println();
delay(2000);
}

 
Arduino

Einstellungen

Nichts schlimmes das meiste ist richtig vorgegeben. Unter Tools lediglich angeben welchen Arduino, hier wär es der Uno und welche Com Windows benutzt. Nicht verwirren lassen. Der Com-Port wird von Windows auf USB umgeleitet.

Eventuell sind noch Speicherort für das Sketchbook sowie die Sprache festzulegen.

Ausgaben mit seriel.Print erfolgen auf den seriellen Monitor unter Tools.
Sie können auch das Windows-Hyperterminal  (Win-XP) benutzen Sie finden es  Zubehör Kommunikation.(Win XP) . Bei Windows 7 gibt es das nicht mehr. Verwenden Sie dann den Seriellen Monitor unter Tools in der Arduino Software. Man kann das Hyperterminal auch von Windows XP verwenden oder versuchen Sie es mit Putty.
Die Com Schnittstelle wird mit 9600Baud, 8Bit, Parity none, Stoppbit kein, Flusssteuerung keine eingestellt. Das geht nur wenn der kleine Hörer aufgelegt ist. In der Programmierung des Arduino wird 9600Baud eingestellt, das andere passt.

Das erste Programm

Arduino Anschliesen LED mit Vorwiderstand an Pin6 Arduinoprogrammierung starten.
Datei neu
den Text unten per drag and drop einfügen
Upload   und sollte funzen.

void setup()
{
  pinMode(6, OUTPUT);      // kofiguriert den Pin 6 als Output
}

void loop()
{
digitalWrite(6,HIGH);          //Pin 6 auf High
delay(1000);                        //1 sek. Pause
digitalWrite(6,LOW);
delay(1000);
}

 

 

Der  von der  Fa. FTDI produzierte FTDI232RL wandelt die USB Pegel in ein RS232 Signal um. Es werden die Pins TX RX DTR und DSR unterstützt.  Für das Programmieren des Arduino ist das DTR Signal wichtig, das den zum Programmiervorgang  benötigte Reset am Ende erzeugt.

 Warnung zur Zeit sind die meisten Chips Nachbauten aus China. Mit der aktuellen Treiberversion werden diese Chips zerstört.
Bis die Situation geklärt ist und ich einwandfreie Ware anbieten kann habe ich diesen Artikel aus meinem Shop entfernt.

Hie ein Bild von einem Selbstbau Arduino.

ftdi350Der Anschluss ist ganz einfach, Betriebspannung, RS an TX und TX an RX wo bei es einem selbst überlassen bleibt obt man direkt an den Atmega oder oben rechts an die digitalen Anschlüsse lötet.
Damit das ganze funktioniert muss das DTR Signal noch über einen Kondensator an Reset angeschlossen werden.
Laut Schaltung ist es ein 100nf (0,1µf). Das hat bei mir auch funktioniert, aber nur auf dem ersten Board. Ich habe dann einen Elko ich glaube 0,47µf eingebaut.

Wer die Schaltung auch in der Arduino Programmierumgebung nutzen will muss noch einen Bootloader installieren.
Bei Ebay wird der Atmega328p auschließlich mit installiertem Bootloader angeboten. Auch in meinen Bausätzen.


Ansonsten müsst Ihr den Bootloader selbst installieren.
Das geht nur über die ISP Schittstelle mit einem Programmiergerät. Man kann auch in einen vorhandenen Aruino einen ISP Sketch laden und diesen dann als Programmer benutzen. Das Kapitel muss ich noch testen.

Mit dem Bootloader aus der Arduino Version 1.04 hat es bei mir nicht funktioniert. Ich habe dann den Optiboot installiert.
 

Eine ältere Treibervision kann ich auf Wunsch per Mail schicken. Der Aktuelle Treiber steht bei FTDI zum download zur Verfügung.

  Downloads:                     Optiboot Bootloader
     

FTDI an USB

               

 

Der Arduino hat 6 analoge Eingänge die von einem 10Bit A/D Wandler ausgewertet können.

Mit dem Befehl int analogPort = 0; wird festgelegt das analogread(0) ausgelesen werden kann.

poti4k7

In den Beispielen der Arduino Software sind ein paar Grundlegende versuche mit dem Analogport beschrieben.

Führen Sie diese mal durch. Schliessen Sie das Poti (Ja 4k7 geht auch) wie im Bild an.

Morgen schreib ich weiter

 

Steckbrett1

 

Schnell mal testen ohne löten, aber auch ideal für den Versuchsaufbau ist das Steckbrett.

Das Steckbrett ist bei mir über Ebay oder meinen Shop erhältlich.

 

 

 

 

 

 

Steckbrett1a

 

Hier hab ich nochmal eingezeichnet wie die Kontakte miteinander verbunden sind.

Die Installation auf dem Steckbrett ist manchmal etwas wackelig. Die Schaltungen dürfen so auf keinen Fall in Luft, Raumfahrt und der Medizin eingesetzt werden. (Grins)

 

Fensterkontakte überwachen.

In den Beispielen ist ein Programm das einen Schalter am Digitalpin abfragt. Ich habe es etwas erweitert. Szenario alle Fenster einer Wohnung sollen überwacht werden. Beim öffnen der Wohnungstür leuchtet ein Led wenn ein Fenster oder beide Fenster auf sind.
Tür und Fenster sind mit Umschaltontakten versehen die bei geschlossene Fenster auf 0 Volt liegen. Bei offenen Fenster oder Tür werden über 10kOhm 5 Volt auf den Digitalpin gelegt. Wenn ein oder beide Fenster offen sind passiert nichts erst wenn die Tür geöffnet wird und eins oder beide Fenster offen sind wird in diesem Beispiel LED13 ( auf Arduino Uno bereits vorhanden) eingeschaltet.Kontakte

 

Hier das Programm, wer es verstanden hat kann es mühelos auf mehr Fenster erweitern:

Die Kommentare habe ich nocht nicht angepasst.

Statt Schaltern kann man zum testen auf dem Steckbrett auch einfach Kabel umstecken.

/*
Fensterüberwachung
 
 Ein Led wird eingeschaltet wenn schalter Dor und Schalter Fenster1 oder Fenster2 auf 5V liegen.
 
 
 The circuit:
 
 * 10K resistor attached to pin 2 from ground
 
 * Hinweis: auf den meisten Arduinos ist bereiz ein  LED auf der Platine mit Pin 13 verbunden.
 
 
 
 
 

modified by http://pc-rentner.de
 */

// constants won't change. They're used here to
// set pin numbers:
const int fenster1 = 2;     // the number of the pushbutton pin
const int fenster2 = 3;     // the number of the pushbutton pin
const int dor = 11;     // the number of the pushbutton pin
const int ledPin =  13;      // the number of the LED pin

// variables will change:
int buttonState1 = 0;         // variable for reading the pushbutton status
int buttonState2 = 0;
int buttonState6 = 0;         // Türkontakt
void setup() {
  // initialize the LED pin as an output:
  pinMode(ledPin, OUTPUT);      
  // initialize the pushbutton pin as an input:
  pinMode(fenster1, INPUT);
  pinMode(fenster2, INPUT);
}

void loop(){
  // read the state of the pushbutton value:
  buttonState1 = digitalRead(fenster1);
   buttonState2 = digitalRead(fenster2);
buttonState6 = digitalRead(dor);
  // check if the pushbutton is pressed.
  // if it is, the buttonState is HIGH:
  if (buttonState6 == HIGH and buttonState1 == HIGH or buttonState2 == HIGH) {     
    // turn LED on:    
    digitalWrite(ledPin, HIGH);  
  }
  else {
    // turn LED off:
    digitalWrite(ledPin, LOW);
  }
}

Dieses Programm funktioniert.  Bitte LCD und LM35 wie in den
Kommentaren anschliessen.

/*Sketch getestet 18.07.2013*/

#include <LiquidCrystal.h>

LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
#define LCD_CLEAR 0b00000001
float temp;
float tempF;
int tempPin = 1;

void setup() {
Serial.begin(9600);
lcd.begin(16, 2);
}

void loop() {
temp = analogRead(tempPin);
temp = temp * 5/1024*100;
tempF = ((temp*9)/5) + 32;
lcd.setCursor(0, 0);
lcd.print(temp);
lcd.print("C");
lcd.setCursor(0,2);
lcd.print(tempF);
lcd.print("F");
delay(5000);
lcd.clear();

Serial.println(temp);

}

Einige werden sich wundern das die Temperatur nicht stimmt. Das liegt daran das der A/D Wandler die Betriebsspannung als Referenzspannung für die Umrechnung benutzt. Wenn man den Arduino nur über die Spannung der USB Schnittstelle Betreibt ist die Spannung meistens zu niedrig.
Abhilfe schafft da ein externes Netzteil um zu gewährleisten das in der Standardprogrammierung Uref = Ubb = 5V ist. Man kann auch, wie im unterem Beispiel die interne Referenz des Atmegacontollers wählen und die liegt hier bei 1,1 V.
Die dritte Möglich wäre  eine externe Referenzspannung ( Achtung max 5V) zu wählen.    analogReference(external);

Dieses Programm funktioniert.  Ausgabe auf den Monitor in den Arduino Tools.

//Aktuell Version Mai 2014

int Sensorport = 0;
float temperatur;

void setup() {
Serial.begin(9600);
analogReference(INTERNAL); // !! Einschalten der internen //Referenzspannung. Beim Uno (Atemge 328p) 1,1Volt

}
void loop()
{ temperatur= analogRead(Sensorport);
delay(20); //warten 20ms
temperatur = temperatur * 1.1 / 10.24 ;
Serial.println(temperatur);
delay(1000);
}

 

Luftfeuchtigkeit messen mit dem dem DHT11,

ist eigentlich ganz einfach da das ganze handling und timig von einer Libary ausgeführt wird. Die Libary benennt die Pins etwas anders. Der Pin 15 im Scetch ist tatsächlich A1 am Arduino.

anschluss

Der Anschluss ist ganz einfach.

Hier der fertige Scetch mit LCD und Ausgabe aufs Terminal. Ganz einfach da hier eine Libary (von Ladyada) verwendet wird.

Der Widerstand wird auf einigen Seiten auch mit kleineren Werten angeben. Bei mir funzt es nur mit 10kOhm.

 

#include "DHT.h" //von ladyada: https://github.com/adafruit/DHT-sensor-library
#define DHTPIN 15 // benutzter ARDUINO-Pin (Analog-Pin 1)

#include <LiquidCrystal.h>
LiquidCrystal lcd(9, 8,4,5,6,7); // diese Pins werden für das Display benötigt.

#define DHTTYPE DHT11 // DHT 11

DHT dht(DHTPIN, DHTTYPE);

void setup() {
Serial.begin(9600);
Serial.println("DHT11-Test");

lcd.clear(); // LCD loeschen
lcd.begin(16, 2); // fuer LCD1602
dht.begin();
}

void loop() {
// Das Erfassen von Temperatur und Luftfeuchtigkeit benoetigt ca. 250 Millisekunden.
float h = dht.readHumidity();
float t = dht.readTemperature();

// Check, ob die Daten Zahlen sind, falls nicht (NaN: not a number), ist was falsch gelaufen!
if (isnan(t) || isnan(h))
{
Serial.println("Fehler beim Lesen vom DHT-Sensor");
}
else
{

Serial.print("Feuchtigkeit: ");
Serial.print(h);
Serial.print(" %\t ");
Serial.print("Temperatur: ");
Serial.print(t);
Serial.println(" Grad Celsius");

lcd.setCursor(0,0);
lcd.print("Feuchtigk.:");
lcd.print(h);
lcd.setCursor(0,1);
lcd.print("Temperatur:");
lcd.print(t);

}
}

 

PWM

Mit der Pulsweitenmodulation ist es möglich LEDs oder Motore stufenlos von ganz langsam bis hanz hell zu regeln. Dazu wird ein Rechtecksignalerzeugt dessen Flanke verschieden breit ist.
Bei den meisten Arduino-Boards (diejenigen mit einem ATmega168 oder ATmega328) ist das mit den Pins 3, 5, 6, 9, 10, und 11 möglich; bei einem Arduino-Mega sind das die Pins 2 bis 13. Bei älteren Arduino-Boardsmit einem ATmega8 wird analogWrite() an den Pins 9, 10, and 11 unterstützt.

Für den nachfolgen Nightridersketch reicht das nicht. Man kann PWM auch mit der Software erzeugen und an jeden Pin ausgeben. Wer Atmega schon mit anderen Sprachen programmiert hat weis das. Für Arduino gibt es eine fertige Libary die die Programmierung einfach macht und alles auf das wesentliche beschränkt.

Hier der Downloadlink für den Sketch

Hier der Downloadlink für die Libary

Ich habe den Sketch auf 10 LED's erweitert

 

{mp4}knightrider{/mp4}