µWebControl

  • Modernisieren von Maschinen und Anlagen leichtgemacht.

  • Steuern und Überwachen Sie Ihre Anlage über Ihren Smartphone- oder Desktop-Browser.

  • Benutzen Sie den µWebGenerator oder lassen Sie sich von uns eine auf Ihre Bedürnisse angepasste Webapplikation anfertigen.

Benutzer erwarten heutzutage für jede Maschine oder Anlage eine Webseite zur Steuerung und Einrichtung.

ELZET80 µWebControl bietet eine Schnittstelle zur HTTP-Kommunikation die nicht nur von Browsern abgefragt/bedient werden kann, sondern auch von Smartphones, Widgets, ERP-Systemen usw..

Mit dem µWebGenerator können Sie sogar ohne Kenntnisse von HTML oder JavaScript eine Webseite aus dem C-Code generieren.

Wird von allen µTasker-Baugruppen und von Sonderlösungen mit Ethernet unterstützt.

  • Funktion
  • µTasker-Integration
  • Beispiel: IO-Callback
  • Beispiel: PC-Widget
  • Downloads

µWebControl bietet Ihnen eine eigene HTTP-Kommunikationsschnittstelle die Sie in jedem µTasker-Projekt (mit Ethernet) verwenden können.

HTTP-GET Anfragen spezieller Form werden als Befehle interpretiert und können mit beliebigen Daten beantwortet werden.

µWebControl wird in den Webhandler von µTasker eingehangen und wartet auf Anfragen der folgenden Form:

http://*IP-Adresse*/*Sonderzeichen**Befehl*[=*Daten*]

Im Webhanlder wird überprüft ob das erste Zeichen der Anfrage dem vordefinierten Sonderzeichen entspricht.

Ist dies der Fall wird die Anfrage an die µWebControl Hauptfunktion fnHandleDynamicQuery übergeben.

In dieser Funktion wird überprüft ob für die vorliegene Anfrage eine Callback-Funktion registriert wurde, ist dies nicht der Fall so wird eine leere Antwort gesendet.

Beispiel:

Anfrage: http://192.168.1.80/!sysInfo

Intern wird der Befehl "sysInfo" extrahiert und überprüft ob eine Callback-Funktion für diesen registriert ist.

Wird eine Callback-Funktion gefunden, so wird diese aufgerufen und füllt die Antwort mit den angefragten Daten (z.B. Seriennummer, Uptime usw.).

 

Webhandler einhängen:

µWebControl wird in den Webhandler von µTasker eingehangen (Datei: webinterface.c, Funktion: fnHandleWeb)

Als erste Abfrage in der Funtkion wird der folgende Code eingefügt:

if(ptrData[0] == '!'){// Check if the dynamic content page was requested
   return fnHandleDynamicQuery(ptrData, http_session);
}

Im obigen Code wird überprüft ob eine HTTP-Anfrage mit einem vordefinierten Sonderzeichen (hier '!') beginnt.

Die Funktion fnHandleDynamicQuery ist die Hauptfunktion des µWebControl-Codes. Sie überprüft ob für die Anfrage eine Callback-Funtkion hinterlegt ist.

Callback registrieren:

In der Datei dynamicContent.c sind zwei Kommando-Arrays definiert. Das erste Array commands enthält Befehle die ohne Authentifizierung aufgerufen werden können, das zweite Array authCommands enhält Befehle die eine Authentifizierung erfordern.

/*command storage
* CMD("commandString", callbackFunction)
* callbackFunction has to be like this:
* int callbackFunction(char * wrPtr, unsigned char message[], int * dynLen, char* query){}
*
*/
WEBCOMMAND commands[] = {
   CMD("login=",fnWebLogin),
   CMD("loginState",fnGetLoginState),
   CMD("gbv",fnGetWebVars),
   CMD("getPageDesc",fnGetPageDesc),
   CMD("curTm",fnGetCurrentTime),
   CMD("hdlVar=",fnWebHandler),
   CMD("clear",fnClearWebPars),
   CMD("btn",fnAddButton),
   CMD("getVals",fnGetValues),
};

WEBCOMMAND authCommands[] = {
   CMD("setTime=",fnSetTime),
};

Aufbau Callback-Funktion:

Die Callback-Funktionen müssen dem folgenden Funktionskopf enstsprechen:

int callbackFunction(char * wrPtr, unsigned char message[], int * dynLen, char* query);

  • wrPtr:   buffer to hold the data
  • message: The startaddress of wrPtr to calculate dynLen
  • dynLen:  an integer pointer to store the length of the data to send
  • query:   The request query

Beispielfunktion fnGetIOStates:

The following function creates a page with the current states of the NET-3A4IO I/Os.

