Schlagwort-Archive: Arduino Matlab

CO2-Messung mit SCD30, Arduino und Matlab

Loading

Dieses Projekt – eigentlich Miniprojekt – könnte vielleicht auch für den einen oder anderen interessant sein. Es handelt sich um den mittlerweile bekannten und häufig verwendeten Kohlendioxid Sensor SCD30 (CO2-Sensor) des Herstellers Sensirion. Es gibt etliche Projekte die man dazu im Netz findet. Im Rahmen eines schnellen Testaufbaues habe ich versucht, die Daten des Sensors mithilfe eines Arduino Uno Boards auszulesen, um sie dann mit der Software Matlab in einem Plot darzustellen. Die Datenübertragung erfolgt über die Serielle Schnittstelle bzw. über serielles Protokoll des USB-UART.

Um den SCD30 am Arduino anzuschließen, benötigt man die Spannungsversorgung und den I²C Datenbus – also in Summe gerade einmal vier Drähte. Damit ist die minimale Konfiguration erfüllt und die Daten können ausgelesen werden.

Der Sensor selbst arbeitet nach dem Prinzip der NDIR Technologie.  (NDIR = non-dispersive-infrared). Das bedeutet, der Sensor ist also ein kleines Spektrometer. Hierbei wird das zu untersuchende Medium in eine Probenkammer geleitet. Die Probenkammer wird von einer Infrarotquelle durchleuchtet und das IR-Licht durchstrahlt das Medium und einen sehr schmalbandigen Wellenlängenfilter und trifft dann auf den IR-Detektor auf. Die Wellenlänge des Filters ist dabei so ausgelegt, dass genau diejenigen Wellenlängen durchgelassen werden, die von den Molekülen des Mediums (Gases) absorbiert werden. Je nach Anzahl der Moleküle, oder Dichte des Gases, werden entsprechend weniger Lichtstrahlen vom Detektor erkannt.  Eine zweite Messkammer, die mit einem Referenzgas gefüllt ist, dient dabei als Referenz. Ein Controller am Sensor wertet diese Informationen aus und gibt sie in Form von ppm über die I²C (oder umschaltbar auch MOD-Bus) Schnittstelle weiter. Zusätzlich befindet sich auch ein Temperatur und Luftfeuchtesensor am Board, deren Daten ebenso über den Bus ausgelesen werden können. Die voreingestellte I²C Adresse des SCD30 ist 0x61. Die genauen Informationen zum Datenprotokoll sind in den Dokumentationen der Firma Sensirion zu finden.

Idealerweise gibt es, wie fast immer, schon eine fertige, studententaugliche Library für die diversen Microcontroller. So braucht man sich keine Gedanken mehr zu machen und kann die Daten des angeschlossenen Sensors direkt auslesen. Die Beispielprogramme findet man unter den Examples der Libraries.

electrical specifications

Für die Versorgungsspannung des Sensors kann der Arduino mit 3.3V oder 5V dienen. Vorsicht ist jedoch geboten, wenn man den I²C Bus, verwendet: Hier ist der Input High-Level mit 1,75-3.0V festgelegt und der Output High Level mit max. 2.4V. An einem Arduino sind die Pegel aber 5V!! Also muss hier ein Levelshifter eingebaut werden – oder zumindest, für einen schnellen Test geeignete Widerstände.

Der hier angeführte Programmcode stammt im Wesentlichen aus dem Beispiel der Library von Nathan Seidle von SparkFun Electronics:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
/*
By: Nathan Seidle SparkFun Electronics  
Library: http://librarymanager/All#SparkFun_SCD30  
*/

#include <Wire.h>
#include "SparkFun_SCD30_Arduino_Library.h" 
SCD30 airSensor;

void setup()  
{
  Wire.begin();
  Serial.begin(9600);
  //Serial.println("SCD30 Example");
  airSensor.begin(); //This will cause readings to occur every two seconds
}

