PC WorX und erster Versuch eines FB in ST

[Portisch]

Zuviel Werbung?
-> Hier kostenlos registrieren

Hallo,

ich möchte einen RS232_Receive in einem FB programmieren. Als FBD (Graphisch) habe ich es schon geschafft.
Nun möchte ich es aber in ST umsetzen.

Also habe ich mir einen neuen FB angelegt und das mal reingeschrieben:

Variabeln:

CMD_INPUT BYTE VAR   0 0 0 0 0 0 0 
Data_Count BYTE VAR   4 0 0 0 0 0 0 
BIT0 BOOL VAR_OUTPUT   FALSE 0 0 0 0 0 0 
BIT1 BOOL VAR_OUTPUT   FALSE 0 0 0 0 0 0 
BIT2 BOOL VAR_OUTPUT   FALSE 0 0 0 0 0 0 
BIT3 BOOL VAR_OUTPUT   FALSE 0 0 0 0 0 0 
BIT4 BOOL VAR_OUTPUT   FALSE 0 0 0 0 0 0 
BIT5 BOOL VAR_OUTPUT   FALSE 0 0 0 0 0 0 
BIT6 BOOL VAR_OUTPUT   FALSE 0 0 0 0 0 0 
BIT7 BOOL VAR_OUTPUT   FALSE 0 0 0 0 0 0 
BIT8 BOOL VAR_OUTPUT   FALSE 0 0 0 0 0 0 
BIT9 BOOL VAR_OUTPUT   FALSE 0 0 0 0 0 0 
BIT10 BOOL VAR_OUTPUT   FALSE 0 0 0 0 0 0 
BIT11 BOOL VAR_OUTPUT   FALSE 0 0 0 0 0 0 
BIT12 BOOL VAR_OUTPUT   FALSE 0 0 0 0 0 0 
BIT13 BOOL VAR_OUTPUT   FALSE 0 0 0 0 0 0 
BIT14 BOOL VAR_OUTPUT   FALSE 0 0 0 0 0 0 
BIT15 BOOL VAR_OUTPUT   FALSE 0 0 0 0 0 0 
Receive_Data RS232_Data VAR    0 0 0 0 0 0 
RS232_RECEIVE_DATA RS232_RECEIVE VAR    0 0 0 0 0 0 
BYTE_TO_BITS BYTE_TO_BITS VAR    0 0 0 0 0 0

ST Code:

RS232_RECEIVE_DATA(REQUEST:=FALSE,DATA:=Receive_Data);
Receive_Data := RS232_RECEIVE_DATA.DATA;

IF RS232_RECEIVE_DATA.RECEIVE_BUFFER_COUNT = BYTE_TO_INT(Data_Count) THEN
 RS232_RECEIVE_DATA.REQUEST := TRUE;
END_IF;

IF RS232_RECEIVE_DATA.DONE THEN
 IF (Receive_Data[0] = Data_Count) AND (Receive_Data[1] = CMD_INPUT) THEN
  BYTE_TO_BITS(IN:=Receive_Data[2]);
  BIT0 := BYTE_TO_BITS.B0;
  BIT1 := BYTE_TO_BITS.B1;
  BIT2 := BYTE_TO_BITS.B2;
  BIT3 := BYTE_TO_BITS.B3;
  BIT4 := BYTE_TO_BITS.B4;
  BIT5 := BYTE_TO_BITS.B5;
  BIT6 := BYTE_TO_BITS.B6;
  BIT7 := BYTE_TO_BITS.B7;
  BYTE_TO_BITS(IN:=Receive_Data[3]);
  BIT8 := BYTE_TO_BITS.B0;
  BIT9 := BYTE_TO_BITS.B1;
  BIT10 := BYTE_TO_BITS.B2;
  BIT11 := BYTE_TO_BITS.B3;
  BIT12 := BYTE_TO_BITS.B4;
  BIT13 := BYTE_TO_BITS.B5;
  BIT14 := BYTE_TO_BITS.B6;
  BIT15 := BYTE_TO_BITS.B7;
 END_IF;
