Cookies op Tweakers

Tweakers maakt gebruik van cookies, onder andere om de website te analyseren, het gebruiksgemak te vergroten en advertenties te tonen. Door gebruik te maken van deze website, of door op 'Ga verder' te klikken, geef je toestemming voor het gebruik van cookies. Wil je meer informatie over cookies en hoe ze worden gebruikt, bekijk dan ons cookiebeleid.

Meer informatie
Toon posts:

Domotica met plc's

Pagina: 1
Acties:

Onderwerpen


  • Femme
  • Registratie: juni 1999
  • Laatst online: 20:37

Femme

Hardwareconnaisseur

Official Jony Ive fan

Topicstarter
In mijn artikel Doe-het-zelf-domotica - Het nieuwe tweaken heb ik vorige maand een aantal populaire protocollen en technieken voor de hardware in een domoticasystemen besproken. Eén van de besproken technieken was de programmable logic controller (plc). Ik gebruik een plc in mijn eigen domoticasysteem en ben er inmiddels erg enthousiast voor. Hopelijk zijn er meer tweakers te vinden die met plc's werken of ermee aan de slag willen :) .


Wat is een plc?

Een programmable logic controller is een apparaat dat volgens een ingesteld programma informatie van inputs verwerkt en outputs aanstuurt. Een klassieke plc werkt cyclisch en leest eerst alle ingangen in, voert vervolgens het programma uit en schrijft de uitgangswaarden naar een tabel. Als het programma klaar is, worden de waarden van uitgangen aangepast. Een cyclus duurt, afhankelijk van de omvang van het programma, een aantal milliseconden en begint daarna opnieuw.



Een plc is meestal modulair opgebouwd en bestaat uit de eigenlijke controller die via een veldbus communiceert met de buitenwereld en via uitbreidingsmodules naar wens voorzien kan worden van in- en uitgangen of interfaces naar andere apparaten. In het verleden werden industriële protocollen zoals Profibus, Modbus, rs-485 en Canbus gebruikt voor de communicatie met plc's. Tegenwoordig is ethernet populair. Dat maakt het makkelijk om een plc in een bestaand netwerk te hangen.

De uitbreidingsmodules voor in- en uitgangen zijn er in allerlei soorten en maten. Er zijn digitale uitgangen waarmee je bijvoorbeeld een relais kunt aansturen, digitale ingangen waarmee je de state van een druktoets, schakelaar of bewegingsmelder kunt herkennen en analoge in- en uitgangen waarmee je bijvoorbeeld de output van een current transformer kunt meten.




Waar worden ze voor gebruikt?

Plc’s worden op grote schaal in de industrie gebruikt om machines aan te sturen. Dat kunnen bijvoorbeeld machines zijn in een productielijn maar ook een mobiele kraan of een glazenwassersinstallatie. Plc's zijn ook prima geschikt voor gebouwautomatisering en, op kleinere schaal, domotica.


Wat is het verschil met knx?

Knx-apparaten zijn voorzien van voorgekookte programmeerbare functionaliteit die je via de programmeersoftware ETS aan elkaar kunt knopen. Je stelt er bijvoorbeeld mee in dat een schakelactor voor een bepaalde tijd ingeschakeld wordt als een bewegingsmelder beweging detecteert. Een plc is af-fabriek een dom apparaat dat niets anders kan dan de status van de aangesloten inputs en outputs lezen. Je kunt ofwel zelf een programma schrijven of tekenen (in een visuele programmeertaal) waarmee de outputs gaan reageren op de inputs en dat op de plc laden of je leest de inputs en outputs uit via ethernet en gebruikt externe software (bijvoorbeeld een domoticapakket zoals OpenHab of IP Symcon) om iets zinvols te doen met de informatie. Je moet dus wat meer zelf doen. Omdat je niet voor ingebakken slimmigheden hoeft te betalen zijn de kosten ook lager.

Een ander belangrijk verschil is dat knx een bustopologie heeft. Hoewel de bekabeling vaak stervormig wordt aangelegd (bijv. alle kabels naar de meterkast waar de knx-apparatuur wordt aangesloten) is dat geen verplichting. Bij een plc leg je wel altijd alle kabels in stervorm centraal naar de plc. Met behulp van buskoppelaars is het overigens wel mogelijk om op een andere plek (bijvoorbeeld in de schuur) uitbreidingsmodules op te hangen maar de kabels zullen dan daar opnieuw stervormig naar de buskoppelaar met uitbreidingsmodules aangelegd moeten worden.


Is het moeilijk?

Mijn ervaring is beperkt tot de plc's van Wago. Als je voor de tweede optie gaat (in- en uitgangen uitlezen en aansturen via een domoticapakket) is de moeilijkheidsgraad laag. Het is dan een kwestie van de plc configureren (instellen welk type uitbreidingsmodules er zijn aangesloten) en in de domoticasoftware modbusinstanties aanmaken voor de adressen die corresponderen met de in- en uitgangen op de plc.