void loop()  
{
  if (airSensor.dataAvailable())
  {
   // Serial.print("co2(ppm):");
   
    Serial.print(airSensor.getCO2());

    //Serial.print(" temp(C):");
    Serial.print(",");
    Serial.print(airSensor.getTemperature(), 1);

   // Serial.print(" humidity(%):");
    Serial.print(",");
    Serial.print(airSensor.getHumidity(), 1);

    Serial.println();
  }
  else
    //Serial.println("No data");

  delay(500);
}

 

Mit diesen Codezeilen im Arduino Uno und der korrekten Verdrahtung (SDA -> an Arduino A4 und SCL -> an Arduino A5 über einen geeigneten Pegelwandler) geht’s dann mit Matlab weiter. Der Arduino sollte jetzt in einem seriellen Terminal folgende Zeilen ausgeben: (Beispiel)

473,28.5,12.9
473,28.5,13.0
470,28.5,13.1
469,28.5,12.9
466,28.5,12.9
465,28.5,12.7
465,28.5,12.5
463,28.6,12.6
461,28.6,12.5
463,28.5,12.4 … und so weiter

Diese gilt es nun in Matlab einzulesen und über einen definierbaren Zeitraum aufzuzeichnen und gleichzeitig in einem Plot darzustellen. Das Matlabskript hier macht es möglich… (pn falls es jemand benötigt)

Als Ergebnis erhält man dann einen Plot, der den CO2 Verlauf im Raum (in dem Fall am Schreibtisch meines Büros) darstellt.

 

 

HYT939 und NTC an Matlab über Arduino

Loading

DSC_2311In den letzten Blogeinträgen habe ich mit dem Arduino einen NTC-Widerstand  über einen Spannungsteiler an den Analogeingang des Arduino-UNO angeschlossen und ihn als eigenständiges Programmchen am Arduino als Temperatursensor laufen lassen. Die aktuellen Messwerte wurden auf einem LC-Display angezeigt. Dann habe ich die selbe Hardware über die Matlab Software und das „Arduino for Matlab“-Package betrieben und mittels Matlabcode direkt den Temperaturverlauf geloggt. Im vorhergehenden Blog war dann ein kombinierter Temperatur und Luftfeuchtigkeitssensor (Type HYT939) an der Reihe, der über den I²C Bus am Arduino seine Daten lieferte und wieder am LCD ausgegeben hat.