END_IF;

Der Ablauf geht so:
Erst wird gewartet, bis 4 Bytes im RECEIVE_BUFFER_COUNT drinnen sind. Dann soll der REQUEST auf TRUE gesetzt werden um die Daten in meine Receive_Data : Array[0..7] of Byte zu kopieren.

Per DONE wird dann angezeigt, wann das Kopieren fertig ist.
Danach sollen einfach die BIT0-BIT15 gesetzt werden.

Per RS232 kommen diese Daten rein:
Byte 0: Complete len (4)
Byte 1: Command, CMD_INPUT = 0
Byte 2: Data BITs 0..7
Byte 3: Data BITs 8..15

Wenn ich nun Funktionsblock ausführe reagiert er nur einmal und dann gar nicht mehr.
Ich glaube das RS232_RECEIVE_DATA.REQUEST := TRUE; löst das kopieren der Daten nicht aus und somit steigt der Buffer_count immer höher.

Kann hier jemand einen Anfänger etwas helfen!?

 

[Portisch]

Ich habe es nun zum Laufen gebracht:

IF NOT RS232_INIT_DONE THEN
 RETURN;
END_IF;
RS232_RECEIVE_1(REQUEST:=RS232_RECEIVE_1.BUFFER_NOT_EMPTY ,DATA:=Receive_Buffer);
Receive_Buffer:=RS232_RECEIVE_1.DATA;
IF RS232_RECEIVE_1.ERROR THEN
 Error := TRUE;
 Status := RS232_RECEIVE_1.STATUS;
END_IF;
 
IF RS232_RECEIVE_1.DONE THEN
 BYTE_TO_BITS_1(IN:=Receive_Buffer[2]);
 BIT0:=BYTE_TO_BITS_1.B0;
 BIT1:=BYTE_TO_BITS_1.B1;
 BIT2:=BYTE_TO_BITS_1.B2;
 BIT3:=BYTE_TO_BITS_1.B3;
 BIT4:=BYTE_TO_BITS_1.B4;
 BIT5:=BYTE_TO_BITS_1.B5;
 BIT6:=BYTE_TO_BITS_1.B6;
 BIT7:=BYTE_TO_BITS_1.B7;
END_IF;

Jedoch scheint der FB von RS232_RECEIVE ein Problem zu haben.
Es geht eine Zeit lang gut, aber danach bleibt RS232_RECEIVE_1.BUFFER_NOT_EMPTY auf TRUE obwohl der Buffer leer ist.
hier hilft dann nur ein Kaltstart damit es wider geht...

 

[Mobi]

Zuviel Werbung?
-> Hier kostenlos registrieren

Morgen,

warum weist du überhaupt DATA doppelt zu?

RS232_RECEIVE_1(REQUEST:=RS232_RECEIVE_1.BUFFER_NOT_EMPTY ,DATA:=Receive_Buffer); 
Receive_Buffer:=RS232_RECEIVE_1.DATA;

Und nutzt du die RS232-Schnittstelle von dem ILC oder hast du eine RS232-Klemme?
Weil dann musst du nämlich andere Bausteine nehmen.

 

[Portisch]

Morgen,

warum weist du überhaupt DATA doppelt zu?

RS232_RECEIVE_1(REQUEST:=RS232_RECEIVE_1.BUFFER_NOT_EMPTY ,DATA:=Receive_Buffer); 
Receive_Buffer:=RS232_RECEIVE_1.DATA;

Und nutzt du die RS232-Schnittstelle von dem ILC oder hast du eine RS232-Klemme?
Weil dann musst du nämlich andere Bausteine nehmen.

Doppelt, da es PC WorX so verlangt. DATA ist ein VAR_IN_OUT.
Wenn ich die untere Zeile weglasse gibt es einen Fehler.

Ich benutze die eingebaute RS232 der ILC - keine extra Klemme.

 

[Mobi]

Ich hab nun auch mal was probiert, kann es aber nicht testen.