Het programmeren van een plc zal een wat grotere investering in tijd vergen. De programmeertalen voor plc's zijn gestandaardiseerd. Er zijn verschillende talen waaronder ook visuele programmeertalen die relatief toegankelijk zijn voor een beginner. Wago heeft tegenwoordig ook Linux-gebaseerde plc's (Wago PFC200) waarmee je o.a. in php de plc kunt programmeren.




Waarom moet ik een plc willen?

- Plc's zijn gemaakt voor industriële toepassingen en dus betrouwbaar.

- Er zit niets op aan voorgekookte functionaliteit die je in de weg kan zitten of de kosten onnodig verhoogt.

- Plc's zijn schaalbaar en geschikt voor grote installaties. Een Wago 750-node mag een lengte hebben van maximaal 78cm (ruim 60 uitbreidingmodules met 2-16 inputs of outputs per stuk) en als je daar niet genoeg aan hebt bouw je lekker verder met behulp van een buskoppelaar.

- De kosten van de digitale in- en uitgangen zijn laag. Voor zo'n 30-40 euro koop je een nieuwe uitbreidingsmodule met vier 24V in- en of uitgangen. Analoge modules zijn wel fors duurder en kosten nieuw al snel 100-250 euro per vier in- of uitgangen.

- Er is op eBay een groot aanbod van hardware die afkomstig is uit ontmantelde industriële installaties. Op eBay scoor je deals van 6 tot 15 euro voor een viervoudige digitale in- of uitgang. Als je de plc eenmaal hebt kun je dus goedkoop uitbreiden.

- Omdat ze gemaakt zijn voor din-rail montage maak je er makkelijk een cleane install mee die ook kan groeien zonder dat het een bende wordt. Zorg wel voor goed en doordacht kabelmanagement.

- Vergeleken met een Arduino of Raspberry Pi zijn de kosten hoger maar ben je mijn inziens wel minder tijd kwijt aan aansluitwerk. Ook kun je aantal inputs en outputs veel makkelijker opschalen en maak je makkelijker een goed georganiseerde build.

- Omdat de aansturing van een relais en het relais zelf uit verschillende componenten bestaan kun je die bij een defect individueel vervangen ipv dat je bijvoorbeeld bij een meervoudige knx-schakelactor moet vervangen.

- Je hebt alle vrijheid om per indivueel apparaat de meest geschikte oplossing te kiezen. Heb je bijvoorbeeld een led-voeding met een hoge inschakelstroom die moeizaam geschakeld kan worden met een mechanisch relais dat trek je voor dat geval een solid state relais uit het schap en gebruik je voor de rest goedkopere spoelrelais.


Wat kost het?

Een Wago Ethernet Start Kit 2 kost je 540 euro. Voor dat geld krijgt je een 750-881-plc, tweevoudige digitale in- en uitgangen, een 750-600-eindmodule, een 24VDC-voeding, usb-kabel, een stukje din-rail, een schakelaar en de programmeersoftware. Hiermee heb je alles dat nodig is om je eerste 'hello world’-bouwsel te maken.



Voor wat meer geld koop je een Wago 750-8204 aka PFC200. Dit is de nieuwste serie van Wago gebaseerd op een real-time Linux-besturingssysteem en een Cortex A8-processor. De programmering verloopt via Wago e!Cockpit dat gebaseerd is op Codesys 3.5. Deze ontwikkelomgeving is aanzienlijk moderner dan de Codesys 2.3-gebaseerde ontwikkelomgeving voor de Wago 750-881. Voor 80 euro kun je targets voor Codesys 3.5 direct bij de makers van Codesys aanschaffen. Codesys zelf kan gratis gedownload worden. Dit is niet hoe Wago het graag ziet maar op die manier kun je zonder een dure e!Cockpit-licentie te moeten kopen toch je PFC200 programmeren. Een PFC200 kost ongeveer 725 euro. Je moet er dan nog minimaal een voeding en 750-600 eindmodule bij kopen. Deze module sluit de interne bus van de plc af.



Het kan goedkoper door een plc van eBay te halen, maar dan krijg je de programmeersoftware (een Wago-variant van Codesys) er niet bij die noodzakelijk is om de plc te configureren en programmeren.

De (digitale) uitbreidingsmodules zijn zogezegd vrij goedkoop en ruim voorhanden op eBay. De meeste digitale modules werken op een spanning van 24V. Een digitale ingang kun je direct aansluiten op een wandschakelaar. Om bijv. een 5V output van een bewegingsmelder uit te lezen met een 24V input op de plc heb je een relais of optocoupler nodig. Hiervoor is goedkoop spul te krijgen uit de Arduinowereld.