In diesem Bericht kommt nun wieder Matlab ins Spiel. Hier habe ich versucht, beide Sensoren, den NTC am Analogeingang und den HYT am I²C Bus, gleichzeitig auszulesen. Das sollte über einen mehrere Minuten andauernden Zeitraum passieren, wobei die Messwerte gleich mitgeloggt werden, um sie danach in einem Vergleichsdiagramm zu plotten. Der Hardwareaufbau ist wieder ganz einfach. Der NTC ist in Serie mit einem 2k2 Widerstand geschaltet. Die Enden des Spannungsteilers gehen an die +5V Versorgung und GND und der Teilerpunkt wird an den A0 – Eingang des Arduino Uno angeschlossen. Der HYT bekommt ebenfalls seine 5V vom Arduino selbst und an A4 und A5 ist der I²C anzuschließen (genaue Pinbelegung s. vorgehenden Bericht). Jetzt fehlt noch das Matlab-Script. Es ist hier einzusehen:

 

 

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Beispielscript um mit ArduinoUno einen Temperaturverlauf aufzuzeichnen
% Sensoren an A0 (Spannungsteiler mit NTC) und HYT939 an I2C
% 03/2016 by I.Bihlo
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
a = arduino('com4','Uno','libraries','I2C')
analogpin=0; %Anschlusspin analog des UNO
analog=0; %Variable für den Analogwert festlegen
nn=600; %anzahl der messpunkte
addr='0x28'; %addresse für digitalsensor
bus=i2cdev(a, addr) %i2c object erzeugen
%ein paar konstanten für die weiteren berechnungen
r=2200; %Spannungsteilerwiderstand
rt=0; %das wird der errechnete widerstand des NTC
urt=0; %das wird der errechnete Spannungsabfall am NTC
% konstanten für berechnung der Temperatur aus NTC Widerstand
% B25=3977K
a1=3.354016E-03;
b1=3.2569850E-04;
c1=2.61013E-06;
d1=6.38309e-08;
rref=2200;
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Lesen des I2C Bus
% Lesen eines Temperaturabhängigen Widerstandes am Analog Eingang A0
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
for x=1:nn
%%%% Analog 
analog(x)=readVoltage(a, analogpin); %Liest den AnalogIn von A0 und gibt in Volt aus
urt(x)=5-analog(x); %spannungsabfall am NTC 
rt(x)=(r/analog(x))*urt(x); %widerstand des NTC
pause(0.5);
%%%%Digital
data = read(bus, 4); %4 byte von i2c auslsesen
pause(0.5);
%Rohdaten aus Puffer lesen und zusammenbauen
humrawh=dec2bin(data(1),8); %byte 1 auf 8bit festlegen in binär wandeln
humrawl=dec2bin(data(2),8); %byte 2 auf 8bit festlegen in binär wandeln
humrawall=strcat(humrawh,humrawl); % beide bins concentenaten
humraw=bin2dec(humrawall); % die ganze kette wieder in dec wandeln
%tempraw=uint16(data(3))*256+uint16(data(4));
temprawh=dec2bin(data(4),8);
temprawl=dec2bin(data(3),8);
temprawall=strcat(temprawl,temprawh);
temprawall=temprawall(1:14); %% die letzten beiden bits abschneiden
tempraw=bin2dec(temprawall);
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Humidity berechnen lt. Datenblatt
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
hum(x)=double(100/(16384-1))*double(humraw);
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Temperatur berechnen lt. Datenblatt
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
temp(x)=double(165/(16384-1))*double(tempraw)-40.0;
%berechung der analogtemperatur
rvsrref(x)=rt(x)/rref; 
tempa(x)=1/(a1+(b1*log(rvsrref(x)))+(c1*(log(rvsrref(x)^2)))+(d1*(log(rvsrref(x)^3))));
tempc(x)=tempa(x)-273.15 %Kelin in Celsius umrechnen
pause(1);
end
clear a;
time=1:nn;
%plotten der daten
figure(1);
subplot(2,1,1);
plot(time,tempc,'m');
grid on; hold on;
%plot(time,analog,'b');
%plot(time,rt/1000,'r');
%plot(time,urt,'g'); 
plot(time,temp,'g');
legend('Temperatur NTC[°C]','Temperatur HYT939 [°C]');
%legend('Analogspannung des ADC','Widerstand des NTC in kOhm','Spannung am NTC','Temperatur [°C]');
subplot(2,1,2);
plot(time,hum,'m');
grid on; hold on;
legend('Rel Luftfeuchtigkeit HYT939 [%RH]');
%ende

Nachdem der Code nun nach einigen Anpassungen läuft, habe ich beide Sensoren (wie am Titelbild zu sehen) nebeneinander angeordnet und vor Beginn der Messung mit Kältespray (Kälte75 von KontaktChemie) heruntergekühlt. Dann startete das Script und begann aufzuzeichnen. Im Ergebnis sollte der Verlauf der Erwärmung auf die Raumtemperatur zu sehen sein. Da die Kälte am Metallgehäuse des HYT sofort eine Schicht aus gefrorenem Kondensat bildet die langsam taut, erwartete ich mir einen Luftfeuchtigkeitswert im Bereich der Sättigung. (was dann auch deutlich im Plot zu sehen ist).

HYTvsNTC

Arduino mit Matlab … Der Sensor

Loading

Nachdem ich im letzten Teil die Installation der Arduino-Matlab Packages zum Laufen bekommen habe, kann es nun weitergehen. Ziel dieses kleinen Beispiels ist es ja, an einen Arduino Uno einen NTC-Widerstand anzuschließen. Dieser soll als analoger Temperatursensor dienen (was er ja ist 😀 ) und über einen der A/D – Eingänge des Arduino eingelesen werden. Matlab soll dann schlussendlich die eingelesenen A/D- Werte  in Temperaturwerte umrechnen. Das Ganze soll über eine gewisse Zeit laufen, wobei alle paar n-Sekunden ein Wert eingelesen wird. Am Ende soll ein wunderschöner Temperaturplot mit Temperatur über Zeit erstellt werden.

