Stromsensor(ACS712)

Stromversorgung und Überwachung

1.Stromsensor

 

Die Sensoren und Mikrocontroller des Zeppelins wurden in den vielen Projekten meist einzeln über einen eigenen Akku versorgt. Dies bedeutete überflüssige Bauteile, ständiges Aufladen der verschiedenen Akkus und keine Kontrolle über die Versorgung. Deshalb bot sich eine Zentralisierung und gleichzeitige Überwachung der Stromversorgung der Komponenten an. Dieser Aufgabe habe ich mich in der folgenden Ingenieurspraxis gestellt.

 

Im folgenden werden einige zur Anwendung kommende Messarten von Strom gegenübergestellt.

 

1.1 Stromsensorarten1

  • Stromwandler (AC)

  • Themische Sensoren

  • Fiber-optical-current sensor (Faraday-Effekt)

  • Magnetosresistiver Effekt

  • Shunt/Bürdewiderstand/Strommesswiderstand

  • Halleffektsensor

 

1.1.1 Stromwandler(passiv)2

Der Stromwandler ist eine Art Transformator der einen Sekundärstrom proportional zum Messstrom erzeugt. Dadurch benötigt er zum einen keine eigene Energiequelle und zum anderen kann er durch eine geeignete Windungswahl einen großen Messbereich bis in den Kiloampere Bereich abdecken. Durch seine Transformatoreigenschaft bedingt kann er aber keinen Gleichstrom messen, was ihn als Strommesser für die Anwendung am Zeppelin ungeeignet macht, da dieser ja durch einen Akku versorgt wir.

1.1.2 Thermische Sensoren

Diese Sensoren nutzen aus, dass abhängig vom Stromfluss und den Materialparametern eine gewisse Leistung in Hitze umgewandelt wird. Veralteten thermische Messgeräte sind Hitzdrahtmesswerke. Aber im Bimetall-Streifen findet sich noch ein gängiges Bauelement, vor allem für Überstromschutzeinrichtungen. Wegen der relativ großen Geräte und Ungenauigkeit bei äußeren Einflüssen im Flugbetrieb ist auch diese Anwendung nicht geeignet.

1.1.3 Faraday-Effekt3

Dieser Effekt nutzt aus, dass die Polarisationsrichtung von Licht durch das Magnetfeld eines Leiters verändert wird. Auch bei sehr hohen magnetischen Feldern erzeugt durch hohe Ströme bis zu 500 Kiloampere erhält man robuste Messungen. Durch das eingesetzte Medium Licht wird der Leiter selbst nicht beeinflusst und es liegt Potentialtrennung vor, die es erlaubt auch bei sehr hohen Spannungen eingesetzt zu werden. Wegen dieser Eigenschaften wir er vor allem in der Energietechnik und zur Messung von Blitzen eingesetzt. Zwar könnte man diesen Sensor auch zur Messung von kleineren Srömen einsetzen, doch da es sich um eine relativ neue Technik handelt und wohl auch nicht in großer Stückzahl hergestellt wird, handelt es sich hier um eine teure Anschaffung im Bereich von 200 bis 300 € pro Stück und entfällt somit ebenfalls für die Anwendung in einem Studentenprojekt.

1.1.4 Magnetoresistiver- Effekt

Hier nutzt man die Veränderlichkeit von Materialen in Abhängigkeit von Magnetfeldern aus. Der Begriff Magnetoresistiver-Effekt umfasst verschiedene atomare Effekte wie den Riesenmagnetowiderstand, der anisotrope magnetoresistive Effekt, planare Halleffekt (nicht mit dem „normalen“ Halleffekt verwechseln) und einigen weiteren Effekten. Als Komponente zur Strommessung lässt er sich sehr kompakt z.B. in ICs verwirklichen. Bei einem Messbereich von 100 Milliampere bis einigen Ampere kann diese Art Sensor nicht in der Strommessung für die Sensoren und Mikrocontroller des Zeppelins eingesetzt werden, da hier Ströme im hundertstel Milliamperebereich auftreten.

1.1.5 Shunt(AC/DC)4