Voor het schakelen van verlichting en andere apparaten kun je relais gebruiken die werken op een spoelspanning van 24V. Zie hiervoor het assortiment van bijvoorbeeld Finder. Een 230V 16A relais van Finder is op eBay te krijgen vanaf € 7,50.

Verder heb je nog bijkomende kosten voor de bedrading, kabelgoten, rails, rijgklemmen, adereindhulzen en dergelijke. Dit kan alles bij elkaar ook nog wel een kostenpost van honderden tot duizenden euro’s worden.


Wat heb je nodig om aan de slag te gaan?

  • Een ruimte waar je de plc en alle bijkomende onderdelen monteert. Dat kan zijn een schakelkast die je ergens ophangt of een schakelplank in de meterkast. Zorg voor voldoende ruimte, die ga je nodig hebben als de installatie in omvang toeneemt.
  • 35mm din-rails om de controller, I/O-modules, voedingen, rijgklemmen en dergelijke op te monteren.
  • Een 24V DC voeding (Mean Well levert betaalbare voedingen). 1 tot 2,5A is voldoende afhankelijk van hoeveel hardware je eraan gaat hangen.
  • Rijgklemmen voor het aansluiten van kabels en aders. Zie het assortiment van Wago, Phoenix Contact en Weidmuller.
  • Aders in verschillende kleuren voor verdeling van de voeding en het aansluiten van input en outputs.
  • Kabels om sensoren en actoren op afstand met de rijgklemmen te verbinden. Cat5- en cat6-kabel leent zich prima voor het aansluiten van bijvoorbeeld relais, sensoren en pulsdrukkers. Goedkope copper clad meuk volstaat.
  • Adereindhulzen en een perstang om aders met flexibele draad te confectioneren.
  • Adernummering om aders te nummeren.

Best practices

Inrichten van een schakelkast
Het bouwen van een schakelkast is een kunst op zich. Er zijn veel oplossingen verkrijgbaar om de inrichting van een schakelkast veilig, overzichtelijk en beheersbaar te maken. Een aantal tips:
  • Monteer binnenkomende stuurkabels niet direct af op de input- en outputmodules van je plc maar gebruik hiervoor rijgklemmen. Op die manier kun je binnenkomende kabels makkelijker naar een andere input of output van de plc patchen en kun je rijgklemmen gebruiken voor potentiaalverdeling (van de massa) zodat er minder aders op de input- en outputmodules aangesloten hoeven te worden.
  • Gebruik etageklemmen om ruimte te besparen. Etageklemmen zijn verkrijgbaar in allerlei soorten en maten. Een rijgklem met drie etages kun je bijvoorbeeld gebruiken om aarde, fase en nul door te verbinden of om de massa, voeding en output van een sensor aan te sluiten. De massa en voeding kun je op een makkelijk manier verdelen door dezelfde etage van naastgelegen etageklemmen met behulp van bruggen met elkaar te verbinden. Bij de etage waarop je de output van een sensor aansluit die je dit natuurlijk niet, die verbindt je door met een input van de plc.
  • Deel de schakelkast op in verschillende etages en gebruik kabelgoten om de kabels en aders naar de verschillende etages in de schakelkast te geleiden. De binnenkomende stuurkabels monteer je helemaal boven (of onder) in de kast (afhankelijk van waar de kabels binnenkomen) af op rijgklemmen en trek je door naar de input/outmodules op een onder- of bovenliggende rail. Tussen horizontale kabelgoten heb je minimaal 14cm ruimte nodig om rijgklemmen en I/O-modules (in het geval van Wago en Beckhoff) op een comfortabele manier op de rail te kunnen monteren.
  • Zorg voor een goede scheiding tussen netspanning en zwakstroom/gelijkstroom. Aders waar 230V door gaat mogen niet in aanraking komen met aders van stuurkabels die onvoldoende isolatie hebben om 230V te weerstaan. Bij voorkeur netspanning en gelijkstroom door verschillende kabelgoten onderbrengen maar als ze toch door dezelfde goot moeten dan de kabels/aders gescheiden van elkaar links of rechts of onder/boven in de kabelgoot houden.
  • Het is verstandig om de voeding van de controller en de field/sensor supply afzonderlijke af te zekeren zodat kortsluiting in bijvoorbeeld een stuurkabel of voedingskabel van een sensor geen gevolgen heeft voor de uptime van de controller. Afzekeren doe je aan de secundaire kant van de voeding met behulp van zekeringsklemmen. Er zijn klemmen waar je standaard glaszekeringen in kunt plaatsen en duurdere modules met een elektronische beveiliging. Zekeringsklemmen vind je onder andere bij Phoenix Contact, Wago en ETA.
  • Gebruik een consistente kleurcodering voor aders die een verschillende potentialen dragen. Dus bruin, blauw en groen/geel voor 230V AC fase, nul en aarde en bijvoorbeeld wit voor massa, rood voor 24V DC, oranje voor 12V DC en geel voor 5V DC.