Doch zuerst zum Sensor. Ich verwende hier einen NTC-Widerstand von dem Hersteller VISHAY mit einem R25 von 2200 Ohm (s.Datenblatt). Das bedeutet, er hat bei 25°C einen ohmschen Widerstand von 2.2kOhm. Je wärmer es nun wird, umso kleiner wird der Widerstand und umgekehrt. Der analoge Eingang des Arduino hat eine Auflösung von 10Bit. Das bedeutet, er kann den Spannungshub am Eingang (eingestellt durch die ADC Referenz) in 210 , also 1024 Teile auflösen (zerlegen). Der Standard beim Arduino ist 0V bis 5V. Also 0V am Eingang bedeutet einen ADC-Wert von 0 und 5V bedeutet einen ADC-Wert von 1024. Die Auflösung, also die kleinste auflösbare Spannungsänderung  ist daher:
formelarduino01 (2)Gibt der ADC beispielsweise einen Wert von 558 aus, so entspricht dies einer Spannung am Eingang von 558*0.00488V = 2.72304V. Doch wie soll der NTC jetzt an den Eingang angeschlossen werden? Ganz einfach. Man nehme einen Spannungsteiler und dimensioniere ihn so, dass der Strom durch die beiden Widerstände nie so groß werden kann, dass er zum einen die Versorgung des Arduino gefährdet und zum anderen auch nie so groß werden kann, dass er den NTC selbst erwärmt. In der Skizze ist nun dargestellt wie der Spannungsteiler aufgebaut und angeschlossen ist. Jetzt gilt es noch herauszufinden, wie aus der Spannung am ADC der gemessene Widerstandswert berechnet werden kann. Hier hilft die Spannungsteilerregel:
formel2
In diesem Beispiel hier besteht der Spannungsteiler aus dem NTC (2k2 @ 25°C) und einem 2k2 Festwiderstand. Wenn der NTC null Ohm haben sollte (nur rein theoretisch), so fließt ein maximaler Strom von 0.002A durch die Widerstände (5V/2200Ohm). Wir lesen jetzt in Matlab den Spannungsabfall am NTC ein und können uns über den Spannungsteiler den Widerstandswert berechnen. Jetzt fehlt nur noch die Formel zur Berechnung der Temperatur. Und die ist, samt den notwendigen Konstanten A1, B1, C1 und D1, im Datenblatt angegeben:formel3Das Ergebnis dieser Berechnung ist die Temperatur in Kelvin. Um die Temperatur aber in °Celsius angezeigt zu bekommen, rechnet man: °C = °K-273,15. Mit all diesen Informationen kann man jetzt ein Matlab-Script schreiben, das dann in etwa so aussieht:
 
 
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Beispielscript um mit ArduinoUno einen Temperaturverlauf aufzuzeichnen
% 02/2016 by I.Bihlo
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
&nbsp;
%a = arduino('com5','Uno');
&nbsp; a = arduino('com5','Uno','TraceOn', true)
&nbsp; analogpin=0;
&nbsp; analog=0;
&nbsp;
&nbsp; %ein paar konstanten für die weiteren berechnungen
&nbsp; %
&nbsp; r=2200;&nbsp; %Spannungsteilerwiderstand
&nbsp; rt=0; %das wird der errechnete widerstand des NTC
&nbsp; urt=0; %das wird der errechnete Spannungsabfall am NTC
&nbsp;
&nbsp; % konstanten für berechnung der Temperatur aus NTC Widerstand
&nbsp; % B25=3977K
&nbsp; a1=3.354016E-03;
&nbsp; b1=3.2569850E-04;
&nbsp; c1=2.61013E-06;
&nbsp; d1=6.38309e-08;
&nbsp; rref=2200;
&nbsp;
&nbsp;
&nbsp;
&nbsp; %Lesen eines Temperaturabhängigen Widerstandes am Analog Eingang A0
&nbsp; %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
&nbsp;
&nbsp; for x=1:50
&nbsp; analog(x)=readVoltage(a, analogpin) %Liest den AnalogIn von A0 und gibt in Volt aus
&nbsp; urt(x)=5-analog(x); %spannungsabfall am NTC
&nbsp; rt(x)=(r/analog(x))*urt(x); %widerstand des NTC
&nbsp;
&nbsp; %berechung der temperatur
&nbsp; rvsrref(x)=rt(x)/rref;
&nbsp; temp(x)=1/(a1+(b1*log(rvsrref(x)))+(c1*(log(rvsrref(x)^2)))+(d1*(log(rvsrref(x)^3))));
&nbsp; tempc(x)=temp(x)-273.15 %Kelin in Celsius umrechnen
&nbsp; pause(2);
&nbsp;
&nbsp; end
&nbsp;
&nbsp; clear a;
&nbsp;
&nbsp; %plot den mist
&nbsp; figure(1);
&nbsp; time=1:50;
&nbsp; plot(time,analog,'b');
&nbsp; grid on; hold on;
&nbsp; plot(time,rt/1000,'r');
&nbsp; plot(time,urt,'g');
&nbsp; plot(time,tempc,'m');
&nbsp; legend('Analogspannung des ADC','Widerstand des NTC in kOhm','Spannung am NTC','Temperatur [°C]'); 
&nbsp; %ende

 

 
temperaturgraph
So sieht der Graph mit dem Temperaturlog danach aus…