EN    BOOL    VAR_INPUT                0    0    0    0    0    0    
BIT0    BOOL    VAR_OUTPUT                0    0    0    0    0    0    
BIT1    BOOL    VAR_OUTPUT                0    0    0    0    0    0    
BIT2    BOOL    VAR_OUTPUT                0    0    0    0    0    0    
BIT3    BOOL    VAR_OUTPUT                0    0    0    0    0    0    
BIT4    BOOL    VAR_OUTPUT                0    0    0    0    0    0    
BIT5    BOOL    VAR_OUTPUT                0    0    0    0    0    0    
BIT6    BOOL    VAR_OUTPUT                0    0    0    0    0    0    
BIT7    BOOL    VAR_OUTPUT                0    0    0    0    0    0    
BIT8    BOOL    VAR_OUTPUT                0    0    0    0    0    0    
BIT9    BOOL    VAR_OUTPUT                0    0    0    0    0    0    
BIT10    BOOL    VAR_OUTPUT                0    0    0    0    0    0    
BIT11    BOOL    VAR_OUTPUT                0    0    0    0    0    0    
BIT12    BOOL    VAR_OUTPUT                0    0    0    0    0    0    
BIT13    BOOL    VAR_OUTPUT                0    0    0    0    0    0    
BIT14    BOOL    VAR_OUTPUT                0    0    0    0    0    0    
BIT15    BOOL    VAR_OUTPUT                0    0    0    0    0    0    
RS232_RECEIVE_1    RS232_RECEIVE    VAR                0    0    0    0    0    0    
RS232_INIT_1    RS232_INIT    VAR                0    0    0    0    0    0    
xRequest    BOOL    VAR                0    0    0    0    0    0    
arrReceiveData    ARRAY_OF_BYTE_0_7    VAR                0    0    0    0    0    0

RS232_INIT_1(ENABLE:=EN,PARAMETER:=(* ANY *));

RS232_RECEIVE_1(REQUEST:=xRequest,DATA:=arrReceiveData);
arrReceiveData := RS232_RECEIVE_1.DATA;

IF RS232_RECEIVE_1.RECEIVE_BUFFER_COUNT = INT#4 AND RS232_INIT_1.VALID AND NOT xRequest THEN
    xRequest := TRUE;
END_IF;

IF RS232_RECEIVE_1.DONE THEN
    BIT0 := arrReceiveData[2].X0;
    BIT1 := arrReceiveData[2].X1;
    BIT2 := arrReceiveData[2].X2;
    BIT3 := arrReceiveData[2].X3;
    BIT4 := arrReceiveData[2].X4;
    BIT5 := arrReceiveData[2].X5;
    BIT6 := arrReceiveData[2].X6;
    BIT7 := arrReceiveData[2].X7;
    BIT8 := arrReceiveData[3].X0;
    BIT9 := arrReceiveData[3].X1;
    BIT10 := arrReceiveData[3].X2;
    BIT11 := arrReceiveData[3].X3;
    BIT12 := arrReceiveData[3].X4;
    BIT13 := arrReceiveData[3].X5;
    BIT14 := arrReceiveData[3].X6;
    BIT15 := arrReceiveData[3].X7;
    xRequest := FALSE;
END_IF;

Was noch fehlt ist natürlich das Error-Handling und die Parameter.
Aber ich wollte nur erstmal den Ablauf bekommen.

 

[Portisch]

Zuviel Werbung?
-> Hier kostenlos registrieren

Das habe ich schon so ähnlich gehabt.

Das RS232_INIT habe ich nicht hier untergebracht, da es nur einmal verwendet werden kann im Projekt. Es gibt ja auch noch ein RS232_SEND...
Ich habe (oben nicht drinnen) beim RS232_INIT das über eine globale VAR gelöst.

RS232_RECEIVE_1.RECEIVE_BUFFER_COUNT = INT#4