Ter inspiratie kun je op google zoeken naar afbeeldingen van een 'sps schaltschrank' (sps staat voor Speicherprogrammierbare Steuering, de Duitse vertaling van plc). Enkele mooie voorbeelden:







Vermijden van single points of failure
Vergelijken met decentrale systemen zoals knx is een plc meer gecentraliseerd. Als de controller uitvalt stopt het programma en kunnen de inputs en outputs van de plc niet meer uitgelezen en aangestuurd worden. Om te voorkomen dat je huis onbestuurbaar wordt is het verstandig om te na te denken over oplossingen om de beschikbaarheid van het systeem te verhogen.

Een makkelijke spof om te verhelpen is de voeding. Met behulp van redundant uitgevoerde voedingen en een redundancy module kun je voorkomen dat het hele systeem op zijn gat ligt als de voeding faalt. Voorbeelden van redundancy modules zijn de Mean Well RD-RDN20 (alleen 24V DC) en Phoenix Contact Step Diode (geschikt voor 5-24V DC). De betere redundancy modules beschikken over een alarm output die je op een ingang van je plc kunt aansluiten om de status van de voedingen te monitoren. Gebruik je geen redundancy module dan is het in ieder geval verstandig om een reservevoeding op voorraad te hebben.

[Voor 62% gewijzigd door Femme op 11-02-2016 12:48]


Acties:
  • +2Henk 'm!
  • Pinned

  • jellevictoor
  • Registratie: maart 2007
  • Laatst online: 23-05 09:09
ondertussen heb ik het niet meer voor gehad dat de PLC faalt bij het starten. Wanneer ik het opnieuw voor heb, ga ik dit proberen, thanks!

Ondertussen heb ik een generieke button geschreven die een mqtt genereerd en dat dan naar een topic stuurt op mijn PLC. Op die manier kan ik effectief pushen vanop mijn PLC.
Ik vroeg me af of er hier iemand enorm bedreven is in het schrijven van PLC software die mijn code even wil reviewen? Ik ben zelf programmeur, maar dit is compleet nieuw voor mij en vind geen zo'n grote online community. Ik ben hier dus wat aan het spelen met bestaande libs die ik mash tot een geheel.

Wat me enorm stoort aan deze code is dat het MQTT stuk aan het eind van de cycle moet. Wanneer ik dit niet doe, stuurt de PLC geen berichten en crashed de ganse IDE. Vandaar kan ik per cycle maar 1 bericht schrijven. In praktijk werkt het wel lekker, de cycles van de wago zijn zo snel, dat dit geen verschil maakt
code: PLC_PRG
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
41
42
43
44
45
46
47
48
49
50
51
PROGRAM PLC_PRG
VAR
    input_001 AT %IX0.0: BOOL;
    input_002 AT %IX0.1: BOOL;
    input_003 AT %IX0.2: BOOL;
    input_004 AT %IX0.3: BOOL;

    button_001: BUTTON;
    button_002: BUTTON;
    button_003: BUTTON;
    button_004: BUTTON;

    button_time: TIME:=t#600ms;

    pub:BOOL;
    subi:BOOL;
    payload:STRING;
    topic:STRING;
    mqttClient: MQTT_Client;
END_VAR

pub:=FALSE;
subi:=FALSE;
payload:='';
IF NOT pub THEN
    topic:='dev/switch/1';
    button_001(IN:=input_001, PT:=button_time, pub=>pub, payload=>payload);
END_IF
IF NOT pub THEN
    topic:='dev/switch/2';
    button_002(IN:=input_002, PT:=button_time, pub=>pub, payload=>payload);
END_IF
IF NOT pub THEN
    topic:='dev/switch/3';
    button_003(IN:=input_003, PT:=button_time, pub=>pub, payload=>payload);
END_IF
IF NOT pub THEN
    topic:='dev/switch/4';
    button_004(IN:=input_004, PT:=button_time, pub=>pub, payload=>payload);
END_IF

mqttClient(
    sTopic:= topic,
    sPayload:= payload ,
    sIp:= IP ,
    wPortNumber:= PORT ,
    sUsername:= USERNAME ,
    sPassword:= PASS,
    xPublish:= pub ,
    xSubscribe:= subi
);


code: BUTTON
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
41
42
43
44
FUNCTION_BLOCK BUTTON
VAR_INPUT
    IN: BOOL;
    PT: TIME;
END_VAR
VAR_OUTPUT
    pub: BOOL;
    payload:STRING;
END_VAR
VAR
    tx:TP;
    CNT: INT:=0;
    edge: BOOL:=FALSE;
    long: BOOL:=FALSE;