Im Messwiderstand findet man die üblichste Form der Strommessung. Mit einem niederohmigen Widerstand (ca 1mOhm ) kann indirekt über die durch Verstärkerschaltungen erzeugte Spannung der druchfließende Strom gemessen werden. Der Messbereich umfasst so vor allem geringe Ströme, da der Widerstand nicht beliebig hohe Leistungen aushält ( I²·R). Über die Vierleitertechnik kann die Messabweichung der Leitungs-und Anschlusswiderstände kompensiert werden. Schwankende Widerstandseigenschaften (Temparatur, Magnetfeld, etc.) erhöhen Fehlerteufel die Messungenauigkeiten. Zudem muss man zwischen Messung an High oder Low (Masse) unterscheiden, bei denen verschiedene Einschränkungen vorliegen. Wegen des zusätzlichen Widerstandes im Schaltungspfad, der zu unerwünschten Lasteffekten und veränderlichen Messgenauigkeiten führt, schien es mir ratsam eine zuverlässigere Messmethode zu finden.

1.1.6 Halleffektsensor(AC/DC)

Der Halleffekt erzeugt durch Anlegen eines senkrechten Magnetfeldes ein elektrisches Potential im stromduchflossenen Leiter, das proportional abhängig vom Strom ist. Dadurch wird der Stromfluss nur auf vernachlässigbare Weise beeinflusst und bleibt ideal. So hat man freie Wahl an welcher Stelle der Leiter man misst. Einzige Einschränkungen sind externe Magnetfelder. Diese Sensoren ermöglichen Messungen vom Milliamperebereich bis einige Ampere. Aus diesen Gründen und der kompakten den kompakten Bauweisen, erschien mir diese Art der Messung am geeignetsten für meine Anforderumg.



Nun wird die Messung mit dem Sensor näher erläutert.

1.2. Hallsensor ACS712

Grundsätzlich gibt es den ACS712 für verschiedene Strombereiche von peak-to-peak 10A (-5A bis 5A ) bis mindestens 60A mit je einer Versorgungsspannung von 5V. In meinem Aufbau verwende ich den kleinsten Messbereich 10A, wobei bei der Stromversorgung nicht mit so hohen Strömen zu rechnen ist. Das ist dadurch bedingt, dass ich nur die Versorgung für die Sensoren und Mikrokontroller aufbaue, die vielleicht maximal Ströme bis 200 Milliampere(Maximalstrom durch Vcc des Mikrokontrollers) erlauben respektive benötigen. Aber entscheidend für ist nicht der Messbereich sondern die Auflösung des Sensors.

1.2.1 Sensorauflösung5

Im Datenblatt ist von einer Empfindlichkeit (Sensitivity)  von 185mV/A die Rede. Der Stromsenor liefert somit 0,185 Volt pro durchfließendem Ampere. Mit folgender Formel lässt sich daraus der Stromwert errechnen:

 

Abb.1: Ampereberechnung aus Sensordaten6

 

Der Wert 0,0049 begründet sich auf die Leistung des A/D-Wandlers des Arduinos. Mit 10 Bit kann er maximal einen Wert von 1023 bei 5Volt ausgeben. Somit ergibt 5V/1023≈ 0,0049V pro unit die der A/D-Wandler errechnet. Geteilt durch die Sensitivity erhält man dann die Auflösung in Ampere von 0,026 A . Der Rest des Terms bezieht sich auf die Offsetspannung des Sensors. Das heißt bei Nullstrom gibt der Sensor 2,5V Vout an.

 

Um nun die Auflösung des Sensors zu erhöhen könnte man die Sensitivity mit einer Verstärkerschaltung vergrößern oder einen Wandler mit mehr Bit verwenden.

 

1.2.2 Aufbau

 

Der ACS712 hat 4 Pins am Eingang und am Ausgang. Zwei Eingangspins werden dabei für einen Stromeingang verwendet. Wohl deswegen, damit bei höheren Strömen die internen Drähte nicht schmelzen. Im Bild sieht man zwar eine Polung des Stroms, doch auch bei verkehrtem Anschluss erhält man eine Ausgabe. Aber diese liegt dann negiert vor!

Abb.2 Sensorpinbelegung

Für das Projekt wurden 4 Sensoren ohne Breakoutboard gekauft. Zur Messung erstellte Fabian Kluger dazu mit der CNC-Fräse von Daedalus eine eigene Platine damit ich mit den Tests starten konnte.

 

                                                       

 

Sensorplatinenaufbau