Das gab bei mir einige Hänger, denn wenn nun 5 Bytes im Buffer sind wird dieser nie ausgelesen.
Wenn man also >=INT#4 macht gehen aber Bytes verloren falls 5 oder mehr im Buffer sind.

Am liebsten möchte ich Byte für Byte aus dem Buffer lesen.
Das erste Byte sagt mir die Anzahl von Bytes die reinkommen. Danach lese ich nachfolgenden Bytes ein.
So würde ich es in Delphi/C machen.

Wenn man nähmlich z.B. mehrere Bytes an die SPS schickt, ist nicht gesagt das schon alle Bytes im Buffer sind bis ich den Buffer auslese.
Und wenn nun mehrere Bytes schnell hintereinander reinkommen kann es sein wenn ich auf z.B. >=INT#512 warte und dann beim nächten Durchlauf erst auslese das schon z.B. 600 Bytes im Buffer sind. Die über 512 gehen dann verloren.

 

[Mobi]

Wenn du weißt wie du es in C# machen willst, dann schreib es doch einfach um. Wie stellst du dir denn den Code in C+ vor, vielleicht kann ich das dann so in ST abwandeln.

Wenn du weißt wieviele Bytes kommen, warum wartest du dann nicht einfach bist du alle hast? Sind es immer unterschiedliche Anzahlen von Bytes?

 

[Portisch]

Eigentlich wollte ich gestern schon Antworten. Scheint aber verloren geganngen zu sein, egal.

Es ist nicht sicher, dass immer die gleiche Anzahl von Bytes reinkommen.
Ich arbeite gerade daran:
http://www.mikrocontroller.net/topic/244302#2503381

Es wird sozusagen per RS232 z.B. 1-Wire Temperatursensoren und aber auch andere Daten zur Verfügung gestellt.
z.B. ein zusätzlicher µC der im Wohnzimmer sitzt und IR-Signale empfangen kann. Somit kann man dann per Fernbedienung Lichter schalten.

Derzeit kommen z.B. die Daten der RS232 so an die SPS:

Beispiel der RS232 mit 2 Temp Sensoren:
000 085 011 048 040 033 057 187 003 000 000 009 236 000 000 085 011 048
040 168 056 187 003 000 000 184 236 000

000 sync byte 1
085 sync byte 2
011 data len
048 command byte
040 id
033 id
057 id
187 id
003 id
000 id
000 id
009 id
236 temp int16
000 temp int16 = 23,6°C

000 sync byte 1
085 sync byte 2
011 data len
048 command byte
040 id
168 id
056 id
187 id
003 id
000 id
000 id
184 id
236 temp int16
000 temp int16 = 23,6°C

Und oder auch die IR Commands:

Wenn nun dieser Code empfangen wird bekommt man das IRMP Command byte:
0x00 0x55 0x02 0x10 0x11

0x00 sync byte 1
0x55 sync byte 2
0x02 data len
0x10 command
0x11 IRMP Command

Von der SPS -> µC über die RS232 mache ich das dann z.B. so wie in der AVR_Bus.c.

Was ich eben leider nicht in der SPS abbilden kann. Im µC wird immer Byte für Byte eingelesen. Die ersten 2 Bytes sind SyncBytes und dann das data len Byte um zu wissen wieviele Bytes noch folgen.
Wenn die SPS nun jetzt bei jedem Durchlauf ein Byte einließt und dann im Buffer hat kann ich es mir vorstellen da es ähnlich dem C-Code abläuft.
Wenn nun aber z.B. schon 3 Bytes im Buffer sind und dann beim nächsten Durchlauf die restlichen wird's kompliziert.

Auch wenn ich auf Buffer_Count >= INT#3 warte sind beim nächsten Durchlauf ja schon wieder neue Bytes (vielleicht auch noch nicht alle Bytes der Nachricht) im Buffer.

 

[Mobi]

Zuviel Werbung?
-> Hier kostenlos registrieren

Cool. Das wollte ich auch schon machen. Nur hatte ich für den AVR keine Zeit, das ganze zu entwickeln. Ich wollte es machen wegen der IR-Fernbedienung. Das einfachste wäre gewesen, das ganze in PC Worx umzusetzen. Aber nun kann ich ja deins nehmen.