END_VAR
pub:= FALSE;

payload:='';
tx(IN:=IN,PT:=PT);
(* Q == true -> pressed *)
IF IN THEN
    IF NOT tx.Q THEN
        IF CNT = 0 THEN
            payload := 'long';
            pub:=TRUE;
            long:=TRUE;
            (* need to reinit the counter, still going strong! *)
            tx(IN:=FALSE,PT:=PT);
            tx(IN:=IN,PT:=PT);
        END_IF
    END_IF
ELSIF tx.Q AND edge THEN
    IF NOT long THEN
        (* found an edge!*)
        cnt := cnt +1;
    END_IF
    long:=FALSE;
END_IF
IF NOT tx.Q AND cnt > 0 THEN
    pub:=TRUE;
    payload := INT_TO_STRING(cnt);
    cnt := 0;
END_IF
edge := IN;


Acties:
  • +2Henk 'm!
  • Pinned

  • MichVw
  • Registratie: mei 2017
  • Laatst online: 22:17
quote:
BlackShadow schreef op zondag 27 augustus 2017 @ 19:52:
[...]


Perfect, heb je wat plc en openhab code om te delen?

Dan ga ik ook kijken wat ik nog kan doen met MQTT, er is een library voor Wago 750 waarmee je kan subscriben, maar niet publishen.
plc code heb ik reeds, openhab code nog niet. ik focus me momenteel op kernfunctionaliteit in de PLC, kijken of alles correct werkt doe ik met behulp van Node-Red, eenmaal dat goed zit ga ik de openhab bindings configureren.

Ik heb dus wel alvast wat plc code voor je, het is wel een proof of concept er dient nog wat aan gesleuteld worden (function blocks maken etc..).

Om te beginnen maak ik gebruik van een sequential function chart om alles wat overzichtelijke te houden. Helaas kan ik er hier geen afbeelding van posten maar simpel gezegd voert het 2 stukjes codes uit achter elkaar in een loop; het lezen van de inputs en het schrijven van de outputs. voor de inputs maak ik gebruik van een drukknop in combinatie met de 'CLICK_MODE' function blok van OSCAT aangezien deze ook dubbelpushes en long presses kan detecteren.

Ik heb 2 variabelen in het NOVRAM geheugen om een ouput hoog of laag te maken, dit zijn dus simpele flags die kunnen geschreven worden aan de hand van modbus.

Variablen:
code:
1
2
3
4
5
6
PROGRAM PLC_PRG
VAR
    FB_DI_02_1: CLICK_MODE;
    DO_01_1_ON AT %MX0.0: BOOL;
    DO_01_1_OFF AT %MX0.1: BOOL;
END_VAR

Lezen inputs:
code:
1
2
3
4
FB_DI_02_1(
    IN:= DI_02_1,
    T_LONG:= T#400ms
);

Schrijven outputs:
code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
F (FB_DI_02_1.SINGLE OR DO_01_1_ON OR DO_01_1_OFF) THEN
    IF(DO_01_1 AND DO_01_1_OFF) THEN
        DO_01_1:=FALSE;
    END_IF
    IF(NOT(DO_01_1) AND DO_01_1_ON) THEN
        DO_01_1:=TRUE;
    END_IF
    IF(FB_DI_02_1.SINGLE) THEN
        DO_01_1:=NOT(DO_01_1);
    END_IF
    DO_01_1_ON:=FALSE;
    DO_01_1_OFF:=FALSE;
END_IF
IF FB_DI_02_1.DOUBLE = TRUE THEN
    DO_01_2:=NOT(DO_01_2);
END_IF
IF FB_DI_02_1.TP_LONG = TRUE THEN
    DO_01_3:=NOT(DO_01_3);
END_IF

Met deze code is het mogelijk om een single press/ double press en long press te detecteren op één enkele input. Daar komt nog bij dat de single press output kan gesimuleerd worden aan de hand van de flags in het NOVRAM geheugen. Werkt allemaal perfect, ik ga me nu wat bezighouden met er functieblokken en dergelijke van te maken. Hou er rekening mee dat data in het NOVRAM geheugen niet verloren gaat als de stroom uitvalt. het is dus belangrijk om parameters te resetten indien nodig tijdens startup van je PLC zodat er geen kans is dat er functioneel iets verkeerd gaat.

Acties:
  • +2Henk 'm!
  • Pinned

  • Sandolution
  • Registratie: november 2015
  • Laatst online: 25-05 13:20
Hi allemaal,

Zelf ben ik ook aan het kijken om mijn domotica systeem uit te breiden met een PLC