int fnGetIOState(char * wrPtr, unsigned char message[], int * dynLen, char* query){
  long lTemp;

//first we display the three raw adc values 

  wrPtr = uStrcpy(wrPtr,"ADC1: ");
  wrPtr = fnBufferDec((fnGetADC3A4IO(0)),1,wrPtr);

  wrPtr = uStrcpy(wrPtr,"<br>ADC2: ");
  wrPtr = fnBufferDec((fnGetADC3A4IO(1)),1,wrPtr);

  wrPtr = uStrcpy(wrPtr,"<br>ADC3: ");
  wrPtr = fnBufferDec((fnGetADC3A4IO(2)),1,wrPtr);

//check if the 3A4IO is configured for PT100 or type K thermocouples and print it accordingly

  if(uc3A4IORange == RANGE_RTD_RAW){
    wrPtr = uStrcpy(wrPtr,"<br> PT100(ADC1): ");
    wrPtr = fnBufferDec(fnLinVal(fnGetADC3A4IO(0),0),1,wrPtr);
  }else if(uc3A4IORange == RANGE_TC_RAW){
    wrPtr = uStrcpy(wrPtr,"<br> Type K(ADC1): ");
    wrPtr = fnBufferDec(fnLinVal(fnGetADC3A4IO(0) + s3A4IO_ref_temp,1),1,wrPtr);
  }

//here we collect and print the states of the four outputs

  wrPtr = uStrcpy(wrPtr,"<br> OUTPUT1: ");
  wrPtr = fnBufferDec(fnGetOutput3A4IO(0),0,wrPtr);
  wrPtr = uStrcpy(wrPtr,"<br> OUTPUT2: ");
  wrPtr = fnBufferDec(fnGetOutput3A4IO(1),0,wrPtr);
  wrPtr = uStrcpy(wrPtr,"<br> OUTPUT3: ");
  wrPtr = fnBufferDec(fnGetOutput3A4IO(2),0,wrPtr);
  wrPtr = uStrcpy(wrPtr,"<br> OUTPUT4: ");
  wrPtr = fnBufferDec(fnGetOutput3A4IO(3),0,wrPtr);

 
//here we collect and print the states of the four inputs

  wrPtr = uStrcpy(wrPtr,"<br> Input1: ");
  wrPtr = fnBufferDec(fnGetInput3A4IO(0),0,wrPtr);
  wrPtr = uStrcpy(wrPtr,"<br> Input2: ");
  wrPtr = fnBufferDec(fnGetInput3A4IO(1),0,wrPtr);
  wrPtr = uStrcpy(wrPtr,"<br> Input3: ");
  wrPtr = fnBufferDec(fnGetInput3A4IO(2),0,wrPtr);
  wrPtr = uStrcpy(wrPtr,"<br> Input4: ");
  wrPtr = fnBufferDec(fnGetInput3A4IO(3),0,wrPtr);

//calculate the length of the generated content
  *dynLen = (wrPtr - (CHAR*) message);
  return 0;
}

 

Das Ergebnis sieht so aus:

ADC1: 12124
ADC2: 5125
ADC3: 12113
PT100(ADC1): 234
OUTPUT1: 0
OUTPUT2: 1
OUTPUT3: 0
OUTPUT4: 0
Input1: 1
Input2: 0
Input3: 1
Input4: 1

Beispiel PC-Widget:

Das PC-Widget ist ein kleines Tool, welches zur Überwachung Ihrer Anlage dient.

Das Widget kommuniziert über die µWebControl-Schnittstelle mit der Hardware, genauso wie die Webseite. ELZET80-Geräte werden über den "Device-Discovery"-Mechanismus automatisch erkannt und wenn die Widget-Schnittstelle unterstützt wird in der Auswahlliste angezeigt.

Die abzubildenden Daten werden in einer Struktur im µTasker-Programmcode definiert.

Für das rechts abgebildete Beispiel sieht die Definition folgendermaßen aus:


        VALUE(iInput1,C8,0,"Input 1"),
        VALUE(iInput2,C8,0,"Input 2"),
        VALUE(iInput3,C8,0,"Input 3"),
        VALUE(iInput4,C8,0,"Input 4"),
        VALUE(iADC1,S16,(unit_ampere | exp_deci),"ADC1"),
        VALUE(iADC2,S16,0,"ADC2"),
        VALUE(iADC3,S16,0,"ADC3"),
        VALUE(sliderDemo,S16,(unit_hour| exp_none),"ADC3"),

Der obenstehende Code ist wie folgt aufgebaut:

VALUE(Variable,Typ,(Einheit | Exponent),Anzeigename)

 

Variable:

die Variable im C-Code dessen Wert abgebildet wird.

Typ:

 

Datentyp der Variablen
Wichtig für signed/unsigned Darstellung.

Einheit | Exponent:

 

z.B. (unit_ampere | exp_deci) -> Einheit: Ampere, Exponent: Deci (-1)
Wichtig für die Skalierung der Werte für die Anzeige.

Anzeigename:

Die Überschrift für den im Widget angezeigten Wert.

Bei VALUE-Objekten handelt es sich um einen read-only Anzeigewert, deswegen ist es hier nicht nötig Grenzen (Min/Max) anzugeben.

 

 

Den Beispielcode für das PC-Widget finden Sie unter dem "Downloads"-Reiter

Dls