Also wenn du die Syncbytes bekommst, solltest du erstmal alle Bytes zwischenspeichern. Und dann wenn du alle hast, das ganze auswerten. Ich müsste mir den AVR-Kram mal aufbauen, dann kann ich dir zeigen was ich meine.

 

[Portisch]

Also wenn du die Syncbytes bekommst, solltest du erstmal alle Bytes zwischenspeichern. Und dann wenn du alle hast, das ganze auswerten.

Ok, aber hier scheidet sich mein Verständniss.
Ich sage ich warte bis der Buffer mindestens 2 Bytes enthält. Dann überprüfe ich die 2 Bytes auf das Sync.
Was aber wenn nun 3 Bytes im Buffer sind und das Sync erst beim zweiten anfängt usw.

Wenn bei jedem durchlauf immer 1 Byte gelesen wird sollte es ohne Probleme funktionieren.

EDIT:
Ich glaub jetzt hat im Kopf geklickelt:

Speicher in den die Daten des Empfangsspeicher der seriellen Schnittstelle
kopiert werden. Es werden nur so viele Zeichen eingelesen, wie der an DATA
angelegte Speicher groß ist.

Wenn man also an DATA ein Array mit der Länge 1 anlegt sollte immer nur ein Byte aus dem Buffer gelesen werden. Was aber mit den übrigen geschieht kann ich noch nicht sagen. Ob diese dann sozusagen aufrücken oder verlorengehen (was ich nicht glaube) könnte es funktionieren.

 

[Mobi]

Mach doch das Array so groß wie das größte Datenpaket groß sein kann. Dann wartest du bis BUFFER_NOT_EMPTY True ist, weil dann weißt du ja das was im Empfangsspeicher steht. Dann füllt er den Speicher und du wartest dann bis sich an RECEIVE_BUFFER_COUNT nix mehr ändert, also 500 ms zum Beispiel. Und dann kannste den Speicher auslesen mit Request.

 

[Portisch]

Zuviel Werbung?
-> Hier kostenlos registrieren

Habe es jetzt einmal auf die schnelle versucht:

IF NOT RS232_INIT_DONE THEN
 uart_status := INT#0;
 data_len := BYTE#0;
 RETURN;
END_IF;

RS232_RECEIVE_1(REQUEST:=RS232_RECEIVE_1.BUFFER_NOT_EMPTY,DATA:=Receive_Buffer);
Receive_Buffer:=RS232_RECEIVE_1.DATA;

IF RS232_RECEIVE_1.ERROR THEN
 uart_status := INT#0;
 data_len := BYTE#0;
 RETURN;
END_IF;