Ik ben ooit begonnen met OpenHAB op een Pi1, maar na de release van OpenHAB 2 kan ik mijn RFlink niet meer aansluiten. Daarnaast was Java niet mijn sterkste kant. Ik ben daarom destijds overgestapt op Domoticz. Deze ondersteunde niet alleen RFlink, maar ook MySensors en nog wat andere bruikbare dingen.

Omdat ik nog bij mijn ouders woon, heb ik niet de mogelijkheid om deze woning te verbouwen. Daarom heb ik de lampen in het huis voorzien van aangepaste KlikAanKlikUit schakelaars,waarbij de originele printplaat vervangen is door mijn eigen printplaat die via NRF24L01 communiceert met de MySensor Gateway op de PI. Ook hebben deze schakelaars nu wat meer sensoren zoals beweging, lichtintensiteit en temperatuur. Daarover misschien later meer.

Ik heb afgelopen maand een complete re-design van het 'hart' van het systeem gedaan: Alles netjes in een kastje (Schneider Thalassa), op DIN-rail. Dat ziet er als volgt uit:

Daarin is links onderin een Wiemann 24V2,5A voeding te zien. Bovenin zijn omvormers naar 3.3v en 5v, de PI 3B+, custom printplaat voor aansluitingen, Arduino Mega (RFLink) en de NRF24L01-PA te zien. Verder nog een rijtje Wago klemmen om de voedingen te verdelen. Ik moet er nog wartels in maken voor de kabels naar buiten toe.

Het idee van dit systeem is om een klein, compact systeem te maken wat in de meterkast gehangen kan worden. Er hoeft ook alleen maar basic functionaliteit in zoals licht, weer etc. Als ik na de zomer mijn eigen huis heb, wil ik een veel uitgebreider systeem gaan maken. Hoe dat precies vorm moet gaan krijgen weet ik nog niet.

Echter, om daar alvast op voor te bereiden, ben ik bezig met het koppelen van een CoDeSys3 PLC aan Domoticz. Gezien PLC programmeren mijn werk is, ben ik op dat vlak veel sterker dan bijvoorbeeld programmeren van LUA of DzVents. Daarbij maak ik gebruik van Domoticz/Raspbian als koppeling met de verschillende sensoren en functies die niet in een PLC kunnen. Veel zaken worden middels CRON-jobs geschreven naar custom sensoren van Domoticz.

Die lees ik uit via HTTP-requests vanuit de PLC. Zo heb ik alle data van Domoticz ook in mijn PLC, waarmee ik dus makkelijk kan programmeren. Aansturen gebeurd op dezelfde manier. Ik wil tevens nog kijken of dit eventueel via MQTT kan. Alles is nog in een begin stadium, dus nog volop in ontwikkeling.

Ik gebruik daarvoor een C300 PLC van Lenze:


Die kost ongeveer rond de €300 euro. Daarbij komt dan nog wel de programmeer software. Ik weet zo even niet wat die kost, gezien ik die van het werk heb. Wel weet ik dat die 30 dagen gratis uit te proberen is:
http://www.lenze.com/en-gb/go/akb/201105919/1/.

Achter deze PLC kunnen eventueel ook I/O slices gehangen worden voor interfacing met de wereld. Hiervoor zijn verschillende type modules beschikbaar, net als het Wago systeem.

In de toekomst wil ik de losse PLC misschien vervangen door een scherm met ingebouwde PLC: De P300. Daarbij zit dus de CoDeSys3 PLC en de visualisatie in één. Daar kunnen dan echter geen losse I/O slices aan verbonden worden, maar die kunnen weer verbonden worden middels een EtherCAT kopstation.
.

Al met al dus ideeën zat om de domotica te laten besturen vanuit een PLC!

[Voor 4% gewijzigd door Sandolution op 05-01-2019 17:48]


Acties:
  • +6Henk 'm!
  • Pinned

  • matthijs33
  • Registratie: oktober 2010
  • Laatst online: 14:32
Het is ondertussen al enkele maanden geleden dat ik in dit forum mijn plannen heb gedeeld voor in mijn nieuwbouw woning.

Ondertussen ben ik 2 weken geleden verhuisd, en doet de WAGO PLC zijn (basic) werk.
Momenteel worden alle lichten, rolluiken, screens en de 2 dimmers (6 kanalen) bestuurd door de PLC.

De lichten worden met drukknoppen binnen gelezen in digitale ingangen, en met digitale uitgangen worden relais aangestuurd (16A).
De screens en rolluiken gebruiken ook digitale in-en uitgangskaarten en hebben 2 relais per screen/rolluik (20 relais in totaal).
De PLC heeft ook een DMX module om de 2 dimmers aan te sturen.
Dit alles is in een industriële metalen kast geplaatst (0.8x1m)