Arduino mit Matlab … Startschwierigkeiten

Loading

arduino01 (4)Heute möchte ich ein Thema vorstellen, mit dem ich mich kurz im Rahmen einer Recherche beschäftigt habe. Viele (Techniker) kennen vielleicht die Software Matlab von der Firma Matworks. Das ist ein extrem umfangreiches Softwarepaket, das bei uns in der Lehre eingesetzt wird, um Studierende in allen möglichen technischen Bereichen zu unterrichten. Sei es Signalverarbeitung, Regelungstechnik, Bildverarbeitung, etc. – Matlab ist das Tool, um all das professionell umzusetzen. Auch wenn es um Messdatenerfassung geht, muß man nicht unbedingt auf Tools zurückgreifen, mit denen ein Projekt oder Programm „gezeichnet“ wird. Das ist zwar toll für den Einstieg, kann (und wird) in späterer Folge aber aufgrund des riesen Overheads und der benötigten PC Resourcen viel zu umständlich, wenn man schnell einmal über eine externe Hardware irgendwelche physikalischen Größen aufzeichnen und verarbeiten will.

In diesem kleinen Projektchen möchte ich nun zeigen, wie einfach man mit Hilfe eines Arduino Uno Boards zusammen mit Matlab eine Temperaturmessung realisieren kann. Der Sensor soll hier ein ganz einfacher NTC Widerstand sein. Das bedeutet, der ohmsche Widerstand des Bauteils ändert sich mit der Temperatur, in dessen Umgebung sich das Bauteil befindet. Die Änderung passiert hier folgendermaßen: wenn die Temperatur steigt, so wird der ohmsche Widerstand kleiner. (Negativer Temperatur Koeffizient) (Coefficient engl. -> NTC). Einziger kleiner Haken – die Änderung passiert nicht linear wie zum Beispiel beim PT100. Das bedeutet der Verlauf  des Widerstands bei Änderung der Temperatur ist keine Gerade mit irgendeiner Steigung, sondern eine e-Funktion. Das wiederum bedeutet, dass, will man aus den gemessenen Widerstandwerten in eine Temperatur zurückrechnen, die Funktionsgleichung zum NTC gefunden werden muss. Glücklicherweise findet man diese aber fix und fertig in den Herstellerdatenblättern 😉 aber dazu später.

Man hat nun einen temperaturabhängigen Widerstand, ein Arduino Uno – Board und einen PC auf dem Matlab läuft. Wie geht´s nun weiter? Nehmen wir als Beispiel an, dass Matlab 2014b installiert ist. Nun gibt es in Matlab unter dem Tab „Home“ eine Rubrik, die sich „Add-Ons“ nennt. Klick man auf  diese, so klappt ein Menue auf, in dem man den Eintrag „Get Hardware Support Packages“ findet. Den klickt man an und es öffnet sich ein Fenster namens „Support Package Installer“.