IF RS232_RECEIVE_1.DONE THEN
 CASE uart_status OF
 0: IF (Receive_Buffer[0] = BYTE#0) THEN
    uart_status := uart_status + INT#1;
  END_IF;
 1: IF( Receive_Buffer[0] = BYTE#16#55) THEN
   uart_status := uart_status + INT#1;
  END_IF;
 2: IF data_len = BYTE#0 THEN
   data_len := Receive_Buffer[0];
  ELSE
   (* read all data bytes *)
   uart_status := INT#0;   
  END_IF;
 END_CASE;
END_IF;

Ich schicke nun per RS232 0x00, 0x55, 0x02 an die SPS.
Leider wird aber nur das erste Byte empfangen. Die restlichen scheinen verloren zu gehen.

Receive_Buffer : Array[0..0] of BYTE;

 

[Mobi]

Receive_Buffer : Array[0..0] of BYTE; ?????????????????

 

[Mobi]

Ich hab nochwas gefunden. Vielleicht hilft es dir ja.

 

[Portisch]

Zuviel Werbung?
-> Hier kostenlos registrieren

Ja, ich weiß das Array [0..0] ist eigentlich ein (in Delphi zumindest) Dynamisches Array.
Aber es gibt halt kein Array mit der Länge 1 da es dann ja einfach ein Byte ist.
Das kann man aber als Data beim Receive nicht anhängen.

Aber ich habe das mit dem Tipp mit der Zeit umgesetzt:

IF NOT RS232_INIT_DONE THEN
 init := FALSE;
 ReadBuffer := FALSE;
 RETURN;
END_IF;

(* make sure the first cycle works correctly *)
IF NOT init THEN
 init := TRUE;
 last_count := INT#0;
 data_len := BYTE#0;
 ms := UDINT#0;
END_IF;

RS232_RECEIVE(REQUEST:=ReadBuffer ,DATA:=Receive_Buffer);
Receive_Buffer:=RS232_RECEIVE.DATA;

IF RS232_RECEIVE.DONE THEN 
 ReadBuffer := FALSE;
 data_len := INT_TO_BYTE(last_count);
 last_count := INT#0;
 ms := UDINT#0; 
END_IF;

IF last_count <> RS232_RECEIVE.RECEIVE_BUFFER_COUNT THEN
 (* buffer count changed, reset timeout *)
 last_count := RS232_RECEIVE.RECEIVE_BUFFER_COUNT;
 ms := UDINT#0;
ELSE
 IF last_count <> INT#0 THEN
  (* read system time *)
  T_PLC_MS();
  tx:= T_PLC_MS.T_PLC_MS;
  (* add the current milliseconds *)
  ms := (tx - last) + ms;
  IF ms >= UDINT#50 THEN
   ReadBuffer := TRUE;  
  END_IF;
  last := tx;
 END_IF; 
END_IF;

RS232_RECEIVE RS232_RECEIVE VAR 0 0 0 0 0 0
tx UDINT VAR 0 0 0 0 0 0
last UDINT VAR 0 0 0 0 0 0
init BOOL VAR 0 0 0 0 0 0
ms UDINT VAR 0 0 0 0 0 0
Receive_Buffer PND_IO_512 VAR 0 0 0 0 0 0
data_len BYTE VAR_OUTPUT 0 0 0 0 0 0
T_PLC_MS T_PLC_MS VAR 0 0 0 0 0 0
last_count INT VAR 0 0 0 0 0 0
ReadBuffer BOOL VAR 0 0 0 0 0 0
RS232_INIT_DONE BOOL VAR_EXTERNAL 0 0 0 0 0 0

Ist noch nicht ganz sauber - geht aber!!
Wenn sich der Buffer Count 50ms nicht mehr ändert werden die Daten aus dem Buffer geholt.

Danach kann der Receive_Buffer abgearbeitet werden...

 

[Portisch]

Da ich somit gerade an der Auswertung der RS232 Daten arbeite ist mir was aufgefallen:

Es scheint das PC WorX kein ADR und SIZEOF kennt.
Das scheinen aber Standard Operatoren von CodeSys zu sein:
http://www.3s-software.com/index.shtml?de_infosys&infosys=de_adroperator_gloss

Wie bekomme ich die nun für PC WorX?

 

[Portisch]

Mit den Temperaturauswertungen über RS232 bin ich dann schon fast fertig!
Anbei die 3 Funktionsblöcke.
Diese Empfangen die Bytes und Werten das CMD_TSENSOR_TEMP aus.

Die OneWire Devices haben diese Struct:

TYPE
T_TEMPSENSOR : STRUCT
 Name : STRING;
 Temperature : REAL;
 Family : BYTE;
 Serial : STRING;
END_STRUCT;
END_TYPE

TYPE
T_TEMPSENSOR_ARRAY : ARRAY[0..1] OF T_TEMPSENSOR;
T_ONEWIRE : STRUCT
 OneWireDevice : T_TEMPSENSOR_ARRAY;
 DeviceCount : INT;
END_STRUCT;  
END_TYPE

Mann muss halt hier die Länge des Arrays anpassen damit es mit den Sensoren zusammen passt.

In der OneWireDevices.ST kann man dann die Devices mit einer String-Serial einen Namen zuweisen.
z.B. Raum 1, Raum 2,....




Für diese Daten wurde dies an die SPS geschickt:
00 55 0B 30 28 21 39 BB 03 00 00 09 D5 00 00 55 0B 30 28 A8 38 BB 03 00 00 B8 05 FF
(HEX Format - eh klar)
-25,1°C wegen Kältespray

Aber der Code muss noch aufgeräumt werden!



Anzeige mit WebVisit im IE9 geht dann auch recht leicht
Anhang anzeigen Exports_FB.zip

 

[Mobi]

Zuviel Werbung?
-> Hier kostenlos registrieren

Hallo,

also dynamische Arrays gibts schonmal nicht in PC WorX. Und Codesys hat mit PC WorX auch nichts zutun.
Bei PC WorX gibts auch keine Pointer und somit auch kein ADR und SIZEOF. Aber du weißt ja sowieso wie groß das Array ist, da es ja statisch ist.


Könntest du mal dein Projekt schicken, würde mir das gerne mal im Zusammenhang ansehen.

Ich muss mir dann nur noch die Hardware zusammenstricken. Dann kann ich es auch mal testen.


Hast du schon probiert mit den IR-Signalen?


Aber sonst super, dass es läuft.

 

[Portisch]

Hallo,

also dynamische Arrays gibts schonmal nicht in PC WorX. Und Codesys hat mit PC WorX auch nichts zutun.
Bei PC WorX gibts auch keine Pointer und somit auch kein ADR und SIZEOF. Aber du weißt ja sowieso wie groß das Array ist, da es ja statisch ist.


Könntest du mal dein Projekt schicken, würde mir das gerne mal im Zusammenhang ansehen.

Ich muss mir dann nur noch die Hardware zusammenstricken. Dann kann ich es auch mal testen.


Hast du schon probiert mit den IR-Signalen?


Aber sonst super, dass es läuft.

Das mit den Pointern habe ich dann schon feststellen müssen. Auch das bei PC WorX in Funktionen keine Arrays übergeben werden können. Dazu muss man einen Funktionsblock nehmen.

Das mit dem IR funktioniert schon, ist nur noch nicht umgesetzt. Per IR können Commands 0x00-0xFF eingestellt werden.
Auch kann man im AVR zwei verschiedenen IR-Befehlen (z.B. unterschiedliche Fernbedienungen) das gleiche Command zuweisen usw...

Das µC Projekt ist noch nicht abgeschlossen da mir die Verbindung zwischen den µC noch nicht so gefällt. Wird wahrscheinlich CAN statt "OneWire".
Auch das Programmieren der IR Codes für die Slaves, was derzeit über die RS232 gemacht wird, werde ich wahrscheinlich auf USB umstellen.
Am PC ist die Programmierung der Slaves dann um einiges einfacher und komfortabler.

 

[Portisch]

Nun hier einmal das RS232 Projekt.

Also einfach mit 9600, 8E1 mit der SPS verbinden und dann z.B. diese Commandos probieren:

2 Temperatur Sensoren:
Hex:
00 55 0B 30 28 21 39 BB 03 00 00 09 E5 00 00 55 0B 30 28 A8 38 BB 03 00 00 B8 EE 00
DEC:
000 085 011 048 040 033 057 187 003 000 000 009 229 000 000 085 011 048 040 168 056 187 003 000 000 184 229 000

IR Command:
Hex:
00 55 02 10 11
DEC:
000 085 002 016 017

(ich nehme HTerm von hier http://www.der-hammer.info/terminal/)

Wenn ein neuer unbekannter Sensor angeschlossen wird, der nicht definiert ist wird er per Serial-String definiert.
Das "IR_Changed" gibt einen Puls aus wenn ein neues IR_Command empfangen wurde.
Danach kann man das IR_Command mit 265 Möglichkeiten verknüpfen.

Testweise kann ich schon schön mit der Fernbedienung ein Toggle hin und her schalten




Anhang anzeigen RS232_Test.zip