Anscheinend hat der Code so auch schon funktioniert ......
#include "U8glib.h"
#include <Encoder.h>
Encoder myEnc(3, 2); //Pins für Hall Sensor von Motor. Blau = 3, Violett = 2
U8GLIB_SSD1306_128X64 u8g(U8G_I2C_OPT_NO_ACK); // I2C / TWI
///////////////////////////Libarys//////////////////////////////////////////////
/// Druck Ausgabe ist in Programm eingebaut, jedoch ausgeklammert.
////////////////////Variabeln Ausgabe/Eingabe/Einterne Rechnung///////////////////////////////////
unsigned int vierhundert = 400;
unsigned int siebenhunderdreisig = 730;
unsigned int valuefrequency = 0 ;
unsigned int static_frequenz = 1;
unsigned int static_volume = 1;
unsigned int static_sruck = 1;
unsigned int valuedruck = 0;
unsigned int wert = 0;
unsigned int wert2 = 0;
unsigned int wert3 = 0;
int umschaltung = 0;
int volumendisplayausgabemanuellumschaltung = 1;
int ausgabevolumen = 0;
int static_betrieb = 0;
int manuelll = 0;
long entgueltigermanuellpunkt = 0 ;
unsigned int wertmagnetsensor = 0;
unsigned int eingabefrequenzalter = 0;
int gewichtmanuellautomatik;
unsigned int timerfrequenz = 0;
unsigned int timergewicht = 0;
unsigned int alterausgabe = 0;
unsigned int gewichtsausgabe;
unsigned int gewichtausgabeanzeige;
int manuellumschaltungbetrieb = 1;
unsigned int frequenzausgabe = 17;
unsigned int manuellfrequenzwert = 0;
unsigned long manuelleanalogeeingabe = 0;
unsigned int manuellbetriebaktivieren = 0;
unsigned long manuellvolumeneingabevonpin = 0;
unsigned long variabelmanuellanzeige = 0;
int ausgabemanuellevolumen;
int pwmwertausgabe = 0;
int manuellbetrieb = 0;
unsigned int GSerreicht = 0;
long wertpositionarbeit;
long wertarbeitsstellung;
long newPosition;
long zaehlervolumen = 0;
int decoderausgabe = 0;
long wechsel = 0;
int programmstart = 0;
long variablewert;
long variableausgabe;
int sensorwert = 0;
int pwmwertausgabezufahren;
int pwmwertausgabeauffahren; /////////////////////////////
long decoderwert = 0; ///////Wichtige für die Fahrweite von GS in Ambo
long variableausgabezwei = 0; /////////////////////////////
int manuellesvolumen ;
///////////////////////////////////////////////////////////////
///////////////////Ein-Ausgangspins////////////////////////////
int PWMpin = 11;
int dir = 7;
int pinmagentsensor = 9;
int pin = A0;
int pin2 = A1;
int pin3 = A2;
int pinmanuelleeingabe = 4; ////Für Manuelle Eingabe
////////////////////////////////////////////////////////////////
////////////////////Setup///////////////////////////////////////
void setup() {
Serial.begin(9600);
pinMode(pin, INPUT); //Poti 1 Für Frequenz und Alter
pinMode(pin2, INPUT); //Poti 2 Für Volumen und Gewicht
pinMode(pin3, INPUT); //Poti 3 Für Druck
pinMode(pinmagentsensor, INPUT); //Magnetsensor Hall
pinMode(dir, OUTPUT); //Dir Für Motorsteuerung
pinMode(PWMpin, OUTPUT); //PWM Augabe
pinMode(pinmanuelleeingabe, INPUT); //Taster für Manuelle Einstellung
/////////////////////////////////////////////////////////////////////////
////////////////Ausführen der Ersten Seite///////////////////////////////
u8g.firstPage();
do {
anfang();
} while ( u8g.nextPage());
delay(5000);
}
/////////////////////////////////////////////////////////////////////////
void eingabealterzahl() {
u8g.drawStr(2, 10, "Bitte Alter eingeben");
u8g.drawStr(2, 20, "Wird nach 30 sek.");
u8g.drawStr(2, 30, "auto. uebernommen");
u8g.drawStr(75, 55, "Jahre");
u8g.setFont(u8g_font_timB14);
}
////////////////Eingabe Alter in Display /Text/ mit umrechnung Alter////////////
void eingabealtertext() {
u8g.setPrintPos(40, 55);
u8g.print(alterausgabe);
u8g.setFont(u8g_font_fixed_v0);
if ((wert >= 0) && (wert <= 45)) {
alterausgabe = 16;
}
else if ((wert >= 64) && (wert <= 90)) {
alterausgabe = 20;
}
else if ((wert >= 91) && (wert <= 135)) {
alterausgabe = 25;
}
else if ((wert >= 136) && (wert <= 180)) {
alterausgabe = 30;
}
else if ((wert >= 181) && (wert <= 225)) {
alterausgabe = 35;
}
else if ((wert >= 226) && (wert <= 270)) {
alterausgabe = 40;
}
else if ((wert >= 271) && (wert <= 315)) {
alterausgabe = 45;
}
else if ((wert >= 316) && (wert <= 360)) {
alterausgabe = 50;
}
else if ((wert >= 361) && (wert <= 405)) {
alterausgabe = 55;
}
else if ((wert >= 406) && (wert <= 450)) {
alterausgabe = 60;
}
else if ((wert >= 451) && (wert <= 495)) {
alterausgabe = 65;
}
else if ((wert >= 456) && (wert <= 540)) {
alterausgabe = 70;
}
else if ((wert >= 541) && (wert <= 585)) {
alterausgabe = 75;
}
else if ((wert >= 586) && (wert <= 630)) {
alterausgabe = 80;
}
else if ((wert >= 631) && (wert <= 675)) {
alterausgabe = 85;
}
else if ((wert >= 676) && (wert <= 750)) {
alterausgabe = 90;
}
wert = analogRead(pin);
delay(10);
}
//////////////////////////////////////////////////////////////////////
//////////////////Wert für geschwindigkeit////////////////////////////
long oldPosition = -999;
//////////////////////////////////////////////////////////////////////
void eingabegewichtzahl() {
u8g.drawStr(2, 10, "Bitte Gewicht eingeben");
u8g.drawStr(2, 20, "Nach 30 sek. wird");
u8g.drawStr(2, 30, "Programm gestartet");
u8g.drawStr(80, 55, "Kg");
u8g.setFont(u8g_font_timB14);
}
//////////////////Eingabe Gewicht in Display mit Umrechnung in KG/////
void eingabegewicht() {
u8g.setPrintPos(50, 55);
u8g.print(gewichtsausgabe);
u8g.setFont(u8g_font_fixed_v0);
if ((wert2 >= 0) && (wert2 <= 36)) {
gewichtsausgabe = 35;
}
else if ((wert2 >= 37) && (wert2 <= 72)) {
gewichtsausgabe = 40;
}
else if ((wert2 >= 73) && (wert2 <= 108)) {
gewichtsausgabe = 45;
}
else if ((wert2 >= 109) && (wert2 <= 144)) {
gewichtsausgabe = 50;
}
else if ((wert2 >= 145) && (wert2 <= 180)) {
gewichtsausgabe = 55;
}
else if ((wert2 >= 181) && (wert2 <= 216)) {
gewichtsausgabe = 60;
}
else if ((wert2 >= 217) && (wert2 <= 252)) {
gewichtsausgabe = 65;
}
else if ((wert2 >= 253) && (wert2 <= 288)) {
gewichtsausgabe = 70;
}
else if ((wert2 >= 289) && (wert2 <= 324)) {
gewichtsausgabe = 75;
}
else if ((wert2 >= 325) && (wert2 <= 360)) {
gewichtsausgabe = 80;
}
if ((wert2 >= 361) && (wert2 <= 396)) {
gewichtsausgabe = 85;
}
else if ((wert2 >= 397) && (wert2 <= 432)) {
gewichtsausgabe = 90;
}
else if ((wert2 >= 433) && (wert2 <= 468)) {
gewichtsausgabe = 95;
}
else if ((wert2 >= 479) && (wert2 <= 504)) {
gewichtsausgabe = 100;
}
else if ((wert2 >= 505) && (wert2 <= 540)) {
gewichtsausgabe = 105;
}
else if ((wert2 >= 541) && (wert2 <= 576)) {
gewichtsausgabe = 110;
}
else if ((wert2 >= 577) && (wert2 <= 612)) {
gewichtsausgabe = 115;
}
else if ((wert2 >= 613) && (wert2 <= 648)) {
gewichtsausgabe = 120;
}
else if ((wert2 >= 649) && (wert2 <= 684)) {
gewichtsausgabe = 125;
}
else if ((wert2 >= 685) && (wert2 <= 750)) {
gewichtsausgabe = 130;
}
wert2 = analogRead(pin2);
delay(10);
}
////////////////////////////////////////////////////Loop/////////////////////////////////////////////////////////////////////////////////////////////////
void loop(void) {
/////////////////Eingang Werte Poti + Sensoren + Taster////////////////////////////////////////
wert = analogRead(pin);
wert2 = analogRead(pin2);
wert3 = analogRead(pin3);
wertmagnetsensor = digitalRead(pinmagentsensor);
manuellbetriebaktivieren = digitalRead(pinmanuelleeingabe);
manuellvolumeneingabevonpin = analogRead(pin2);
////////////////////////////////////////////////////////////////////////
//////////////////// Manuellbetrieb////////////////
if (manuellbetriebaktivieren == 1)
{
manuellfrequenzwert ++; ////////////////////
} //Manuelle Eingabe wird hier aktieviert über Button"manuellbetriebaktivieren"
else if (manuellfrequenzwert >= 2) { ////////////////////
manuellfrequenzwert = 0;
}
///////////////////////////////////////////////////////////////////
/////////////////Timer für Parametereinstellung Alter////////////////////
eingabefrequenzalter ++;
if (eingabefrequenzalter >= 1 && timerfrequenz <= 400) {
u8g.firstPage();
do {
eingabealtertext();
eingabealterzahl();
timerfrequenz ++;
} while ( u8g.nextPage());
}
///////////////////////////////////////////////////////////////
//////////////////Timer für Parametereinstellung Gewicht//////////////////////////////
if ( timerfrequenz >= 401 && timergewicht <= 1300) {
u8g.firstPage();
do {
eingabegewicht();
eingabegewichtzahl();
timergewicht ++;
} while ( u8g.nextPage());
}
///////////////////////////////////////////////////////////////
///////////////Ausgabe Hauptdisplay////////////////////////////
if (timergewicht >= 1301) {
u8g.firstPage();
do {
//druck();
volumen();
frequenz();
if (manuellfrequenzwert <= 0 ) {
if (manuellumschaltungbetrieb == 1) {
wertvolumen();
manuelll = 0;
}
wertfrequenz();
wertvolumenmanuellumschaltung();
betriebanzeigeautomatik();
}
if (manuellfrequenzwert >= 1) {
volumenmanuell();
manuelll = 1;
wertmanuellfrequenz();
betriebanzeigemanuell();
}
unterstrich();
//wertdruck();
Einheithz();
Einheitml();
//Einheitmbar();
} while (u8g.nextPage());
///////////////////////////////////////////////////////////////////////////
//////////////////Ausgabe Refferenzpunkt anfahren in Grundstellung//////////////////////////////
sensorwert = digitalRead(pinmagentsensor);
if (programmstart == 0 && sensorwert == 1) {
analogWrite(11, 30);
digitalWrite(dir, HIGH);
}
if (sensorwert == 0 && programmstart == 0) {
variablewert = newPosition ; ///////////////////////////////////
variableausgabe = 1350 + variablewert; //1250 Impulse bis zum Ambo, kann je nach Ambo Variieren //Hier Mittlerer Ambo, 1500ml
programmstart = 1; //Ambo mit 2500ml hat den wert 1350
analogWrite(11, 0); ///////////////////////////////////
}
//////////////////////////////////////////////////////////////////////////
///////////////////////Bewegung Frequenz Ausgabe /////////////////////////////////////////
if (programmstart == 1) {
if (newPosition <= variablewert && wechsel == 0 && static_betrieb == 0) {
analogWrite(11, 50);
digitalWrite(dir, LOW);
}
if (newPosition >= variableausgabe && wechsel == 0 && static_betrieb == 0) {
wechsel = 1;
}
if (wechsel == 1) {
analogWrite(11, 0);
digitalWrite(dir, HIGH);
GSerreicht = 1;
wechsel = 0;
wertpositionarbeit = newPosition; ////////////////////
wertarbeitsstellung = wertpositionarbeit + decoderausgabe; //Decoderwert Impulse vom Ambo auußenseite bis Innen,
if (newPosition <= 0) { //kann je nach Ambo Variieren
wechsel = 0; ////////////////////
}
}
if (GSerreicht == 1 && manuelll == 0) {
if (newPosition <= wertpositionarbeit ) {
analogWrite(11, pwmwertausgabezufahren);
digitalWrite(dir, LOW);
static_betrieb = 1;
}
if (newPosition >= wertarbeitsstellung) {
analogWrite(11, pwmwertausgabezufahren / 2);
digitalWrite(dir, HIGH);
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////manuellbetrieb Volumen/////////////////////////////////////////////////////
entgueltigermanuellpunkt = wertpositionarbeit - newPosition + ausgabevolumen;
if (manuelll == 1) {
if (newPosition <= wertpositionarbeit ) {
analogWrite(11, pwmwertausgabezufahren);
digitalWrite(dir, LOW);
}
else if (newPosition >= entgueltigermanuellpunkt) {
analogWrite(11, pwmwertausgabezufahren / 2);
digitalWrite(dir, HIGH);
}
}
}
}
newPosition = myEnc.read();
if (newPosition != oldPosition) {
oldPosition = newPosition;
}
Serial.println(decoderausgabe);
Serial.print("...");
Serial.println(wertpositionarbeit);
u8g.setFont(u8g_font_unifont);
u8g.setPrintPos(80, 60);
u8g.print(gewichtmanuellautomatik);
////////////////////////Ausgabe Frequenz, wie schnell pro Minute//////////////////////////////////////
if (frequenzausgabe == 13) {
pwmwertausgabezufahren = 27; ///Neue Frequenz für test schneller zu
}
if (frequenzausgabe == 14) {
pwmwertausgabezufahren = 29;
}
if (frequenzausgabe == 15) {
pwmwertausgabezufahren = 33;
}
if (frequenzausgabe == 16) {
pwmwertausgabezufahren = 34;
}
if (frequenzausgabe == 17) {
pwmwertausgabezufahren = 37;
}
if (frequenzausgabe == 18) {
pwmwertausgabezufahren = 33;
}
if (frequenzausgabe == 19) {
pwmwertausgabezufahren = 37;
}
//////////////////Volumensteuerung Ausgabe//////////////////////////////////////////////////
decoderausgabe = decoderwert;
gewichtmanuellautomatik = ausgabemanuellevolumen;
Serial.print(ausgabemanuellevolumen);
}
/////////////////////////////////////////////////////////Ende Loop/////////////////////////////////////////////////////////////////////////////////////////////
///////////////////Wird Gestartet Setup_1. Anzeige//////////////////////////
void anfang() {
u8g.drawStr(5, 15, "!!Achtung!!");
u8g.drawStr(5, 30, "Stellen Sie die");
u8g.drawStr(5, 45, "Parameter auf den");
u8g.drawStr(5, 60, "Patienten ein");
u8g.setFont(u8g_font_fixed_v0);
}
/////////////////////////////////////////////////////////////////////////
///////////////////"Frequenz" Ausgabe Display//////////////////////////////
void frequenz() {
u8g.setFont(u8g_font_unifont);
u8g.setPrintPos(2, 38);
u8g.print("Frequenz");
}
////////////////////////////////////////////////////////////////
//////////////////"Volumen" Ausgabe Display///////////////////////////////
void volumen() {
u8g.setFont(u8g_font_unifont);
u8g.setPrintPos(2, 60);
u8g.print("Volumen");
u8g.setCursorColor( 1, 3);
}
////////////////////////////////////////////////////////////////
////////////////"Druck" Ausgabe Display///////////////////////////////////
/*void druck() {
u8g.setFont(u8g_font_unifont);
u8g.setPrintPos(2, 60);
u8g.print("Druck");
}*/
////////////////////////////////////////////////////////////////
////////////////Wert Frequenzwert Ausgabe Displpay///////////////////////////////////
void wertfrequenz() {
u8g.setFont(u8g_font_unifont);
u8g.setPrintPos(80, 38);
u8g.print(frequenzausgabe);
delay(1);
}
///////////////////////////////////////////////////////////////
void wertvolumenmanuellumschaltung() {
u8g.setFont(u8g_font_unifont); ///// Sonst normale Volumeneinheit Position
u8g.setPrintPos(80, 60);
u8g.print(ausgabemanuellevolumen);
}
/////////////////Einheit Ausgabe Display A/min/////////////////////////////////
void Einheithz() {
u8g.setFont(u8g_font_04b_03r);
u8g.setPrintPos(98, 38);
u8g.print("A/min");
}
///////////////////////////////////////////////////////////////
////////////////Ausgabe Display Einheit ml/////////////////////////////////////
void Einheitml() {
if ( decoderausgabe <= 980 || ausgabemanuellevolumen <= 980) {
u8g.setFont(u8g_font_04b_03r);
u8g.setPrintPos(105, 60);
u8g.print("ml");
}
else {
u8g.setFont(u8g_font_04b_03r);
u8g.setPrintPos(114, 60);
u8g.print("ml");
}
delay(1);
}
///////////////////////////////////////////////////////////////
/*void voluemumschaltung(){
u8g.setFont(u8g_font_unifont);
u8g.setPrintPos(80, 60);
u8g.print(gewichtmanuellautomatik);
}
*/
////////////////Wert Volumenwert Ausgabe Display + Ausgabewert///////////////////////////////////
void wertvolumen() {
u8g.setFont(u8g_font_unifont);
u8g.setPrintPos(80, 60);
u8g.print(gewichtausgabeanzeige);
gewichtmanuellautomatik = gewichtausgabeanzeige;
if (umschaltung == 0) {
if (alterausgabe <= 40) { //////////////////////////////
gewichtausgabeanzeige = gewichtsausgabe * 7.5; //Ab alter von 40/50 fängt das Volumen an zu schrumpfen.
} //Bei 80 Jahren bis zu 20 %
else if ((alterausgabe >= 40) && (alterausgabe <= 50)) { //////////////////////////////
gewichtausgabeanzeige = gewichtsausgabe * 7.5 * 0.9975; //2,75 % abfall
}
else if ((alterausgabe >= 51) && (alterausgabe <= 60)) {
gewichtausgabeanzeige = gewichtsausgabe * 7.5 * 0.9925; //7,5 % abfall
}
else if ((alterausgabe >= 61) && (alterausgabe <= 70)) {
gewichtausgabeanzeige = gewichtsausgabe * 7.5 * 0.875; // 12.5 % abfall
}
else if (alterausgabe >= 71) {
gewichtausgabeanzeige = gewichtsausgabe * 7.5 * 0.825; //17,5 % abfall
}
///////////////////////////////////////////////////////////////////////////////////////////////////
}
//////////////////////////Ausgabe Decoder im Ausgerechneten Betrieb,an Motor///////////////////////////
if (manuelll == 0) {
if (gewichtausgabeanzeige >= 0 && gewichtausgabeanzeige <= 100) {
decoderwert = 200; //////////////////////
} //Wert Variiert je nach Volumen wo ausgegeben wird.um so höher, desto
else if ( gewichtausgabeanzeige >= 100 && gewichtausgabeanzeige <= 199) { //höherer Decoder wert für weiter reinfahren
decoderwert = 240; //////////////////////
}
else if (gewichtausgabeanzeige >= 200 && gewichtausgabeanzeige <= 299) { ////Neue werte zum feststellen ob weiter zu
decoderwert = 360;
}
else if ( gewichtausgabeanzeige >= 300 && gewichtausgabeanzeige <= 399) {
decoderwert = 410;
}
else if (gewichtausgabeanzeige >= 400 && gewichtausgabeanzeige <= 499) {
decoderwert = 480;
}
else if ( gewichtausgabeanzeige >= 500 && gewichtausgabeanzeige <= 599) {
decoderwert = 540;
}
else if ( gewichtausgabeanzeige >= 600 && gewichtausgabeanzeige <= 799) {
decoderwert = 590;
}
else if (gewichtausgabeanzeige >= 800) {
decoderwert = 1300 ; ///vorher 1000 jetzt neuer versuch
}
}
else {
gewichtausgabeanzeige = manuellesvolumen;
}
decoderausgabe = decoderwert;
}
///////////////////////////////////////////////////////////////
///////////////Ausgabe Display Einheit mbar////////////////////////////////////
/*void Einheitmbar(){
u8g.setFont(u8g_font_04b_03r);
u8g.setPrintPos(105, 60);
u8g.print("mbar");
delay(1);
}*/
///////////////////////////////////////////////////////////////////////
///////////////Ausgabe Display Wert Druck/////////////////////////////////////
/*void wertdruck(){
u8g.setFont(u8g_font_unifont);
u8g.setPrintPos(80, 60);
u8g.print("-");
}*/
///////////////////////////////////////////////////////////////
/////////////////////////Freauenzausgabe Display manuell/////////////////
void wertmanuellfrequenz() {
manuelleanalogeeingabe = analogRead(pin);
if (manuelleanalogeeingabe <= 100) {
frequenzausgabe = 13;
}
else if ((manuelleanalogeeingabe >= 101) && (manuelleanalogeeingabe <= 200)) {
frequenzausgabe = 14;
}
else if ((manuelleanalogeeingabe >= 201) && (manuelleanalogeeingabe <= 300)) {
frequenzausgabe = 15;
}
else if ((manuelleanalogeeingabe >= 301) && (manuelleanalogeeingabe <= 400)) {
frequenzausgabe = 16;
}
else if ((manuelleanalogeeingabe >= 401) && (manuelleanalogeeingabe <= 500)) {
frequenzausgabe = 17;
}
else if ((manuelleanalogeeingabe >= 501) && (manuelleanalogeeingabe <= 600)) {
frequenzausgabe = 18;
}
else if ((manuelleanalogeeingabe >= 601)) {
frequenzausgabe = 19;
}
u8g.setFont(u8g_font_unifont);
u8g.setPrintPos(80, 38);
u8g.print(frequenzausgabe);
delay(1);
}
/////////////////////////////////////////////////////////////////////////////////
////////////////////Volumenausgabe Display Manuell///////////////////////////////////////
void volumenmanuell() {
manuellumschaltungbetrieb = 0;
volumendisplayausgabemanuellumschaltung = 0;
umschaltung = 1;
manuellesvolumen = analogRead(pin2);
gewichtmanuellautomatik = ausgabemanuellevolumen;
ausgabemanuellevolumen = 1.33333333 * manuellesvolumen;
if (manuellesvolumen >= 0 && manuellesvolumen <= 90) {
ausgabevolumen = 200; //////////////////////
} //Wert Variiert je nach Volumen wo ausgegeben wird.um so höher, desto
else if ( manuellesvolumen >= 91 && manuellesvolumen <= 180) { //höherer Decoder wert für weiter reinfahren
ausgabevolumen = 240; //////////////////////
}
else if (manuellesvolumen >= 181 && manuellesvolumen <= 270) {
ausgabevolumen = 360;
}
else if ( manuellesvolumen >= 271 && manuellesvolumen <= 360) {
ausgabevolumen = 410;
}
else if (manuellesvolumen >= 361 && manuellesvolumen <= 450) {
ausgabevolumen = 480;
}
else if ( manuellesvolumen >= 451 && manuellesvolumen <= 540) {
ausgabevolumen = 540;
}
else if ( manuellesvolumen >= 541 && manuellesvolumen <= 630) {
ausgabevolumen = 590;
}
else if (manuellesvolumen >= 631) {
ausgabevolumen = 1000;
}
decoderausgabe = ausgabevolumen;
if (ausgabemanuellevolumen >= 1000) { ///// <---- wenn person mehr als 1000ml Volumen benötigt verschiebt sich die Einheit
u8g.setFont(u8g_font_unifont);
u8g.setPrintPos(80, 60);
u8g.print(ausgabemanuellevolumen);
}
else {
u8g.setFont(u8g_font_unifont); ///// Sonst normale Volumeneinheit Position
u8g.setPrintPos(80, 60);
u8g.print(ausgabemanuellevolumen);
}
}
void betriebanzeigeautomatik() {
u8g.setFont(u8g_font_unifont);
u8g.setPrintPos(2, 15);
u8g.print("Man. Deaktiviert");
}
void unterstrich() {
u8g.setFont(u8g_font_unifont);
u8g.setPrintPos(2, 18);
u8g.print("_______________");
}
void betriebanzeigemanuell() {
u8g.setFont(u8g_font_unifont);
u8g.setPrintPos(2, 15);
u8g.print("Man. Aktiviert");
}