Unter „Install from Internet“ und „Next>“ kommt man zu einem Auswahlmenue der verfügbaren Packages. Hier sucht man sich „Arduino“ aus und setzt im rechten Bereich des Fensters einen Haken – und zwar bei dem Paket „Aquire inputs and send outputs on Arduino Uno…“. Danach wieder auf „Next>“ klicken und die Installation vollenden.

Ist alles erledigt so kann man den Arduino am USB-Port anstecken. Windows sollte einen Treiber zuordnen. (Unter Systemsteuerung – Gerätemanger – Anschlüsse > sollte ein Arduino Uno (COMx) zu finden sein). Ist das der Fall, dann sollte es klappen 🙂

Jetzt kann in der Matlab Console folgender Befehl eingegeben werden:

arduino()

Folgende Antwort kommt nun zurück:

 arduino with properties:

Port: 'COM5'
Board: 'Uno'
AvailableAnalogPins: [0, 1, 2, 3, 4, 5]
AvailableDigitalPins: [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
Libraries: {'I2C', 'SPI', 'Servo'}

Der COM-Port unterscheidet sich natürlich und wird meist auf den nächsten freien COM gemappt. Hat das aber geklappt, so ist der erste Teil schon gewonnen. Matlab kommuniziert mit dem Arduinoboard. Es kann aber auch vorkommen, dass Fehlermeldungen auftauchen. Wie bei mir der Fall:

Cannot detect Arduino hardware. Make sure original Arduino hardware is properly plugged in. If
using unofficial(clone) hardware, specify port and board type. For more information, see the
arduino function reference page.

Das war die erste Meldung nach der Installation: Dafür gibt’s aber auch Abhilfe. Man gibt folgendes ein:

a = arduino('com5','Uno')

Wenn auch dann eine Fehlermeldung kommt, so wie natürlich bei mir, dann kann man mit folgendem commando auf Fehlersuche gehen:

 a = arduino('com5','Uno','TraceOn', true)

Jetzt kam bei mir die Meldung : Updating server code on Arduino Uno (COM5). Please wait.  Und danach gleich ein Errorfenster mit einem „avr-gcc.exe
Die Anwendung konnte nicht korrekt gestartet werden (0xc00000142)“ Fehler. Danach habe ich lange in diversen Foren gesucht, Tracelogs verglichen und nach den Fehlermeldungen gegoogelt. Hier gab es Tips von: die make.exe in den Tiefen des SupportPackages Ordner ist nicht kompatibel mit 64bit Systemen, mit Windows8.1 und Windows10 gibt es Zugriffsrechteprobleme und und und. Leider war aber nie ein Lösungsvorschlag dabei der bei mir funktionierte. Also habe ich auf einem zweiten Rechner eine jungfräuliche Installation von Matlab und dem Arduino Matlab Package durchgeführt. Und siehe da – es funktionierte. Aber wie jetzt nach dem Fehler suchen, oder ihn beheben. Also habe ich auf dem funktionierenden Rechner einen Tracelog durchgeführt, indem ich beim Aufrufen der Arduinofunktion einen Port angegeben habe, auf dem ein anderes NICHT Arudino Gerät angeschlossen ist. Und siehe da, der Errortracelog war seeehr lange und ausführlich. Man konnte ansehen was die Funktion alles aufruft. Und irgendwo ganz unten im Log las ich was von avrdude… Da kam mir die Idee. Auf meinem PC sind einige Entwicklungsumgebungen installiert. Unter anderem auch AVR-Studio und der WinAVR20100110 Compiler. Und genau der war das Problem. Den WinAVR gelöscht und schon klappte es.

Also steht dem weiteren Aufbau zur Realisierung des Projektchens nichts mehr im Weg. Aber darüber scheibe ich beim nächsten Mal in Teil 2…