De volgende stap is een UI te voorzien op een Rasberry PI, om alles via de GSM te kunnen besturen.
Over de software voor de UI ben ik nog niet helemaal over uit, de communicatie tussen de PI en de WAGO PLC zal waarschijnlijk MQTT worden.
De bedoeling is dat deze software de geavanceerdere taken op zich neemt, maar de basis taken zullen blijven werken met enkel de PLC. (als de PI crashed, dat ik alles nog kan bedienen met de drukknoppen in huis.)
Hopelijk heb ik hier de komende maanden wat tijd voor, maar er is ook nog ander werk in het huis die de nodige prioriteit nodig heeft :)

Vragen of (opbouwende) kritiek is altijd welkom :)

Acties:
  • +5Henk 'm!
  • Pinned

  • WebStarVenlo
  • Registratie: september 2012
  • Laatst online: 08:38
Zelf heb ik een andere oplossing bedacht om vanuit de PLC de verschillende inputs te detecteren en door te sturen via MQTT.
Ik maak gebruik van de zelfde MQTT library.

Door een queue te maken van berichten heb ik ondervangen dat als er meerdere inputs wijzigen, alle berichten na elkaar verstuurd worden.

Hiervoor heb ik een aantal functie blokken gemaakt en wat globale variables.

Globale variables:

code:
1
2
3
4
5
6
7
8
9
10
11
12
13
VAR_GLOBAL
    (*MQTT Settings / variables*)
    MQTT_IP: STRING := '192.168.0.2';
    MQTT_PORT: WORD := 1883;
    MQTT_CLIENT_ID: STRING := '1234';
    MQTT_USER: STRING;
    MQTT_PASS: STRING;
    MQTT_MESSAGE_QUEUE: ARRAY[1..20] OF MQTT_MESSAGE; (*Array to store the outgoing messages, extend the size if more messages need to be stored*)
    MQTT_MESSAGE_QUEUE_SIZE: USINT := 20; (*message queue length*)
    MQTT_MESSAGE_QUEUE_CURRENT: USINT := 0; (*used for sending, the current message in the queue that is processed*)
    MQTT_MESSAGE_QUEUE_LAST: USINT := 0; (*the last added message in the queue*)
    MQTT_SEND : MQTT_SEND;
END_VAR



Data type:

code:
1
2
3
4
5
6
7
TYPE MQTT_MESSAGE :
STRUCT
    Topic: STRING;
    Payload: STRING;
    DateTime: DT;
END_STRUCT
END_TYPE



FB om de berichten daadwerkelijk te verzenden, wordt aangeroepen op het laatst van het main programma

code:
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
41
42
43
44
45
46
47
(*HEADER*)
FUNCTION_BLOCK MQTT_HANDLER
VAR_INPUT
END_VAR
VAR_OUTPUT
END_VAR
VAR
    MQTT_Client : MQTT_Client;
    Message: MQTT_Message;
END_VAR
VAR_IN_OUT
END_VAR
VAR RETAIN
    Connected: BOOL;
    Busy: BOOL;
    Publish: BOOL;
    SkipCycle: BOOL;
END_VAR

(*BODY*)
IF NOT SkipCycle AND NOT Publish AND NOT Busy AND  MQTT_MESSAGE_QUEUE_CURRENT <> MQTT_MESSAGE_QUEUE_LAST THEN
    MQTT_MESSAGE_QUEUE_CURRENT := MQTT_MESSAGE_QUEUE_CURRENT + 1;

    IF MQTT_MESSAGE_QUEUE_CURRENT > MQTT_MESSAGE_QUEUE_SIZE THEN
        MQTT_MESSAGE_QUEUE_CURRENT := 1;
    END_IF

    Message := MQTT_MESSAGE_QUEUE[MQTT_MESSAGE_QUEUE_CURRENT];
    Publish := TRUE;
    SkipCycle := TRUE;
END_IF

IF NOT Publish AND SkipCycle THEN
    SkipCycle := FALSE;
END_IF

MQTT_Client(
    sTopic:= Message.Topic,
    sPayload:= Message.Payload,
    sIp:= MQTT_IP,
    sClientId:=MQTT_CLIENT_ID,
    iPortNumber:= MQTT_PORT,
    sUsername:= MQTT_USER,
    sPassword:= MQTT_PASS,
    xPublish:= Publish,
    xConnected=> Connected,
    xBusy=> Busy);



FB om een bericht aan de queue toe te voegen

code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
(*HEADER*)
FUNCTION_BLOCK MQTT_SEND
VAR_INPUT
    Topic : STRING;
    Payload: STRING;
END_VAR
VAR_OUTPUT
END_VAR
VAR
    Message: MQTT_MESSAGE;
END_VAR

(*BODY*)
MQTT_MESSAGE_QUEUE_LAST := MQTT_MESSAGE_QUEUE_LAST + 1;
IF MQTT_MESSAGE_QUEUE_LAST > MQTT_MESSAGE_QUEUE_SIZE THEN
    MQTT_MESSAGE_QUEUE_LAST := 1;