Abb.3+4: Sensorplatinenaufbau

 

1.3 Codierung

Zum einen verfasste ich einen .ino Code für den Mikrocontroller

1.3.1 Arduino Stromcontroller-Code (Funktion den Kommentaren entnehmen)

 

#include <SPI.h>

#include <SoftwareSerial.h>

#include <test.h>

 

/************************************************************

* Programm zum Auslesen, Steuern des Stromsensors ACS712 und*

* CAN-Abfrage *

************************************************************/

 

/////////////////GLOBALE VARIABLEN///////////////////////////////////////////////////////////////

 

CANClass CAN;

 

//Datenfeld für den CAN zum senden und empfangen

byte datenfeld_transmit[20];

byte datenfeld_receive[20];

 

//Länge der zu übermittelnden Datenfelder

int laenge_transmit = 11;

int laenge_receive = 11;

 

//Zaehler für Abfrage vom Controller nach einer bestimmten Durchlaufzahl

int CAN_count = 0;

 

//Zaehler für Stromunterbrechung bei fehlender Antwort des Empfängers

int stop_count = 0;

 

//Steuert den einmaligen Reset

int reset = 1;

 

//int zaehler = 0;

 

//AnalogPin zur Strommessung

int an_pin_Sens_1 = 1;

int an_pin_Sens_2 = 2;

 

//Null init

double normierung_Sens_1= 0.0;

double normierung_Sens_2= 0.0;

 

//Stromwert in Ampere

float average_Sens_1 =0.0;

float average_Sens_2=0.0;

 

//DigPin zur Stromsteuerung

int dig_pin_Sens_1 = 3;

int dig_pin_Sens_2 = 5;

 

//Einstellen der erlaubten Ströme in Ampere

int maximal_Strom_Sens_1 = 0.3;

int maximal_Strom_Sens_2 = 0.3;

//////////////////////////////////////////////////////////////////////////////////////////////

void setup() {

 

// CAN-Bus_initialisierung/Adresszuweisung

int adresse_Strom_controller = 0xFF;

CAN.init_adres(adresse_Strom_controller);

 

 

//Mosfetsteuerpins_initialisierung

pinMode(dig_pin_Sens_1,OUTPUT);

pinMode(dig_pin_Sens_2,OUTPUT);

 

digitalWrite(dig_pin_Sens_1, LOW);

digitalWrite(dig_pin_Sens_2, LOW);

 

Serial.begin(9600);

 

//Durch das LOW Schalten oben gilt der folgende Text nicht mehr!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

/* !!!!: Wenn der Arduino Serial über USB ausliest wird init wird bei jedem Aufruf des Serials (auch über Matlab)

der Ausgabewert auf 0 gelegt, d.h. auch wenn ein Strom schon vorher floss.

Nur die Änderung wird also erkannt.

Das Problem kann durch das Auslesen der Daten über TX/RX (Dig.Pin 1/0) mitHilfe eines "MikroUSB"FDTI-Adapters verhindert werden.

*/

/* Nullsetzen wegen Ungenauigkeit bei Klemmenanschluss(zB. bei Anschluss vom Netzteil zum testen reagiert er

obwohl kein Strom fließt).

*/

//SENSOR 1

for(int i = 0; i < 1000; i++) {

average_Sens_1 = average_Sens_1+(.0264 * (analogRead(an_pin_Sens_1))-13.62);

delay(1);

}

average_Sens_1 = average_Sens_1/1000;

normierung_Sens_1= 13.62+average_Sens_1;

 

//SENSOR 2

for(int i = 0; i < 1000; i++) {

average_Sens_2 = average_Sens_2+(.0264 * (analogRead(an_pin_Sens_2))-13.62);

delay(1);

}

average_Sens_2 = average_Sens_2/1000;

normierung_Sens_2= 13.62+average_Sens_2;

 

//Mathematische Umrechnung siehe Dokumentation zur Sensorauflösung

}

 

void loop() {

 

///////////////////////////////////////CAN////////////////////////////////////

///////////////////////////TRANSMIT///////////////////////////////////////////

if(CAN_count == 10){

 

int empfaenger_adresse_1 = 0xA0;

 

// Serial.print("(Stop_count =");

// Serial.print(stop_count);

// Serial.println(")");

 

Serial.println("Lebscht no?");

 

//für den Übertragungstext "Lebscht no?":

/*Übertragungsdaten*/

 

datenfeld_transmit[0] = 'L';

datenfeld_transmit[1] = 'e';

datenfeld_transmit[2] = 'b';

datenfeld_transmit[3] = 's';

datenfeld_transmit[4] = 'c';

datenfeld_transmit[5] = 'h';

datenfeld_transmit[6] = 't';

datenfeld_transmit[7] = ' ';

datenfeld_transmit[8] = 'n';

datenfeld_transmit[9] = 'o';

datenfeld_transmit[10] = '?';

 

CAN.send(datenfeld_transmit, empfaenger_adresse_1, laenge_transmit);

CAN_count = 0;

stop_count += 1;

 

if(stop_count >3){

Serial.println("Keine Reaktion von Last 1 -> Dauerhaft Abgeschaltet"); //Ausgabe wenn keine Antwort ankommt

}

}

/////////////////////////////////////////////////////////////////////////////////////////////

 

////////////////////////////RECEIVE//////////////////////////////////////////////////////////

CAN.receive(datenfeld_receive, &laenge_receive);

 

//Abfrage ob erlaubte Daten empfangen wurden

if(datenfeld_receive[0] == 'A' && datenfeld_receive[9] == 'r' && stop_count!= 0){ //von "Alles klar!"

/*Ausgabe der empfangenen Daten*/

int i;

 

Serial.print("Antwort von Empfaenger1:");

for(i= 0; i<laenge_receive ; i++){

Serial.print((char)datenfeld_receive[i]);

datenfeld_receive[i]=0; //Zum Buffer löschen

}

Serial.println("");

 

stop_count = 0;

}

/////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////SENSOREN///////////////////////////////////

float average_Sens_1 = 0;

float average_Sens_2 = 0;

 

//SENSOR 1

for(int i = 0; i < 1000; i++) {

average_Sens_1 = average_Sens_1 + (.0264 * (analogRead(an_pin_Sens_1))-normierung_Sens_1);

}

average_Sens_1 = average_Sens_1/1000;

 

//SENSOR 2

for(int i = 0; i < 1000; i++) {

average_Sens_2 = average_Sens_2 + (.0264 * (analogRead(an_pin_Sens_2))-normierung_Sens_2);

}

average_Sens_2= average_Sens_2/1000;

////////////////////////////////////////

// lineares Fehlerverhalten ausgleichen

//SENSOR 1

average_Sens_1 = average_Sens_1+ (average_Sens_1/9);// evtl. noch mindern,aber exakt ab ca 0.5 Ampere

////////////////////////////////////////

////////////////////////////////////////

// lineares Fehlerverhalten ausgleichen

//SENSOR 2

average_Sens_2 = average_Sens_2+ (average_Sens_2/9);// evtl. noch mindern,aber exakt ab ca 0.5 Ampere

////////////////////////////////////////

 

Serial.print(average_Sens_1,4);

// Serial.print('A'); //Bei Auslesen über Matlab "A" kommentieren!

 

Serial.print('\t');

Serial.println(average_Sens_2,4);

// Serial.println('A'); //Bei Auslesen über Matlab "A" kommentieren!

 

/////////////////////////////////////////////////////////////////////////////////////////

//////////////////////////MOSFETSTEUERUNG//////////////////////////////////

 

if (average_Sens_1 < maximal_Strom_Sens_1){

digitalWrite(dig_pin_Sens_1, HIGH);//Test mit LED: Blinken pro loop

}

else{

digitalWrite(dig_pin_Sens_1, LOW);

}

 

// if (zaehler <30){ //Test mit Arduino über zaehler gesteuert

// digitalWrite(dig_pin_Sens_2, HIGH);

// }

 

if(stop_count < 3 && average_Sens_2 < maximal_Strom_Sens_2){

digitalWrite(dig_pin_Sens_2, HIGH);//Test mit Arduino über CAN-Businfo gesteuert

 

if(reset == 2){

reset=3;

}

 

}

else if(stop_count > 2 && reset == 1){

digitalWrite(dig_pin_Sens_2, LOW);//Test mit Arduino

stop_count = 0;

reset += 1;

Serial.println("Keine Reaktion von Last 1 -> Reset");

delay(50);

}

else{

digitalWrite(dig_pin_Sens_2, LOW);

}

 

/////////////////////////////////////////////////////////////////////////////

 

digitalWrite(dig_pin_Sens_1, LOW); //Test mit LED

 

// if(zaehler >= 30){

// digitalWrite(dig_pin_Sens_2, LOW); // Test mit Arduino

// }

//zaehler = zaehler +1;

 

CAN_count = CAN_count +1;

delay(50);

}

}

 

}