END_IF

Message.Topic := Topic;
Message.Payload := Payload;
Message.DateTime := SysRtcGetTime(TRUE);

MQTT_MESSAGE_QUEUE[MQTT_MESSAGE_QUEUE_LAST] := Message;



En het main programma met de logica / aanroep

code:
1
2
3
4
5
6
(*call to add new message to the queue*)
MQTT_SEND(Topic:= 'home/floor-0/livging-room/switch/dining-table-lights', Payload:='message content');

MQTT_SEND(Topic:= 'home/floor-0/livging-room/switch/dining-table-lights', Payload:='next message');

MQTT_HANDLER();



De enige beperking aan deze manier van verzenden is de lengte van de queue, als er meer en sneller berichten in de queue geplaatst worden dan dat deze worden verzonden zullen niet verzonden berichten worden overschreven.

Dit is wel redelijk te voorkomen door de lengte van de queue groter te maken, deze kan nu maximaal 20 berichten bevatten, maar kan gewenst groter worden gemaakt.
Voor mij is dit ruim voldoende, de kans dat er 20 schakelaars en/of deurcontacten gelijktijdig worden aangesproken lijkt me onwaarschijnlijk.

Acties:
  • +9Henk 'm!
  • Pinned

  • VBP8501
  • Registratie: februari 2017
  • Laatst online: 24-05 22:30
Juist de laatste hand gelegd aan de montageplaat van de kast. Nu wat spierkracht vinden om het op te hangen..

'k zal later nog wat meer duiding geven bij mijn keuzes, maar laat ons zeggen dat het sterk geïnspireerd is op de info in dit forum en de blogpost van Femme (waarvoor dank _/-\o_ )

https://photos.app.goo.gl/SZaWbSfjd1LCicz77

Het was wel niet eenvoudig om alles erin te krijgen. 120x120 is zowat de grootste hangkast die ik kon vinden en ik wou absoluut vermijden om meerdere kasten te plaatsen. En staande kasten waren nog is dubbel de prijs 8)7 Ik heb daarom op voorhand alles in autocad uitgetekend. Iedere klem had ik eerst digitaal geplaatst voordat ik aan het fysieke werk begon.

Hetgeen nog niet geklableerd is en niet op de plaat past, zijn de 5V/24V level omvormer voor de PIR sensoren (eerder genoemde panasonics). Die ga ik aan de linker binnenkant van mijn kast hangen.

Een paar snelle tips die ik niet heb gevonden op het forum maar die anderen misschien kunnen helpen:
- probeer te standaardiseren, niet teveel verschillende soorten klemmen gebruiken, ook niet teveel kabelsecties
- 1 kabel = 1 klem is leuk maar voor een UTP heb je dan een 8 etage klem nodig die veel teveel plaats inneemt. Ik laat bv de UTP van mijn drukknoppen (altijd dubbele drukknop + 2 statusleds + 1-wire apparaat) toekomen op een 4 etage klem voor de 2DI's en 2DO's en de 24V voeding, GND, en de 1-wire op potentiaalverdelers. Ook gebruik je niet altijd alle draden van een UTP (lusje voor magneetsensoren bv). Zonde van de plaats.
- Kabelgoten met een diepte die ongeveer gelijk komen met de bovenkant van je automaten lijkt mij een goede maat (6cm in mijn geval)
- Neem diepe DIN rail (niet de platte variant) met gaten, werkt veel gemakkelijker
- Een kast met een montageplaat wil zeggen dat je eerst de kast kunt hangen, alles op de montageplaat monteren en vervolgens de montageplaat in de kast... monteren
- Ik heb 0.75mm² gebruikt voor het merendeel van het laagspanningsgedeelte (ook voor de DI's en DO's). Bij nader inzien had ik beter iets kleiner van sectie genomen voor de DI's en DO's. Keuze gemaakt om gemakkelijker te kunnen hanteren.
- Flexibele draad gebruiken voor het hoogspanningsgedeelte is leuk, legt zich mooi in de kabelgoten. Maar als je de preflex op maat begint te snijden heb je echt veel korte stukken draad over. Ik heb vooral daarvan gebruik gemaakt (hoewel ik ook flexibele had liggen).
Pagina: 1


Apple iPhone SE (2020) Microsoft Xbox Series X LG CX Google Pixel 4a CES 2020 Samsung Galaxy S20 4G Sony PlayStation 5 Nintendo Switch Lite

'14 '15 '16 '17 2018

Tweakers vormt samen met Hardware Info, AutoTrack, Gaspedaal.nl, Nationale Vacaturebank, Intermediair en Independer DPG Online Services B.V.
Alle rechten voorbehouden © 1998 - 2020 Hosting door True