else if(stop_count > 2 && reset == 1){

digitalWrite(dig_pin_Sens_2, LOW);//Test mit Arduino

stop_count = 0;

reset += 1;

Serial.println("Keine Reaktion von Last 1 -> Reset");

delay(50);

}

else{

digitalWrite(dig_pin_Sens_2, LOW);

}

/////////////////////////////////////////////////////////////////////////////

 

////////////////////////////SENSOREN///////////////////////////////////

float average_Sens_1 = 0;

float average_Sens_2 = 0;

 

//SENSOR 1

for(int i = 0; i < 1000; i++) {

average_Sens_1 = average_Sens_1 + (.0264 * (analogRead(an_pin_Sens_1))-normierung_Sens_1);

}

average_Sens_1 = average_Sens_1/1000;

 

//SENSOR 2

for(int i = 0; i < 1000; i++) {

average_Sens_2 = average_Sens_2 + (.0264 * (analogRead(an_pin_Sens_2))-normierung_Sens_2);

}

average_Sens_2= average_Sens_2/1000;

 

 

////////////////////////////////////////

// lineares Fehlerverhalten ausgleichen

//SENSOR 1

average_Sens_1 = average_Sens_1+ (average_Sens_1/9);// evtl. noch mindern,aber exakt ab ca 0.5 Ampere

////////////////////////////////////////

////////////////////////////////////////

// lineares Fehlerverhalten ausgleichen

//SENSOR 2

average_Sens_2 = average_Sens_2+ (average_Sens_2/9);// evtl. noch mindern,aber exakt ab ca 0.5 Ampere

////////////////////////////////////////

 

Serial.print(average_Sens_1,4);

// Serial.print('A'); //Bei Auslesen über Matlab "A" kommentieren!

 

Serial.print('\t');

Serial.println(average_Sens_2,4);

// Serial.println('A'); //Bei Auslesen über Matlab "A" kommentieren!

 

/////////////////////////////////////////////////////////////////////////////////////////

 

digitalWrite(dig_pin_Sens_1, LOW); //Test mit LED

 

// if(zaehler >= 30){

// digitalWrite(dig_pin_Sens_2, LOW); // Test mit Arduino

// }

//zaehler = zaehler +1;

 

CAN_count = CAN_count +1;

delay(50);

}

 

1.3.2. Arduino Last-Code

/*Code für gesteuerten Arduino*/

 

#include <SPI.h>

#include <stdlib.h>

#include <stdio.h>

#include <SoftwareSerial.h>

#include <test.h>

 

CANClass CAN;

 

void setup() {

Serial.begin(9600); //Baudrate einstellen

int adresse_empfaenger_1= 0xA0; //Adresse des Arduinos einstellen (Zweistellig Hexadezimal)

CAN.init_adres(adresse_empfaenger_1); //Adresse übergeben damit Filter gesetzt werden können

}

//Globale Variablen

int adresse_Strom_controller = 0xFF;

 

byte datenfeld_transmit[20];

byte datenfeld_receive[20]; //Datenfeld erstellen um dort die ankommenden Daten zu speichern

 

static int laenge_transmit = 11; //In dieser Variable kann die Länge ausgelesen werden

static int laenge_receive = 11;

 

int gesendet=0;

int empfangen = 0;

 

void loop(){

 

CAN.receive(datenfeld_receive, &laenge_receive); //Befehl zum Empfange, dafür ist nötig das Datenfeld und die Variable,

 

//Nachrichtenauswertung

if(datenfeld_receive[0] == 'L'){ //L von Lebscht no?

 

empfangen == 1;

Serial.print("Controller fraegt: ");

int i;

for(i=0; i<laenge_receive ;i++){ //Ausgabe des Datenfeldes

Serial.print((char)datenfeld_receive[i]);

}

Serial.println("");

//Text: "Alles klar!"

/*Übertragungsdaten*/

datenfeld_transmit[0] = 'A';

datenfeld_transmit[1] = 'l';

datenfeld_transmit[2] = 'l';

datenfeld_transmit[3] = 'e';

datenfeld_transmit[4] = 's';

datenfeld_transmit[5] = ' ';

datenfeld_transmit[6] = 'k';

datenfeld_transmit[7] = 'l';

datenfeld_transmit[8] = 'a';

datenfeld_transmit[9] = 'r';

datenfeld_transmit[10] = '!';

 

CAN.send(datenfeld_transmit, adresse_Strom_controller ,laenge_transmit);

gesendet = 1;

Serial.println(" ");

}

else{

Serial.println("Keine Anfrage erhalten!");

Serial.println(" ");

empfangen == 0;

gesendet == 0;

}

//delay der den restlichen Code simuliert

delay(500);

}



1.3.3. Matlabcode zur graphischen Darstellung (Funktion den Kommentaren entnehmen)

function [strom_history]= Matlab_Arduino(anzahl_messwerte,Port)

 

%Nicht gleichzeitig Arduino Serial öffnen !!! Sonst Interferrieren beide Fenster.

 

%% Bisherige Ports schließen und neuen Port öffnen

close all;

clc;

delete(instrfind({'Port'},{Port}));

 

%"Port" Parameter zB. '/dev/ttyUSB0'

serial_port = serial(Port);

 

warning('off', 'MATLAB:serial:fscanf:unsuccessfulRead');

 

%Oeffnen des Ports

fopen(serial_port);

%--------------------------------------------------

 

%% Plotten und Auslesen

strom_history = zeros(1, anzahl_messwerte,2);

strom1_history = zeros(1,anzahl_messwerte); %Datenvektor1

strom2_history = zeros(1,anzahl_messwerte); %Datenvektor2

 

zaehler = 1;

 

%Graph

figure('Name','Serial communication')

title('SERIAL COMMUNICATION MATLAB+ARDUINO');

 

%Einzelne Messwerte auslesen bis zur gewünschten Anzahl der Messungen.

while zaehler <= anzahl_messwerte

 

%Auslesen und zwischenspeichern

zwischenspeicher = fscanf(serial_port,'%g %g');

 

subplot(1,2,1);

 

grid on;

hold on;

 

xlabel('Messung');

%ylabel('Ampere');

ylabel('MilliAmpere');

 

%ylim([-3 3 ]); %Maxima des ACS712 sind aber -5A und 5A !

%set(gca, 'YTick',-3.0:0.5:3.0);

ylim([-100 100]);

set(gca, 'YTick',-100:20:100);

 

xlim([zaehler-40 zaehler+5]);

 

%Wegen CAN-Abfragen Asci werte der Buchstabe im Zwischenspeicher!

%Da Stromwert nicht über 10 Ampere vom Akku->

if zwischenspeicher(1) < 10

 

strom1_history(zaehler) = zwischenspeicher(1);

%serial_wert = fscanf(serial_port, '%d');

%strom_history(zaehler) = (0.0264*serial_wert(1)-13.52);

plot(zaehler, 1000*strom1_history(zaehler), '*-r');

 

%Sensor2

subplot(1,2,2);

 

grid on;

hold on;

 

xlabel('Messung');

 

%ylabel('Ampere');

ylabel('MilliAmpere');

 

%ylim([-3 3 ]); %Maxima des ACS712 sind aber -5A und 5A !

%set(gca, 'YTick',-3.0:0.5:3.0);

ylim([-100 100]);

set(gca, 'YTick',-100:20:100);

 

xlim([zaehler-40 zaehler+5]);

%Wegen CAN-Abfragen Asci werte der Buchstabe im Zwischenspeicher!

 

 

 

strom2_history(zaehler) = zwischenspeicher(2);

%serial_wert = fscanf(serial_port, '%d');

%strom_history(zaehler) = (0.0264*serial_wert(1)-13.52);

plot(zaehler, 1000*strom2_history(zaehler), 'x-g');

drawnow

 

zaehler = zaehler+1;

 

end

end

%----------------------------------------------------------------

%% Abspeichern und Schließen

strom_history(:,:,1) = strom1_history;

strom_history(:,:,2) = strom2_history;

 

 

fclose(serial_port);

delete(serial_port);

%---------------------------------------

end

2. Stromversorgung

Da nun der Überblick und die Codierung für die Sensoren abgeschlossen war, galt es die Stromversorgung anzugehen. Die grundsätzliche Überlegung war es für den Zeppelinflug eine mobile und überwachte Stromversorgungseinheit zu entwickeln.

2.1. Schaltplan

Zur Verfügung stand ein Akku mit 14,8V der auf die für die Sensoren und Mikrocontroller nötigen Spannungen von 5V und 3,3V herunter geregelt werden musste. Die einzelnen Lasten sollten dann über je einen Stromsensor versorgt werden. Zudem zeigt eine LED an, ob Strom fließt. Die Steuerung übernehmen MOSFETs da ein Transistor mit seinem Durchbruchstrom die Messung verfälschen könnte. Insgesamt stehen in dem von mir erstellten Schaltplan vier Anschlüsse für 3,3V-Lasten und zwei für 5V zur Verfügung. Pinbelegungen sind dem Schaltplan und dem Arduinocode zu entnehmen.

 Schaltplan der Stromversorgung mit Stromsensor

Abb.5 Schaltplan der Stromversorgung mit Stromsensor (Eagle)

 

2.2. Steuerung

Wie im Code zu erkennen ist gibt es zwei Steuerprinzipien der Stromversorgung.

2.2.1. Sensorsteuerung

Fast jedes Bauteil von Mikorkontrollern bis zu LEDs braucht einen gewissen Strom und erlaubt auch nur einen gewissen Maximalwert. Darüber hinaus geht das Bauteil kaputt. Mit Hilfe des Stromsensors lässt sich nun messen wie groß der Wert ist der von den Lasten gezogen wird. Will man verhindern, dass ein zu großer Strom zu lange fließt kann man über die Variablen „maximal_Strom_Sens_NummerdesSensors“ diesen Wert festlegen und der Steuermikrocontroller schaltet den MOSFET, damit die Versorgung unterbrochen wird. 

 

Abb.6 Strommessung einer LED (links) und gesteuerte Strommessung eines Arduinos (rechts)

2.2.2. CAN-Steuerung

Zunächst muss dem Mikrocontroller der als Last wirkt der Code aus dem Programm „CAN_Strom_receiver“ in der Schleife hinizugefügt werden.Benutzt wird hierbei zur CANduino Bibliothek  die CANdalus7- Erweiterung, welche in einem parallelem Praktikum angefertigt wurde.

 

 

Unter Ausnutzung der CAN-Bus Kommunikation wird dann überprüft ob der versorgte Mikrocontroller ordnungsgemäß seine Schleifen durchläuft und so auch auf Anfragen über den CAN-Bus antwortet. Sollte sich der Mikrocontroller in einer Endlosschleife gefangen haben oder anderweitig seine Funktion nicht mehr erfüllen, findet keine Kommunikation mehr zwischen den Controllern statt. Dies wird erkannt und ein Reset in Form von zweimaligem Schalten des zuständigen MOSFETS wird durchgeführt. Sollte diese Maßnahme zu keiner Besserung führen wird nach einer gewissen Wartezeit die Stromzufuhr entgültig gekappt.

 


Quellen:

1 de.wikipedia.org/wiki/Stromsensor

2 http://www.mikrocontroller.net/articles/Stromwandler

3 Siehe Anhang 1 und Anhang 2

4 http://www.elektroniknet.de/messen-testen/sonstiges/artikel/84373/

5 http://www.lionprecision.com/tech-library/technotes/article-0010-sensor-resolution.html oder http://arduino.cc/forum/index.php?PHPSESSID=2095ab88c80f3acc104d57c2c333e127&topic=127917.0

6 http://www.lucadentella.it/en/2011/11/29/sensore-di-corrente-con-arduino/

http://www.daedalus.ei.tum.de/index.php/de/dokumentation/projekte/komm-struktur/candalus

 

Anhänge:
Diese Datei herunterladen (FiberOpticCurrentSens.pdf) Anhang1: FiberOpticalCurrentSens[ ]%2013-%04-%17 %1:%Apr%+02:00
Diese Datei herunterladen (SENSOR_CONF_fiber_optic_current_sensor.pdf)Anhang2: SENSOR_CONF_fiber_optic_current_sensor[ ]%2013-%04-%17 %1:%Apr%+02:00