You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@plc4x.apache.org by cd...@apache.org on 2022/01/06 16:37:19 UTC

[plc4x] branch develop updated: feature(plc4go): simulated driver, connection pool

This is an automated email from the ASF dual-hosted git repository.

cdutz pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/plc4x.git


The following commit(s) were added to refs/heads/develop by this push:
     new c76b28e  feature(plc4go): simulated driver, connection pool
c76b28e is described below

commit c76b28ee125970b611ae608e5884121ef790facc
Author: cdutz <ch...@c-ware.de>
AuthorDate: Thu Jan 6 17:37:10 2022 +0100

    feature(plc4go): simulated driver, connection pool
---
 Jenkinsfile                                        |   2 +-
 plc4go/go.mod                                      |   6 +-
 plc4go/go.sum                                      |  70 +-
 plc4go/internal/plc4go/knxnetip/FieldHandler.go    |  15 -
 plc4go/internal/plc4go/s7/Driver.go                |   2 +-
 plc4go/internal/plc4go/simulated/Connection.go     | 162 +++++
 .../internal/plc4go/simulated/Connection_test.go   | 758 +++++++++++++++++++++
 plc4go/internal/plc4go/simulated/Device.go         |  76 +++
 plc4go/internal/plc4go/simulated/Device_test.go    | 288 ++++++++
 plc4go/internal/plc4go/simulated/Driver.go         |  79 +++
 plc4go/internal/plc4go/simulated/Driver_test.go    | 326 +++++++++
 plc4go/internal/plc4go/simulated/Field.go          |  71 ++
 plc4go/internal/plc4go/simulated/FieldHandler.go   | 103 +++
 .../internal/plc4go/simulated/FieldHandler_test.go | 169 +++++
 plc4go/internal/plc4go/simulated/Field_test.go     | 291 ++++++++
 plc4go/internal/plc4go/simulated/Reader.go         |  84 +++
 plc4go/internal/plc4go/simulated/Reader_test.go    | 202 ++++++
 plc4go/internal/plc4go/simulated/ValueHandler.go   |  37 +
 plc4go/internal/plc4go/simulated/Writer.go         |  76 +++
 plc4go/internal/plc4go/simulated/Writer_test.go    | 214 ++++++
 .../plc4go/utils/pool/PlcConnectionPool.go         | 158 +++++
 .../plc4go/utils/pool/PlcConnectionPool_test.go    |  88 +++
 .../plc4go/utils/pool/PooledPlcConnection.go       | 188 +++++
 plc4go/pkg/plc4go/pool/plc_connection_pool.go      |  20 +
 24 files changed, 3407 insertions(+), 78 deletions(-)

diff --git a/Jenkinsfile b/Jenkinsfile
index 92e83ea..a49f848 100644
--- a/Jenkinsfile
+++ b/Jenkinsfile
@@ -47,7 +47,7 @@ pipeline {
     }
 
     options {
-        // Kill this job after one hour.
+        // Kill this job after one day.
         timeout(time: 24, unit: 'HOURS')
         // When we have test-fails e.g. we don't need to run the remaining steps
         skipStagesAfterUnstable()
diff --git a/plc4go/go.mod b/plc4go/go.mod
index b783d8e..dcb2101 100644
--- a/plc4go/go.mod
+++ b/plc4go/go.mod
@@ -23,7 +23,6 @@ go 1.16
 
 require (
 	github.com/ajankovic/xdiff v0.0.1
-	github.com/elastic/go-licenser v0.4.0 // indirect
 	github.com/google/gopacket v1.1.19
 	github.com/icza/bitio v1.0.0
 	github.com/jacobsa/go-serial v0.0.0-20180131005756-15cf729a72d4
@@ -31,9 +30,8 @@ require (
 	github.com/rs/zerolog v1.20.0
 	github.com/snksoft/crc v1.1.0
 	github.com/subchen/go-xmldom v1.1.2
-	github.com/tebeka/go2xunit v1.4.10 // indirect
+	github.com/viney-shih/go-lock v1.1.1
 	golang.org/x/net v0.0.0-20211015210444-4f30a5c0130f // indirect
+	golang.org/x/sync v0.0.0-20210220032951-036812b2e83c // indirect
 	golang.org/x/sys v0.0.0-20211102192858-4dd72447c267 // indirect
-	golang.org/x/tools v0.1.8 // indirect
-	gotest.tools/gotestsum v1.7.0 // indirect
 )
diff --git a/plc4go/go.sum b/plc4go/go.sum
index cf5a1e6..d3915ac 100644
--- a/plc4go/go.sum
+++ b/plc4go/go.sum
@@ -3,103 +3,59 @@ github.com/ajankovic/xdiff v0.0.1/go.mod h1:SUmEZ67uB97I0zkiuQ+lb+LOms9ipn8X+p+2
 github.com/antchfx/xpath v0.0.0-20170515025933-1f3266e77307 h1:C735MoY/X+UOx6SECmHk5pVOj51h839Ph13pEoY8UmU=
 github.com/antchfx/xpath v0.0.0-20170515025933-1f3266e77307/go.mod h1:Yee4kTMuNiPYJ7nSNorELQMr1J33uOpXDMByNYhvtNk=
 github.com/coreos/go-systemd v0.0.0-20190321100706-95778dfbb74e/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4=
-github.com/dnephin/pflag v1.0.7 h1:oxONGlWxhmUct0YzKTgrpQv9AUA1wtPBn7zuSjJqptk=
-github.com/dnephin/pflag v1.0.7/go.mod h1:uxE91IoWURlOiTUIA8Mq5ZZkAv3dPUfZNaT80Zm7OQE=
-github.com/elastic/go-licenser v0.4.0 h1:jLq6A5SilDS/Iz1ABRkO6BHy91B9jBora8FwGRsDqUI=
-github.com/elastic/go-licenser v0.4.0/go.mod h1:V56wHMpmdURfibNBggaSBfqgPxyT1Tldns1i87iTEvU=
-github.com/fatih/color v1.10.0 h1:s36xzo75JdqLaaWoiEHk767eHiwo0598uUxyfiPkDsg=
-github.com/fatih/color v1.10.0/go.mod h1:ELkj/draVOlAH/xkhN6mQ50Qd0MPOk5AAr3maGEBuJM=
-github.com/fsnotify/fsnotify v1.4.9 h1:hsms1Qyu0jgnwNXIxa+/V/PDsU6CfLf6CNO8H7IWoS4=
-github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
-github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/google/gopacket v1.1.19 h1:ves8RnFZPGiFnTS0uPQStjwru6uO6h+nlr9j6fL7kF8=
 github.com/google/gopacket v1.1.19/go.mod h1:iJ8V8n6KS+z2U1A8pUwu8bW5SyEMkXJB8Yo/Vo+TKTo=
-github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 h1:El6M4kTTCOh6aBiKaUGG7oYTSPP8MxqL4YI3kZKwcP4=
-github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510/go.mod h1:pupxD2MaaD3pAXIBCelhxNneeOaAeabZDe5s4K6zSpQ=
 github.com/icza/bitio v1.0.0 h1:squ/m1SHyFeCA6+6Gyol1AxV9nmPPlJFT8c2vKdj3U8=
 github.com/icza/bitio v1.0.0/go.mod h1:0jGnlLAx8MKMr9VGnn/4YrvZiprkvBelsVIbA9Jjr9A=
 github.com/icza/mighty v0.0.0-20180919140131-cfd07d671de6 h1:8UsGZ2rr2ksmEru6lToqnXgA8Mz1DP11X4zSJ159C3k=
 github.com/icza/mighty v0.0.0-20180919140131-cfd07d671de6/go.mod h1:xQig96I1VNBDIWGCdTt54nHt6EeI639SmHycLYL7FkA=
 github.com/jacobsa/go-serial v0.0.0-20180131005756-15cf729a72d4 h1:G2ztCwXov8mRvP0ZfjE6nAlaCX2XbykaeHdbT6KwDz0=
 github.com/jacobsa/go-serial v0.0.0-20180131005756-15cf729a72d4/go.mod h1:2RvX5ZjVtsznNZPEt4xwJXNJrM3VTZoQf7V6gk0ysvs=
-github.com/jonboulle/clockwork v0.2.2 h1:UOGuzwb1PwsrDAObMuhUnj0p5ULPj8V/xJ7Kx9qUBdQ=
-github.com/jonboulle/clockwork v0.2.2/go.mod h1:Pkfl5aHPm1nk2H9h0bjmnJD/BcgbGXUBGnn1kMkgxc8=
-github.com/mattn/go-colorable v0.1.8 h1:c1ghPdyEDarC70ftn0y+A/Ee++9zz8ljHG1b13eJ0s8=
-github.com/mattn/go-colorable v0.1.8/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
-github.com/mattn/go-isatty v0.0.12 h1:wuysRhFDzyxgEmMf5xjvJ2M9dZoWAXNNr5LSBS7uHXY=
-github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
 github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/rs/xid v1.2.1/go.mod h1:+uKXf+4Djp6Md1KODXJxgGQPKngRmWyn10oCKFzNHOQ=
 github.com/rs/zerolog v1.20.0 h1:38k9hgtUBdxFwE34yS8rTHmHBa4eN16E4DJlv177LNs=
 github.com/rs/zerolog v1.20.0/go.mod h1:IzD0RJ65iWH0w97OQQebJEvTZYvsCUm9WVLWBQrJRjo=
 github.com/snksoft/crc v1.1.0 h1:HkLdI4taFlgGGG1KvsWMpz78PkOC9TkPVpTV/cuWn48=
 github.com/snksoft/crc v1.1.0/go.mod h1:5/gUOsgAm7OmIhb6WJzw7w5g2zfJi4FrHYgGPdshE+A=
-github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.5.1 h1:nOGnQDM7FYENwehXlg/kFVnos3rEvtKTjRvOWSzb6H4=
+github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
 github.com/subchen/go-xmldom v1.1.2 h1:7evI2YqfYYOnuj+PBwyaOZZYjl3iWq35P6KfBUw9jeU=
 github.com/subchen/go-xmldom v1.1.2/go.mod h1:6Pg/HuX5/T4Jlj0IPJF1sRxKVoI/rrKP6LIMge9d5/8=
-github.com/tebeka/go2xunit v1.4.10 h1:0UO+9YoLpXTZ0DL9XbTmIIibgmKBGiwroo8uhFMSyR0=
-github.com/tebeka/go2xunit v1.4.10/go.mod h1:wmc9jKT7KlU4QLU6DNTaIXNnYNOjKKNlp6mjOS0UrqY=
-github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
-github.com/yuin/goldmark v1.4.0/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
-github.com/yuin/goldmark v1.4.1/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
+github.com/viney-shih/go-lock v1.1.1 h1:SwzDPPAiHpcwGCr5k8xD15d2gQSo8d4roRYd7TDV2eI=
+github.com/viney-shih/go-lock v1.1.1/go.mod h1:Yijm78Ljteb3kRiJrbLAxVntkUukGu5uzSxq/xV7OO8=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
-golang.org/x/lint v0.0.0-20210508222113-6edffad5e616/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
 golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
-golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/mod v0.5.1 h1:OJxoQ/rynoF0dcCdI7cLPktw/hR2cueqYfjm43oqK38=
-golang.org/x/mod v0.5.1/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro=
-golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
-golang.org/x/net v0.0.0-20210805182204-aaa1db679c0d/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 golang.org/x/net v0.0.0-20211015210444-4f30a5c0130f h1:OfiFi4JbukWwe3lzw+xunroH1mnC1e2Gy5cxNJApiSY=
 golang.org/x/net v0.0.0-20211015210444-4f30a5c0130f/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20210220032951-036812b2e83c h1:5KslGYwFpkhGh+Q16bwMP3cOontH8FOep7tGV86Y7SQ=
 golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210119212857-b64e53b001e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20210809222454-d867a43fc93e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20211019181941-9d821ace8654/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20211102192858-4dd72447c267 h1:7zYaz3tjChtpayGDzu6H0hDAUM5zIGA2XW7kRNgQ0jc=
 golang.org/x/sys v0.0.0-20211102192858-4dd72447c267/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1 h1:v+OssWQX+hTHEmOBgwxdZxK4zHq3yOs8F9J7mk0PY8E=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20190624222133-a101b041ded4/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
 golang.org/x/tools v0.0.0-20190828213141-aed303cbaa74/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.1.0/go.mod h1:xkSsbof2nBLbhDlRMhhhyNLN/zl3eTqcnHD5viDpcZ0=
-golang.org/x/tools v0.1.7/go.mod h1:LGqMHiF4EqQNHR1JncWGqT5BVaXmza+X+BDGol+dOxo=
-golang.org/x/tools v0.1.8 h1:P1HhGGuLW4aAclzjtmJdf0mJOjVUZUzOTqkAkWL+l6w=
-golang.org/x/tools v0.1.8/go.mod h1:nABZi5QlRsZVlzPpHl034qft6wpY4eDcsTt5AaioBiU=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
-golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-gotest.tools/gotestsum v1.7.0 h1:RwpqwwFKBAa2h+F6pMEGpE707Edld0etUD3GhqqhDNc=
-gotest.tools/gotestsum v1.7.0/go.mod h1:V1m4Jw3eBerhI/A6qCxUE07RnCg7ACkKj9BYcAm09V8=
-gotest.tools/v3 v3.0.3/go.mod h1:Z7Lb0S5l+klDB31fvDQX8ss/FlKDxtlFlw3Oa8Ymbl8=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
+gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
diff --git a/plc4go/internal/plc4go/knxnetip/FieldHandler.go b/plc4go/internal/plc4go/knxnetip/FieldHandler.go
index 5dd11db..c33f7bb 100644
--- a/plc4go/internal/plc4go/knxnetip/FieldHandler.go
+++ b/plc4go/internal/plc4go/knxnetip/FieldHandler.go
@@ -29,21 +29,6 @@ import (
 	"strconv"
 )
 
-type FieldType uint8
-
-const (
-	FieldCoil FieldType = 0x00
-)
-
-func (m FieldType) GetName() string {
-	switch m {
-	case FieldCoil:
-		// TODO: these looked like copy paste from modbus before change this name might be therefore completly wrong
-		return "KNXNETIPFIELDCOIL"
-	}
-	return ""
-}
-
 type FieldHandler struct {
 	groupAddress3Level             *regexp.Regexp
 	groupAddress2Level             *regexp.Regexp
diff --git a/plc4go/internal/plc4go/s7/Driver.go b/plc4go/internal/plc4go/s7/Driver.go
index 4ab02bb..b6d24c0 100644
--- a/plc4go/internal/plc4go/s7/Driver.go
+++ b/plc4go/internal/plc4go/s7/Driver.go
@@ -47,7 +47,7 @@ func NewDriver() plc4go.PlcDriver {
 
 func (m *Driver) GetConnection(transportUrl url.URL, transports map[string]transports.Transport, options map[string][]string) <-chan plc4go.PlcConnectionConnectResult {
 	log.Debug().Stringer("transportUrl", &transportUrl).Msgf("Get connection for transport url with %d transport(s) and %d option(s)", len(transports), len(options))
-	// Get an the transport specified in the url
+	// Get the transport specified in the url
 	transport, ok := transports[transportUrl.Scheme]
 	if !ok {
 		log.Error().Stringer("transportUrl", &transportUrl).Msgf("We couldn't find a transport for scheme %s", transportUrl.Scheme)
diff --git a/plc4go/internal/plc4go/simulated/Connection.go b/plc4go/internal/plc4go/simulated/Connection.go
new file mode 100644
index 0000000..74d63b4
--- /dev/null
+++ b/plc4go/internal/plc4go/simulated/Connection.go
@@ -0,0 +1,162 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package simulated
+
+import (
+	"github.com/apache/plc4x/plc4go/internal/plc4go/spi"
+	_default "github.com/apache/plc4x/plc4go/internal/plc4go/spi/default"
+	internalModel "github.com/apache/plc4x/plc4go/internal/plc4go/spi/model"
+	"github.com/apache/plc4x/plc4go/pkg/plc4go"
+	"github.com/apache/plc4x/plc4go/pkg/plc4go/model"
+	"github.com/pkg/errors"
+	"strconv"
+	"time"
+)
+
+type Connection struct {
+	device       *Device
+	fieldHandler spi.PlcFieldHandler
+	valueHandler spi.PlcValueHandler
+	options      map[string][]string
+	connected    bool
+}
+
+func NewConnection(device *Device, fieldHandler spi.PlcFieldHandler, valueHandler spi.PlcValueHandler, options map[string][]string) *Connection {
+	connection := &Connection{
+		device:       device,
+		fieldHandler: fieldHandler,
+		valueHandler: valueHandler,
+		options:      options,
+		connected:    false,
+	}
+	return connection
+}
+
+func (c *Connection) Connect() <-chan plc4go.PlcConnectionConnectResult {
+	ch := make(chan plc4go.PlcConnectionConnectResult)
+	go func() {
+		// Check if the connection was already connected
+		if c.connected {
+			// Return an error to the user.
+			ch <- _default.NewDefaultPlcConnectionConnectResult(c, errors.New("already connected"))
+		}
+		if delayString, ok := c.options["connectionDelay"]; ok {
+			// This is the length of the array, not the string
+			if len(delayString) == 1 {
+				delay, err := strconv.Atoi(delayString[0])
+				if err == nil {
+					time.Sleep(time.Duration(delay) * time.Millisecond)
+				}
+			}
+		}
+		// Mark the connection as "connected"
+		c.connected = true
+		// Return the connection in a connected state to the user.
+		ch <- _default.NewDefaultPlcConnectionConnectResult(c, nil)
+	}()
+	return ch
+}
+
+func (c *Connection) BlockingClose() {
+	<-c.Close()
+}
+
+func (c *Connection) Close() <-chan plc4go.PlcConnectionCloseResult {
+	ch := make(chan plc4go.PlcConnectionCloseResult)
+	go func() {
+		// Check if the connection is connected
+		if !c.connected {
+			// Return an error to the user.
+			ch <- _default.NewDefaultPlcConnectionCloseResult(c, errors.New("not connected"))
+		}
+		if delayString, ok := c.options["closingDelay"]; ok {
+			// This is the length of the array, not the string
+			if len(delayString) == 1 {
+				delay, err := strconv.Atoi(delayString[0])
+				if err == nil {
+					time.Sleep(time.Duration(delay) * time.Millisecond)
+				}
+			}
+		}
+		// Mark the connection as "disconnected"
+		c.connected = false
+		// Return a new connection to the user.
+		ch <- _default.NewDefaultPlcConnectionCloseResult(c, nil)
+	}()
+	return ch
+}
+
+func (c *Connection) IsConnected() bool {
+	return c.connected
+}
+
+func (c *Connection) Ping() <-chan plc4go.PlcConnectionPingResult {
+	ch := make(chan plc4go.PlcConnectionPingResult)
+	go func() {
+		if delayString, ok := c.options["pingDelay"]; ok {
+			// This is the length of the array, not the string
+			if len(delayString) == 1 {
+				delay, err := strconv.Atoi(delayString[0])
+				if err == nil {
+					time.Sleep(time.Duration(delay) * time.Millisecond)
+				}
+			}
+		}
+		// Return a new connection to the user.
+		ch <- _default.NewDefaultPlcConnectionPingResult(nil)
+	}()
+	return ch
+}
+
+func (c *Connection) GetMetadata() model.PlcConnectionMetadata {
+	return _default.DefaultConnectionMetadata{
+		ConnectionAttributes: map[string]string{
+			"connectionDelay": "Delay applied when connecting",
+			"closingDelay":    "Delay applied when closing the connection",
+			"pingDelay":       "Delay applied when executing a ping operation",
+			"readDelay":       "Delay applied when executing a read operation",
+			"writeDelay":      "Delay applied when executing a write operation",
+		},
+		ProvidesReading:     true,
+		ProvidesWriting:     true,
+		ProvidesSubscribing: false,
+		ProvidesBrowsing:    false,
+	}
+}
+
+func (c *Connection) ReadRequestBuilder() model.PlcReadRequestBuilder {
+	return internalModel.NewDefaultPlcReadRequestBuilder(c.fieldHandler, NewReader(c.device, c.options))
+}
+
+func (c *Connection) WriteRequestBuilder() model.PlcWriteRequestBuilder {
+	return internalModel.NewDefaultPlcWriteRequestBuilder(c.fieldHandler, c.valueHandler, NewWriter(c.device, c.options))
+}
+
+func (c *Connection) SubscriptionRequestBuilder() model.PlcSubscriptionRequestBuilder {
+	panic("not implemented")
+}
+
+func (c *Connection) UnsubscriptionRequestBuilder() model.PlcUnsubscriptionRequestBuilder {
+	panic("not implemented")
+}
+
+func (c *Connection) BrowseRequestBuilder() model.PlcBrowseRequestBuilder {
+	panic("not implemented")
+}
diff --git a/plc4go/internal/plc4go/simulated/Connection_test.go b/plc4go/internal/plc4go/simulated/Connection_test.go
new file mode 100644
index 0000000..6a74b56
--- /dev/null
+++ b/plc4go/internal/plc4go/simulated/Connection_test.go
@@ -0,0 +1,758 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package simulated
+
+import (
+	"github.com/apache/plc4x/plc4go/internal/plc4go/spi"
+	_default "github.com/apache/plc4x/plc4go/internal/plc4go/spi/default"
+	internalModel "github.com/apache/plc4x/plc4go/internal/plc4go/spi/model"
+	"github.com/apache/plc4x/plc4go/pkg/plc4go"
+	"github.com/apache/plc4x/plc4go/pkg/plc4go/model"
+	"reflect"
+	"testing"
+	"time"
+)
+
+func TestConnection_Connect(t *testing.T) {
+	type fields struct {
+		device       *Device
+		fieldHandler spi.PlcFieldHandler
+		valueHandler spi.PlcValueHandler
+		options      map[string][]string
+		connected    bool
+	}
+	tests := []struct {
+		name         string
+		fields       fields
+		want         plc4go.PlcConnectionConnectResult
+		delayAtLeast time.Duration
+		wantErr      bool
+	}{
+		{
+			name: "simple",
+			fields: fields{
+				device:       NewDevice("hurz"),
+				fieldHandler: NewFieldHandler(),
+				valueHandler: NewValueHandler(),
+				options:      map[string][]string{},
+				connected:    false,
+			},
+			want: _default.NewDefaultPlcConnectionConnectResult(&Connection{
+				device:       NewDevice("hurz"),
+				fieldHandler: NewFieldHandler(),
+				valueHandler: NewValueHandler(),
+				options:      map[string][]string{},
+				connected:    true,
+			}, nil),
+			delayAtLeast: 0,
+			wantErr:      false,
+		},
+		// If the connection was already connected, the
+		// connection should fail with an error.
+		{
+			name: "already connected",
+			fields: fields{
+				device:       NewDevice("hurz"),
+				fieldHandler: NewFieldHandler(),
+				valueHandler: NewValueHandler(),
+				options:      map[string][]string{},
+				connected:    true,
+			},
+			want: _default.NewDefaultPlcConnectionConnectResult(&Connection{
+				device:       NewDevice("hurz"),
+				fieldHandler: NewFieldHandler(),
+				valueHandler: NewValueHandler(),
+				options:      map[string][]string{},
+				connected:    true,
+			}, nil),
+			delayAtLeast: 0,
+			wantErr:      true,
+		},
+		// If the connection should simulate a delay, make sure it doesn't
+		// return immediately.
+		{
+			name: "delayed connected",
+			fields: fields{
+				device:       NewDevice("hurz"),
+				fieldHandler: NewFieldHandler(),
+				valueHandler: NewValueHandler(),
+				options: map[string][]string{
+					"connectionDelay": {"1000"},
+				},
+				connected: false,
+			},
+			want: _default.NewDefaultPlcConnectionConnectResult(&Connection{
+				device:       NewDevice("hurz"),
+				fieldHandler: NewFieldHandler(),
+				valueHandler: NewValueHandler(),
+				options: map[string][]string{
+					"connectionDelay": {"1000"},
+				},
+				connected: true,
+			}, nil),
+			delayAtLeast: time.Second * 1,
+			wantErr:      false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			c := &Connection{
+				device:       tt.fields.device,
+				fieldHandler: tt.fields.fieldHandler,
+				valueHandler: tt.fields.valueHandler,
+				options:      tt.fields.options,
+				connected:    tt.fields.connected,
+			}
+			timeBeforeConnect := time.Now()
+			connectionChan := c.Connect()
+			select {
+			case connectResult := <-connectionChan:
+				timeAfterConnect := time.Now()
+				// If an expected delay was defined, check if connecting
+				// took at least this long.
+				if tt.delayAtLeast > 0 {
+					connectionTime := timeAfterConnect.Sub(timeBeforeConnect)
+					if connectionTime < tt.delayAtLeast {
+						t.Errorf("TestConnection.Connect() connected too fast. Expected at least %v but connected after %v", tt.delayAtLeast, connectionTime)
+					}
+				}
+				// If we wanted an error, but didn't get one or the other way around.
+				if tt.wantErr != (connectResult.GetErr() != nil) {
+					t.Errorf("TestConnection.Connect() hasErr= %v, wantErr %v", connectResult.GetErr() != nil, tt.wantErr)
+				} else if !tt.wantErr {
+					// Check if we're connected.
+					if !reflect.DeepEqual(connectResult, tt.want) {
+						t.Errorf("TestConnection.Connect() = %v, want %v", connectResult, tt.want)
+					}
+				}
+			case <-time.After(3 * time.Second):
+				t.Errorf("TestConnection.Connect() got timeout")
+			}
+		})
+	}
+}
+
+func TestConnection_Close(t *testing.T) {
+	type fields struct {
+		device       *Device
+		fieldHandler spi.PlcFieldHandler
+		valueHandler spi.PlcValueHandler
+		options      map[string][]string
+		connected    bool
+	}
+	tests := []struct {
+		name         string
+		fields       fields
+		want         plc4go.PlcConnectionCloseResult
+		delayAtLeast time.Duration
+		wantErr      bool
+	}{
+		{
+			name: "simple",
+			fields: fields{
+				device:       NewDevice("hurz"),
+				fieldHandler: NewFieldHandler(),
+				valueHandler: NewValueHandler(),
+				options:      map[string][]string{},
+				connected:    true,
+			},
+			want: _default.NewDefaultPlcConnectionCloseResult(&Connection{
+				device:       NewDevice("hurz"),
+				fieldHandler: NewFieldHandler(),
+				valueHandler: NewValueHandler(),
+				options:      map[string][]string{},
+				connected:    false,
+			}, nil),
+			delayAtLeast: 0,
+			wantErr:      false,
+		},
+		{
+			name: "not connected",
+			fields: fields{
+				device:       NewDevice("hurz"),
+				fieldHandler: NewFieldHandler(),
+				valueHandler: NewValueHandler(),
+				options:      map[string][]string{},
+				connected:    false,
+			},
+			want: _default.NewDefaultPlcConnectionCloseResult(&Connection{
+				device:       NewDevice("hurz"),
+				fieldHandler: NewFieldHandler(),
+				valueHandler: NewValueHandler(),
+				options:      map[string][]string{},
+				connected:    false,
+			}, nil),
+			delayAtLeast: 0,
+			wantErr:      true,
+		},
+		{
+			name: "delayed close",
+			fields: fields{
+				device:       NewDevice("hurz"),
+				fieldHandler: NewFieldHandler(),
+				valueHandler: NewValueHandler(),
+				options: map[string][]string{
+					"closingDelay": {"1000"},
+				},
+				connected: true,
+			},
+			want: _default.NewDefaultPlcConnectionCloseResult(&Connection{
+				device:       NewDevice("hurz"),
+				fieldHandler: NewFieldHandler(),
+				valueHandler: NewValueHandler(),
+				options: map[string][]string{
+					"closingDelay": {"1000"},
+				},
+				connected: false,
+			}, nil),
+			delayAtLeast: 1000,
+			wantErr:      false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			c := &Connection{
+				device:       tt.fields.device,
+				fieldHandler: tt.fields.fieldHandler,
+				valueHandler: tt.fields.valueHandler,
+				options:      tt.fields.options,
+				connected:    tt.fields.connected,
+			}
+			timeBeforeClose := time.Now()
+			closeChan := c.Close()
+			select {
+			case closeResult := <-closeChan:
+				timeAfterClose := time.Now()
+				// If an expected delay was defined, check if closing
+				// took at least this long.
+				if tt.delayAtLeast > 0 {
+					connectionTime := timeAfterClose.Sub(timeBeforeClose)
+					if connectionTime < tt.delayAtLeast {
+						t.Errorf("TestConnection.Close() connected too fast. Expected at least %v but connected after %v", tt.delayAtLeast, connectionTime)
+					}
+				}
+				// If we wanted an error, but didn't get one or the other way around.
+				if tt.wantErr != (closeResult.GetErr() != nil) {
+					t.Errorf("TestConnection.Close() hasErr= %v, wantErr %v", closeResult.GetErr() != nil, tt.wantErr)
+				} else if !tt.wantErr {
+					if !reflect.DeepEqual(closeResult, tt.want) {
+						t.Errorf("TestConnection.Close() = %v, want %v", closeResult, tt.want)
+					}
+				}
+			case <-time.After(3 * time.Second):
+				t.Errorf("TestConnection.Close() got timeout")
+			}
+		})
+	}
+}
+
+func TestConnection_BlockingClose(t *testing.T) {
+	type fields struct {
+		device       *Device
+		fieldHandler spi.PlcFieldHandler
+		valueHandler spi.PlcValueHandler
+		options      map[string][]string
+		connected    bool
+	}
+	tests := []struct {
+		name         string
+		fields       fields
+		delayAtLeast time.Duration
+	}{
+		{
+			name: "simple",
+			fields: fields{
+				device:       NewDevice("hurz"),
+				fieldHandler: NewFieldHandler(),
+				valueHandler: NewValueHandler(),
+				options:      map[string][]string{},
+				connected:    true,
+			},
+			delayAtLeast: 0,
+		},
+		{
+			name: "not connected",
+			fields: fields{
+				device:       NewDevice("hurz"),
+				fieldHandler: NewFieldHandler(),
+				valueHandler: NewValueHandler(),
+				options:      map[string][]string{},
+				connected:    false,
+			},
+			delayAtLeast: 0,
+		},
+		{
+			name: "delayed close",
+			fields: fields{
+				device:       NewDevice("hurz"),
+				fieldHandler: NewFieldHandler(),
+				valueHandler: NewValueHandler(),
+				options: map[string][]string{
+					"closingDelay": {"1000"},
+				},
+				connected: true,
+			},
+			delayAtLeast: 1000,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			c := &Connection{
+				device:       tt.fields.device,
+				fieldHandler: tt.fields.fieldHandler,
+				valueHandler: tt.fields.valueHandler,
+				options:      tt.fields.options,
+				connected:    tt.fields.connected,
+			}
+			timeBeforeClose := time.Now()
+			executor := func() <-chan bool {
+				ch := make(chan bool)
+				go func() {
+					c.BlockingClose()
+					ch <- true
+				}()
+				return ch
+			}
+			select {
+			case <-executor():
+				timeAfterClose := time.Now()
+				// If an expected delay was defined, check if closing
+				// took at least this long.
+				if tt.delayAtLeast > 0 {
+					connectionTime := timeAfterClose.Sub(timeBeforeClose)
+					if connectionTime < tt.delayAtLeast {
+						t.Errorf("TestConnection.Close() connected too fast. Expected at least %v but connected after %v", tt.delayAtLeast, connectionTime)
+					}
+				}
+			case <-time.After(3 * time.Second):
+				t.Errorf("TestConnection.Close() got timeout")
+			}
+		})
+	}
+}
+
+func TestConnection_GetMetadata(t *testing.T) {
+	type fields struct {
+		device       *Device
+		fieldHandler spi.PlcFieldHandler
+		valueHandler spi.PlcValueHandler
+		options      map[string][]string
+		connected    bool
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		want   model.PlcConnectionMetadata
+	}{
+		{
+			name:   "simple",
+			fields: fields{},
+			want: _default.DefaultConnectionMetadata{
+				ConnectionAttributes: map[string]string{
+					"connectionDelay": "Delay applied when connecting",
+					"closingDelay":    "Delay applied when closing the connection",
+					"pingDelay":       "Delay applied when executing a ping operation",
+					"readDelay":       "Delay applied when executing a read operation",
+					"writeDelay":      "Delay applied when executing a write operation",
+				},
+				ProvidesReading:     true,
+				ProvidesWriting:     true,
+				ProvidesSubscribing: false,
+				ProvidesBrowsing:    false,
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			c := &Connection{
+				device:       tt.fields.device,
+				fieldHandler: tt.fields.fieldHandler,
+				valueHandler: tt.fields.valueHandler,
+				options:      tt.fields.options,
+				connected:    tt.fields.connected,
+			}
+			if got := c.GetMetadata(); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("GetMetadata() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestConnection_IsConnected(t *testing.T) {
+	type fields struct {
+		device       *Device
+		fieldHandler spi.PlcFieldHandler
+		valueHandler spi.PlcValueHandler
+		options      map[string][]string
+		connected    bool
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		want   bool
+	}{
+		{
+			name: "simple",
+			fields: fields{
+				device:       NewDevice("hurz"),
+				fieldHandler: NewFieldHandler(),
+				valueHandler: NewValueHandler(),
+				options:      map[string][]string{},
+				connected:    true,
+			},
+			want: true,
+		},
+		{
+			name: "not connected",
+			fields: fields{
+				device:       NewDevice("hurz"),
+				fieldHandler: NewFieldHandler(),
+				valueHandler: NewValueHandler(),
+				options:      map[string][]string{},
+				connected:    false,
+			},
+			want: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			c := &Connection{
+				device:       tt.fields.device,
+				fieldHandler: tt.fields.fieldHandler,
+				valueHandler: tt.fields.valueHandler,
+				options:      tt.fields.options,
+				connected:    tt.fields.connected,
+			}
+			if got := c.IsConnected(); got != tt.want {
+				t.Errorf("IsConnected() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestConnection_Ping(t *testing.T) {
+	type fields struct {
+		device       *Device
+		fieldHandler spi.PlcFieldHandler
+		valueHandler spi.PlcValueHandler
+		options      map[string][]string
+		connected    bool
+	}
+	tests := []struct {
+		name         string
+		fields       fields
+		want         plc4go.PlcConnectionPingResult
+		delayAtLeast time.Duration
+	}{
+		{
+			name: "simple",
+			fields: fields{
+				device:       NewDevice("hurz"),
+				fieldHandler: NewFieldHandler(),
+				valueHandler: NewValueHandler(),
+				options:      map[string][]string{},
+				connected:    true,
+			},
+			want:         _default.NewDefaultPlcConnectionPingResult(nil),
+			delayAtLeast: 0,
+		},
+		{
+			name: "delayed ping",
+			fields: fields{
+				device:       NewDevice("hurz"),
+				fieldHandler: NewFieldHandler(),
+				valueHandler: NewValueHandler(),
+				options: map[string][]string{
+					"pingDelay": {"1000"},
+				},
+				connected: true,
+			},
+			want:         _default.NewDefaultPlcConnectionPingResult(nil),
+			delayAtLeast: 1000,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			c := &Connection{
+				device:       tt.fields.device,
+				fieldHandler: tt.fields.fieldHandler,
+				valueHandler: tt.fields.valueHandler,
+				options:      tt.fields.options,
+				connected:    tt.fields.connected,
+			}
+			timeBeforePing := time.Now()
+			pingChan := c.Ping()
+			select {
+			case pingResult := <-pingChan:
+				timeAfterPing := time.Now()
+				// If an expected delay was defined, check if closing
+				// took at least this long.
+				if tt.delayAtLeast > 0 {
+					pingTime := timeAfterPing.Sub(timeBeforePing)
+					if pingTime < tt.delayAtLeast {
+						t.Errorf("TestConnection.Ping() completed too fast. Expected at least %v but returned after %v", tt.delayAtLeast, pingTime)
+					}
+				}
+				if !reflect.DeepEqual(pingResult, tt.want) {
+					t.Errorf("TestConnection.Ping() = %v, want %v", pingResult, tt.want)
+				}
+			case <-time.After(3 * time.Second):
+				t.Errorf("TestConnection.Ping() got timeout")
+			}
+		})
+	}
+}
+
+func TestConnection_BrowseRequestBuilder(t *testing.T) {
+	type fields struct {
+		device       *Device
+		fieldHandler spi.PlcFieldHandler
+		valueHandler spi.PlcValueHandler
+		options      map[string][]string
+		connected    bool
+	}
+	tests := []struct {
+		name    string
+		fields  fields
+		wantErr bool
+	}{
+		{
+			name: "simple",
+			fields: fields{
+				device:       NewDevice("hurz"),
+				fieldHandler: NewFieldHandler(),
+				valueHandler: NewValueHandler(),
+				options:      map[string][]string{},
+				connected:    true,
+			},
+			wantErr: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			c := &Connection{
+				device:       tt.fields.device,
+				fieldHandler: tt.fields.fieldHandler,
+				valueHandler: tt.fields.valueHandler,
+				options:      tt.fields.options,
+				connected:    tt.fields.connected,
+			}
+			defer func() {
+				if r := recover(); tt.wantErr && r == nil {
+					t.Errorf("The code did not panic")
+				}
+			}()
+			c.BrowseRequestBuilder()
+		})
+	}
+}
+
+func TestConnection_ReadRequestBuilder(t *testing.T) {
+	type fields struct {
+		device       *Device
+		fieldHandler spi.PlcFieldHandler
+		valueHandler spi.PlcValueHandler
+		options      map[string][]string
+		connected    bool
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		want   model.PlcReadRequestBuilder
+	}{
+		{
+			name: "simple",
+			fields: fields{
+				device:       NewDevice("hurz"),
+				fieldHandler: NewFieldHandler(),
+				valueHandler: NewValueHandler(),
+				options:      map[string][]string{},
+				connected:    true,
+			},
+			want: internalModel.NewDefaultPlcReadRequestBuilder(NewFieldHandler(), NewReader(NewDevice("hurz"), map[string][]string{})),
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			c := &Connection{
+				device:       tt.fields.device,
+				fieldHandler: tt.fields.fieldHandler,
+				valueHandler: tt.fields.valueHandler,
+				options:      tt.fields.options,
+				connected:    tt.fields.connected,
+			}
+			if got := c.ReadRequestBuilder(); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("ReadRequestBuilder() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestConnection_SubscriptionRequestBuilder(t *testing.T) {
+	type fields struct {
+		device       *Device
+		fieldHandler spi.PlcFieldHandler
+		valueHandler spi.PlcValueHandler
+		options      map[string][]string
+		connected    bool
+	}
+	tests := []struct {
+		name    string
+		fields  fields
+		wantErr bool
+	}{
+		{
+			name: "simple",
+			fields: fields{
+				device:       NewDevice("hurz"),
+				fieldHandler: NewFieldHandler(),
+				valueHandler: NewValueHandler(),
+				options:      map[string][]string{},
+				connected:    true,
+			},
+			wantErr: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			c := &Connection{
+				device:       tt.fields.device,
+				fieldHandler: tt.fields.fieldHandler,
+				valueHandler: tt.fields.valueHandler,
+				options:      tt.fields.options,
+				connected:    tt.fields.connected,
+			}
+			defer func() {
+				if r := recover(); tt.wantErr && r == nil {
+					t.Errorf("The code did not panic")
+				}
+			}()
+			c.SubscriptionRequestBuilder()
+		})
+	}
+}
+
+func TestConnection_UnsubscriptionRequestBuilder(t *testing.T) {
+	type fields struct {
+		device       *Device
+		fieldHandler spi.PlcFieldHandler
+		valueHandler spi.PlcValueHandler
+		options      map[string][]string
+		connected    bool
+	}
+	tests := []struct {
+		name    string
+		fields  fields
+		wantErr bool
+	}{
+		{
+			name: "simple",
+			fields: fields{
+				device:       NewDevice("hurz"),
+				fieldHandler: NewFieldHandler(),
+				valueHandler: NewValueHandler(),
+				options:      map[string][]string{},
+				connected:    true,
+			},
+			wantErr: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			c := &Connection{
+				device:       tt.fields.device,
+				fieldHandler: tt.fields.fieldHandler,
+				valueHandler: tt.fields.valueHandler,
+				options:      tt.fields.options,
+				connected:    tt.fields.connected,
+			}
+			defer func() {
+				if r := recover(); tt.wantErr && r == nil {
+					t.Errorf("The code did not panic")
+				}
+			}()
+			c.UnsubscriptionRequestBuilder()
+		})
+	}
+}
+
+func TestConnection_WriteRequestBuilder(t *testing.T) {
+	type fields struct {
+		device       *Device
+		fieldHandler spi.PlcFieldHandler
+		valueHandler spi.PlcValueHandler
+		options      map[string][]string
+		connected    bool
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		want   model.PlcWriteRequestBuilder
+	}{
+		{
+			name: "simple",
+			fields: fields{
+				device:       NewDevice("hurz"),
+				fieldHandler: NewFieldHandler(),
+				valueHandler: NewValueHandler(),
+				options:      map[string][]string{},
+				connected:    true,
+			},
+			want: internalModel.NewDefaultPlcWriteRequestBuilder(NewFieldHandler(), NewValueHandler(), NewWriter(NewDevice("hurz"), map[string][]string{})),
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			c := &Connection{
+				device:       tt.fields.device,
+				fieldHandler: tt.fields.fieldHandler,
+				valueHandler: tt.fields.valueHandler,
+				options:      tt.fields.options,
+				connected:    tt.fields.connected,
+			}
+			if got := c.WriteRequestBuilder(); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("WriteRequestBuilder() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestNewConnection(t *testing.T) {
+	type args struct {
+		device       *Device
+		fieldHandler spi.PlcFieldHandler
+		valueHandler spi.PlcValueHandler
+		options      map[string][]string
+	}
+	tests := []struct {
+		name string
+		args args
+		want *Connection
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := NewConnection(tt.args.device, tt.args.fieldHandler, tt.args.valueHandler, tt.args.options); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("NewConnection() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
diff --git a/plc4go/internal/plc4go/simulated/Device.go b/plc4go/internal/plc4go/simulated/Device.go
new file mode 100644
index 0000000..53d5a30
--- /dev/null
+++ b/plc4go/internal/plc4go/simulated/Device.go
@@ -0,0 +1,76 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package simulated
+
+import (
+	"github.com/apache/plc4x/plc4go/internal/plc4go/simulated/readwrite/model"
+	"github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
+	"github.com/apache/plc4x/plc4go/pkg/plc4go/values"
+	"github.com/rs/zerolog/log"
+	"math/rand"
+)
+
+type Device struct {
+	Name  string
+	State map[SimulatedField]*values.PlcValue
+}
+
+func NewDevice(name string) *Device {
+	return &Device{
+		Name:  name,
+		State: make(map[SimulatedField]*values.PlcValue),
+	}
+}
+
+func (t *Device) Get(field SimulatedField) *values.PlcValue {
+	switch field.FieldType {
+	case FieldState:
+		return t.State[field]
+	case FieldRandom:
+		return t.getRandomValue(field)
+	}
+	return nil
+}
+
+func (t *Device) Set(field SimulatedField, value *values.PlcValue) {
+	switch field.FieldType {
+	case FieldState:
+		t.State[field] = value
+		break
+	case FieldRandom:
+		// TODO: Doesn't really make any sense to write a random
+		break
+	case FieldStdOut:
+		log.Debug().Msgf("TEST PLC STDOUT [%s]: %s", field.Name, (*value).GetString())
+		break
+	}
+}
+
+func (t *Device) getRandomValue(field SimulatedField) *values.PlcValue {
+	size := field.GetDataTypeSize().DataTypeSize()
+	data := make([]byte, uint16(size)*field.Quantity)
+	rand.Read(data)
+	readBuffer := utils.NewReadBufferByteBased(data)
+	plcValue, err := model.DataItemParse(readBuffer, field.DataTypeSize.String(), field.Quantity)
+	if err != nil {
+		panic("Unable to parse random bytes")
+	}
+	return &plcValue
+}
diff --git a/plc4go/internal/plc4go/simulated/Device_test.go b/plc4go/internal/plc4go/simulated/Device_test.go
new file mode 100644
index 0000000..870ece0
--- /dev/null
+++ b/plc4go/internal/plc4go/simulated/Device_test.go
@@ -0,0 +1,288 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package simulated
+
+import (
+	"github.com/apache/plc4x/plc4go/internal/plc4go/simulated/readwrite/model"
+	values2 "github.com/apache/plc4x/plc4go/internal/plc4go/spi/values"
+	"github.com/apache/plc4x/plc4go/pkg/plc4go/values"
+	"github.com/rs/zerolog/log"
+	"reflect"
+	"testing"
+)
+
+func TestDevice_Get(t1 *testing.T) {
+	type fields struct {
+		Name  string
+		State map[SimulatedField]*values.PlcValue
+	}
+	type args struct {
+		field        SimulatedField
+		verifyOutput bool
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		args   args
+		want   *values.PlcValue
+	}{
+		{
+			name: "simple state",
+			fields: fields{
+				Name: "hurz",
+				State: map[SimulatedField]*values.PlcValue{
+					NewSimulatedField(FieldState, "boolField", model.SimulatedDataTypeSizes_BOOL, 1): ToReference(values2.NewPlcBOOL(true)),
+				},
+			},
+			args: args{
+				field:        NewSimulatedField(FieldState, "boolField", model.SimulatedDataTypeSizes_BOOL, 1),
+				verifyOutput: true,
+			},
+			want: ToReference(values2.NewPlcBOOL(true)),
+		},
+		{
+			name: "simple random",
+			fields: fields{
+				Name:  "hurz",
+				State: map[SimulatedField]*values.PlcValue{},
+			},
+			args: args{
+				field:        NewSimulatedField(FieldRandom, "boolField", model.SimulatedDataTypeSizes_BOOL, 1),
+				verifyOutput: false,
+			},
+			want: ToReference(values2.NewPlcBOOL(true)),
+		},
+		{
+			name: "simple stdout",
+			fields: fields{
+				Name:  "hurz",
+				State: map[SimulatedField]*values.PlcValue{},
+			},
+			args: args{
+				field:        NewSimulatedField(FieldStdOut, "boolField", model.SimulatedDataTypeSizes_BOOL, 1),
+				verifyOutput: false,
+			},
+			want: nil,
+		},
+	}
+	for _, tt := range tests {
+		t1.Run(tt.name, func(t1 *testing.T) {
+			t := &Device{
+				Name:  tt.fields.Name,
+				State: tt.fields.State,
+			}
+			got := t.Get(tt.args.field)
+			if got != nil {
+				log.Debug().Msgf("Result: %v", *got)
+			} else {
+				log.Debug().Msg("Result: nil")
+			}
+			if tt.args.verifyOutput && !reflect.DeepEqual(got, tt.want) {
+				t1.Errorf("Get() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+/*
+ * When first playing around with random values I only got "false" values.
+ * So I added this test in order to verify I'm actually getting random values.
+ */
+func TestDevice_Random(t1 *testing.T) {
+	type fields struct {
+		Name  string
+		State map[SimulatedField]*values.PlcValue
+	}
+	type args struct {
+		field   SimulatedField
+		numRuns int
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		args   args
+		want   *values.PlcValue
+	}{
+		{
+			name: "simple random",
+			fields: fields{
+				Name:  "hurz",
+				State: map[SimulatedField]*values.PlcValue{},
+			},
+			args: args{
+				field:   NewSimulatedField(FieldRandom, "boolField", model.SimulatedDataTypeSizes_BOOL, 1),
+				numRuns: 1000,
+			},
+			want: ToReference(values2.NewPlcBOOL(true)),
+		},
+	}
+	for _, tt := range tests {
+		t1.Run(tt.name, func(t1 *testing.T) {
+			t := &Device{
+				Name:  tt.fields.Name,
+				State: tt.fields.State,
+			}
+			numTrue := 0
+			numFalse := 0
+			for i := 0; i < tt.args.numRuns; i++ {
+				got := t.Get(tt.args.field)
+				boolValue := (*got).GetBool()
+				if boolValue {
+					numTrue++
+				} else {
+					numFalse++
+				}
+			}
+			if numTrue == 0 || numFalse == 0 {
+				t1.Errorf("Random doesn't seem to work. In %d runs I got %d true and %d false values", tt.args.numRuns, numTrue, numFalse)
+			} else {
+				log.Info().Msgf("In %d runs I got %d true and %d false values", tt.args.numRuns, numTrue, numFalse)
+			}
+		})
+	}
+}
+
+func TestDevice_Set(t1 *testing.T) {
+	type fields struct {
+		Name  string
+		State map[SimulatedField]*values.PlcValue
+	}
+	type args struct {
+		field         SimulatedField
+		value         *values.PlcValue
+		shouldBeSaved bool
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		args   args
+	}{
+		{
+			name: "simple state",
+			fields: fields{
+				Name:  "hurz",
+				State: map[SimulatedField]*values.PlcValue{},
+			},
+			args: args{
+				field:         NewSimulatedField(FieldState, "boolField", model.SimulatedDataTypeSizes_BOOL, 1),
+				value:         ToReference(values2.NewPlcBOOL(true)),
+				shouldBeSaved: true,
+			},
+		},
+		{
+			name: "simple random",
+			fields: fields{
+				Name:  "hurz",
+				State: map[SimulatedField]*values.PlcValue{},
+			},
+			args: args{
+				field:         NewSimulatedField(FieldRandom, "boolField", model.SimulatedDataTypeSizes_BOOL, 1),
+				value:         ToReference(values2.NewPlcBOOL(true)),
+				shouldBeSaved: false,
+			},
+		},
+		{
+			name: "simple stdout",
+			fields: fields{
+				Name:  "hurz",
+				State: map[SimulatedField]*values.PlcValue{},
+			},
+			args: args{
+				field:         NewSimulatedField(FieldStdOut, "boolField", model.SimulatedDataTypeSizes_BOOL, 1),
+				value:         ToReference(values2.NewPlcBOOL(true)),
+				shouldBeSaved: false,
+			},
+		},
+	}
+	for _, tt := range tests {
+		t1.Run(tt.name, func(t1 *testing.T) {
+			t := &Device{
+				Name:  tt.fields.Name,
+				State: tt.fields.State,
+			}
+			// It shouldn't exist in the map before
+			if _, ok := tt.fields.State[tt.args.field]; ok {
+				t1.Errorf("Value for %v already present in map", tt.args.field)
+			}
+			t.Set(tt.args.field, tt.args.value)
+			// It should exist in the map after
+			if _, ok := tt.fields.State[tt.args.field]; tt.args.shouldBeSaved != ok {
+				if tt.args.shouldBeSaved {
+					t1.Errorf("Value for %v not present in map (it should)", tt.args.field)
+				} else {
+					t1.Errorf("Value for %v present in map (is should not)", tt.args.field)
+				}
+			}
+		})
+	}
+}
+
+func TestDevice_getRandomValue(t1 *testing.T) {
+	type fields struct {
+		Name  string
+		State map[SimulatedField]*values.PlcValue
+	}
+	type args struct {
+		field SimulatedField
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		args   args
+		want   *values.PlcValue
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t1.Run(tt.name, func(t1 *testing.T) {
+			t := &Device{
+				Name:  tt.fields.Name,
+				State: tt.fields.State,
+			}
+			if got := t.getRandomValue(tt.args.field); !reflect.DeepEqual(got, tt.want) {
+				t1.Errorf("getRandomValue() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestNewDevice(t *testing.T) {
+	type args struct {
+		name string
+	}
+	tests := []struct {
+		name string
+		args args
+		want *Device
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := NewDevice(tt.args.name); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("NewDevice() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func ToReference(value values.PlcValue) *values.PlcValue {
+	return &value
+}
diff --git a/plc4go/internal/plc4go/simulated/Driver.go b/plc4go/internal/plc4go/simulated/Driver.go
new file mode 100644
index 0000000..80cf225
--- /dev/null
+++ b/plc4go/internal/plc4go/simulated/Driver.go
@@ -0,0 +1,79 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package simulated
+
+import (
+	"github.com/apache/plc4x/plc4go/internal/plc4go/spi/options"
+	"github.com/apache/plc4x/plc4go/internal/plc4go/spi/transports"
+	"github.com/apache/plc4x/plc4go/pkg/plc4go"
+	"github.com/apache/plc4x/plc4go/pkg/plc4go/model"
+	"github.com/pkg/errors"
+	"net/url"
+)
+
+type Driver struct {
+	fieldHandler FieldHandler
+	valueHandler ValueHandler
+}
+
+func NewDriver() plc4go.PlcDriver {
+	return &Driver{
+		fieldHandler: NewFieldHandler(),
+		valueHandler: NewValueHandler(),
+	}
+}
+
+// GetProtocolCode Get the short code used to identify this driver (As used in the connection string)
+func (d *Driver) GetProtocolCode() string {
+	return "simulated"
+}
+
+// GetProtocolName Get a human-readable name for this driver
+func (d *Driver) GetProtocolName() string {
+	return "Simulated PLC4X Datasource"
+}
+
+// GetDefaultTransport If the driver has a default form of transport, provide this and make
+// providing the transport code optional in the connection string
+func (d *Driver) GetDefaultTransport() string {
+	return "none"
+}
+
+// CheckQuery Have the driver parse the query string and provide feedback if it's not a valid one
+func (d *Driver) CheckQuery(query string) error {
+	_, err := d.fieldHandler.ParseQuery(query)
+	return err
+}
+
+// GetConnection Establishes a connection to a given PLC using the information in the connectionString
+func (d *Driver) GetConnection(_ url.URL, _ map[string]transports.Transport, options map[string][]string) <-chan plc4go.PlcConnectionConnectResult {
+	connection := NewConnection(NewDevice("test"), d.fieldHandler, d.valueHandler, options)
+	return connection.Connect()
+}
+
+// SupportsDiscovery returns true if this driver supports discovery
+// TODO: Actually the connection could support discovery to list up all fields in the Device
+func (d *Driver) SupportsDiscovery() bool {
+	return false
+}
+
+func (d *Driver) Discover(_ func(event model.PlcDiscoveryEvent), _ ...options.WithDiscoveryOption) error {
+	return errors.New("unsupported operation")
+}
diff --git a/plc4go/internal/plc4go/simulated/Driver_test.go b/plc4go/internal/plc4go/simulated/Driver_test.go
new file mode 100644
index 0000000..ac92235
--- /dev/null
+++ b/plc4go/internal/plc4go/simulated/Driver_test.go
@@ -0,0 +1,326 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package simulated
+
+import (
+	"github.com/apache/plc4x/plc4go/internal/plc4go/spi/options"
+	"github.com/apache/plc4x/plc4go/internal/plc4go/spi/transports"
+	"github.com/apache/plc4x/plc4go/pkg/plc4go/model"
+	"net/url"
+	"testing"
+	"time"
+)
+
+func TestDriver_CheckQuery(t *testing.T) {
+	type fields struct {
+		fieldHandler FieldHandler
+		valueHandler ValueHandler
+	}
+	type args struct {
+		query string
+	}
+	tests := []struct {
+		name    string
+		fields  fields
+		args    args
+		wantErr bool
+	}{
+		{
+			name: "valid query",
+			fields: fields{
+				fieldHandler: NewFieldHandler(),
+				valueHandler: NewValueHandler(),
+			},
+			args: args{
+				query: "STATE/test:UINT[2]",
+			},
+			wantErr: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			d := &Driver{
+				fieldHandler: tt.fields.fieldHandler,
+				valueHandler: tt.fields.valueHandler,
+			}
+			if err := d.CheckQuery(tt.args.query); (err != nil) != tt.wantErr {
+				t.Errorf("CheckQuery() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestDriver_Discover(t *testing.T) {
+	type fields struct {
+		fieldHandler FieldHandler
+		valueHandler ValueHandler
+	}
+	type args struct {
+		callback         func(event model.PlcDiscoveryEvent)
+		discoveryOptions []options.WithDiscoveryOption
+	}
+	tests := []struct {
+		name    string
+		fields  fields
+		args    args
+		wantErr bool
+	}{
+		{
+			name: "discovery fails",
+			fields: fields{
+				fieldHandler: NewFieldHandler(),
+				valueHandler: NewValueHandler(),
+			},
+			args: args{
+				// Can all be nil, as the call is expected to fail
+				callback:         nil,
+				discoveryOptions: nil,
+			},
+			wantErr: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			d := &Driver{
+				fieldHandler: tt.fields.fieldHandler,
+				valueHandler: tt.fields.valueHandler,
+			}
+			if err := d.Discover(tt.args.callback, tt.args.discoveryOptions...); (err != nil) != tt.wantErr {
+				t.Errorf("Discover() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestDriver_GetConnection(t *testing.T) {
+	type fields struct {
+		fieldHandler FieldHandler
+		valueHandler ValueHandler
+	}
+	type args struct {
+		in0     url.URL
+		in1     map[string]transports.Transport
+		options map[string][]string
+	}
+	tests := []struct {
+		name    string
+		fields  fields
+		args    args
+		wantErr bool
+	}{
+		{
+			name: "simple no options",
+			fields: fields{
+				fieldHandler: NewFieldHandler(),
+				valueHandler: NewValueHandler(),
+			},
+			// Input doesn't really matter, as the code simply ignores most of it.
+			args: args{
+				in0:     url.URL{},
+				in1:     nil,
+				options: nil,
+			},
+			wantErr: false,
+		},
+		{
+			name: "simple with options",
+			fields: fields{
+				fieldHandler: NewFieldHandler(),
+				valueHandler: NewValueHandler(),
+			},
+			// Input doesn't really matter, as the code simply ignores most of it.
+			args: args{
+				in0: url.URL{},
+				in1: nil,
+				options: map[string][]string{
+					"testOption": {"testValue"},
+				},
+			},
+			wantErr: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			d := &Driver{
+				fieldHandler: tt.fields.fieldHandler,
+				valueHandler: tt.fields.valueHandler,
+			}
+			connectionChan := d.GetConnection(tt.args.in0, tt.args.in1, tt.args.options)
+			select {
+			case connectResult := <-connectionChan:
+				if tt.wantErr && (connectResult.GetErr() == nil) {
+					t.Errorf("PlcConnectionPool.GetConnection() = %v, wantErr %v", connectResult.GetErr(), tt.wantErr)
+				} else if connectResult.GetErr() != nil {
+					t.Errorf("PlcConnectionPool.GetConnection() error = %v, wantErr %v", connectResult.GetErr(), tt.wantErr)
+				}
+			case <-time.After(3 * time.Second):
+				t.Errorf("PlcConnectionPool.GetConnection() got timeout")
+			}
+		})
+	}
+}
+
+func TestDriver_GetDefaultTransport(t *testing.T) {
+	type fields struct {
+		fieldHandler FieldHandler
+		valueHandler ValueHandler
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		want   string
+	}{
+		{
+			name: "simple",
+			fields: fields{
+				fieldHandler: NewFieldHandler(),
+				valueHandler: NewValueHandler(),
+			},
+			want: "none",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			d := &Driver{
+				fieldHandler: tt.fields.fieldHandler,
+				valueHandler: tt.fields.valueHandler,
+			}
+			if got := d.GetDefaultTransport(); got != tt.want {
+				t.Errorf("GetDefaultTransport() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestDriver_GetProtocolCode(t *testing.T) {
+	type fields struct {
+		fieldHandler FieldHandler
+		valueHandler ValueHandler
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		want   string
+	}{
+		{
+			name: "simple",
+			fields: fields{
+				fieldHandler: NewFieldHandler(),
+				valueHandler: NewValueHandler(),
+			},
+			want: "simulated",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			d := &Driver{
+				fieldHandler: tt.fields.fieldHandler,
+				valueHandler: tt.fields.valueHandler,
+			}
+			if got := d.GetProtocolCode(); got != tt.want {
+				t.Errorf("GetProtocolCode() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestDriver_GetProtocolName(t *testing.T) {
+	type fields struct {
+		fieldHandler FieldHandler
+		valueHandler ValueHandler
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		want   string
+	}{
+		{
+			name: "simple",
+			fields: fields{
+				fieldHandler: NewFieldHandler(),
+				valueHandler: NewValueHandler(),
+			},
+			want: "Simulated PLC4X Datasource",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			d := &Driver{
+				fieldHandler: tt.fields.fieldHandler,
+				valueHandler: tt.fields.valueHandler,
+			}
+			if got := d.GetProtocolName(); got != tt.want {
+				t.Errorf("GetProtocolName() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestDriver_SupportsDiscovery(t *testing.T) {
+	type fields struct {
+		fieldHandler FieldHandler
+		valueHandler ValueHandler
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		want   bool
+	}{
+		{
+			name: "simple",
+			fields: fields{
+				fieldHandler: NewFieldHandler(),
+				valueHandler: NewValueHandler(),
+			},
+			want: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			d := &Driver{
+				fieldHandler: tt.fields.fieldHandler,
+				valueHandler: tt.fields.valueHandler,
+			}
+			if got := d.SupportsDiscovery(); got != tt.want {
+				t.Errorf("SupportsDiscovery() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestNewDriver(t *testing.T) {
+	tests := []struct {
+		name    string
+		wantErr bool
+	}{
+		{
+			name:    "simple",
+			wantErr: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := NewDriver()
+			if got == nil && !tt.wantErr {
+				t.Errorf("NewDriver() error creating")
+			}
+		})
+	}
+}
diff --git a/plc4go/internal/plc4go/simulated/Field.go b/plc4go/internal/plc4go/simulated/Field.go
new file mode 100644
index 0000000..133da1c
--- /dev/null
+++ b/plc4go/internal/plc4go/simulated/Field.go
@@ -0,0 +1,71 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package simulated
+
+import (
+	"fmt"
+	"github.com/apache/plc4x/plc4go/internal/plc4go/simulated/readwrite/model"
+)
+
+type Field interface {
+	GetFieldType() *FieldType
+	GetName() string
+	GetDataTypeSize() *model.SimulatedDataTypeSizes
+}
+
+type SimulatedField struct {
+	FieldType    FieldType
+	Name         string
+	DataTypeSize model.SimulatedDataTypeSizes
+	Quantity     uint16
+}
+
+func NewSimulatedField(fieldType FieldType, name string, dataTypeSize model.SimulatedDataTypeSizes, quantity uint16) SimulatedField {
+	return SimulatedField{
+		FieldType:    fieldType,
+		Name:         name,
+		DataTypeSize: dataTypeSize,
+		Quantity:     quantity,
+	}
+}
+
+func (t SimulatedField) GetFieldType() FieldType {
+	return t.FieldType
+}
+
+func (t SimulatedField) GetName() string {
+	return t.Name
+}
+
+func (t SimulatedField) GetDataTypeSize() model.SimulatedDataTypeSizes {
+	return t.DataTypeSize
+}
+
+func (t SimulatedField) GetAddressString() string {
+	return fmt.Sprintf("%s/%s:%s[%d]", t.FieldType.Name(), t.Name, t.DataTypeSize.String(), t.Quantity)
+}
+
+func (t SimulatedField) GetTypeName() string {
+	return t.DataTypeSize.String()
+}
+
+func (t SimulatedField) GetQuantity() uint16 {
+	return t.Quantity
+}
diff --git a/plc4go/internal/plc4go/simulated/FieldHandler.go b/plc4go/internal/plc4go/simulated/FieldHandler.go
new file mode 100644
index 0000000..de0bfd3
--- /dev/null
+++ b/plc4go/internal/plc4go/simulated/FieldHandler.go
@@ -0,0 +1,103 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package simulated
+
+import (
+	"errors"
+	"github.com/apache/plc4x/plc4go/internal/plc4go/simulated/readwrite/model"
+	"github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
+	apiModel "github.com/apache/plc4x/plc4go/pkg/plc4go/model"
+	"regexp"
+	"strconv"
+)
+
+type FieldType uint8
+
+const (
+	FieldRandom FieldType = iota
+	FieldState
+	FieldStdOut
+)
+
+func (e FieldType) Name() string {
+	switch e {
+	case FieldRandom:
+		return "RANDOM"
+	case FieldState:
+		return "STATE"
+	case FieldStdOut:
+		return "STDOUT"
+	default:
+		return "UNKNOWN"
+	}
+}
+
+type FieldHandler struct {
+	simulatedQuery *regexp.Regexp
+}
+
+func NewFieldHandler() FieldHandler {
+	return FieldHandler{
+		simulatedQuery: regexp.MustCompile(`^(?P<type>\w+)/(?P<name>[a-zA-Z0-9_\\.]+):(?P<dataType>[a-zA-Z0-9]+)(\[(?P<numElements>\d+)])?$`),
+	}
+}
+
+func (m FieldHandler) ParseQuery(query string) (apiModel.PlcField, error) {
+	if match := utils.GetSubgroupMatches(m.simulatedQuery, query); match != nil {
+		fieldTypeName, ok := match["type"]
+		var fieldType FieldType
+		if ok {
+			switch fieldTypeName {
+			case "RANDOM":
+				fieldType = FieldRandom
+				break
+			case "STATE":
+				fieldType = FieldState
+				break
+			case "STDOUT":
+				fieldType = FieldStdOut
+			default:
+				return nil, errors.New("unknown field type '" + fieldTypeName + "'")
+			}
+		}
+		fieldName, ok := match["name"]
+		fieldDataTypeName, ok := match["dataType"]
+		var fieldDataType model.SimulatedDataTypeSizes
+		if ok {
+			fieldDataType = model.SimulatedDataTypeSizesByName(fieldDataTypeName)
+			if fieldDataType == 0 {
+				return nil, errors.New("unknown field data-type '" + fieldDataTypeName + "'")
+			}
+		}
+		fieldNumElementsText, ok := match["numElements"]
+		var fieldNumElements uint16
+		if ok && len(fieldNumElementsText) > 0 {
+			num, err := strconv.Atoi(fieldNumElementsText)
+			if err != nil {
+				return nil, errors.New("invalid size '" + fieldNumElementsText + "'")
+			}
+			fieldNumElements = uint16(num)
+		} else {
+			fieldNumElements = 1
+		}
+		return NewSimulatedField(fieldType, fieldName, fieldDataType, fieldNumElements), nil
+	}
+	return nil, errors.New("Invalid address format for address '" + query + "'")
+}
diff --git a/plc4go/internal/plc4go/simulated/FieldHandler_test.go b/plc4go/internal/plc4go/simulated/FieldHandler_test.go
new file mode 100644
index 0000000..281147a
--- /dev/null
+++ b/plc4go/internal/plc4go/simulated/FieldHandler_test.go
@@ -0,0 +1,169 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package simulated
+
+import (
+	model2 "github.com/apache/plc4x/plc4go/internal/plc4go/simulated/readwrite/model"
+	"github.com/apache/plc4x/plc4go/pkg/plc4go/model"
+	"reflect"
+	"testing"
+)
+
+func TestFieldHandler_ParseQuery(t *testing.T) {
+	type args struct {
+		query string
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    model.PlcField
+		wantErr bool
+	}{
+		{
+			name: "simple random",
+			args: args{
+				query: "RANDOM/test_random:BOOL",
+			},
+			want:    NewSimulatedField(FieldRandom, "test_random", model2.SimulatedDataTypeSizes_BOOL, 1),
+			wantErr: false,
+		},
+		{
+			name: "simple random array",
+			args: args{
+				query: "RANDOM/test_random:BOOL[10]",
+			},
+			want:    NewSimulatedField(FieldRandom, "test_random", model2.SimulatedDataTypeSizes_BOOL, 10),
+			wantErr: false,
+		},
+		{
+			name: "simple state",
+			args: args{
+				query: "STATE/test_state:BOOL",
+			},
+			want:    NewSimulatedField(FieldState, "test_state", model2.SimulatedDataTypeSizes_BOOL, 1),
+			wantErr: false,
+		},
+		{
+			name: "simple state array",
+			args: args{
+				query: "STATE/test_state:BOOL[42]",
+			},
+			want:    NewSimulatedField(FieldState, "test_state", model2.SimulatedDataTypeSizes_BOOL, 42),
+			wantErr: false,
+		},
+		{
+			name: "simple stdout",
+			args: args{
+				query: "STDOUT/test_stdout:BOOL",
+			},
+			want:    NewSimulatedField(FieldStdOut, "test_stdout", model2.SimulatedDataTypeSizes_BOOL, 1),
+			wantErr: false,
+		},
+		{
+			name: "simple stdout array",
+			args: args{
+				query: "STDOUT/test_stdout:BOOL[23]",
+			},
+			want:    NewSimulatedField(FieldStdOut, "test_stdout", model2.SimulatedDataTypeSizes_BOOL, 23),
+			wantErr: false,
+		},
+		{
+			name: "error invalid type",
+			args: args{
+				query: "HURZ/test_stdout:BOOL[23]",
+			},
+			want:    nil,
+			wantErr: true,
+		},
+		{
+			name: "error invalid name format",
+			args: args{
+				query: "RANDOM/test/stdout:BOOL[23]",
+			},
+			want:    nil,
+			wantErr: true,
+		},
+		{
+			name: "error invalid datatype",
+			args: args{
+				query: "RANDOM/test_stdout:HURZ[23]",
+			},
+			want:    nil,
+			wantErr: true,
+		},
+		{
+			name: "error invalid array size",
+			args: args{
+				query: "RANDOM/test_stdout:BOOL[999999999999999999999999999999999999]",
+			},
+			want:    nil,
+			wantErr: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			m := NewFieldHandler()
+			got, err := m.ParseQuery(tt.args.query)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("ParseQuery() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("ParseQuery() got = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestFieldType_Name(t *testing.T) {
+	tests := []struct {
+		name string
+		e    FieldType
+		want string
+	}{
+		{
+			name: "simple random",
+			e:    FieldRandom,
+			want: "RANDOM",
+		},
+		{
+			name: "simple state",
+			e:    FieldState,
+			want: "STATE",
+		},
+		{
+			name: "simple stdout",
+			e:    FieldStdOut,
+			want: "STDOUT",
+		},
+		{
+			name: "simple stdout",
+			e:    10,
+			want: "UNKNOWN",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := tt.e.Name(); got != tt.want {
+				t.Errorf("Name() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
diff --git a/plc4go/internal/plc4go/simulated/Field_test.go b/plc4go/internal/plc4go/simulated/Field_test.go
new file mode 100644
index 0000000..c4a961a
--- /dev/null
+++ b/plc4go/internal/plc4go/simulated/Field_test.go
@@ -0,0 +1,291 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package simulated
+
+import (
+	"github.com/apache/plc4x/plc4go/internal/plc4go/simulated/readwrite/model"
+	"reflect"
+	"testing"
+)
+
+func TestNewSimulatedField(t *testing.T) {
+	type args struct {
+		fieldType    FieldType
+		name         string
+		dataTypeSize model.SimulatedDataTypeSizes
+		quantity     uint16
+	}
+	tests := []struct {
+		name string
+		args args
+		want SimulatedField
+	}{
+		{
+			name: "simple",
+			args: args{
+				fieldType:    FieldRandom,
+				name:         "test",
+				dataTypeSize: model.SimulatedDataTypeSizes_BOOL,
+				quantity:     1,
+			},
+			want: SimulatedField{
+				FieldType:    FieldRandom,
+				Name:         "test",
+				DataTypeSize: model.SimulatedDataTypeSizes_BOOL,
+				Quantity:     1,
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := NewSimulatedField(tt.args.fieldType, tt.args.name, tt.args.dataTypeSize, tt.args.quantity); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("NewSimulatedField() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestSimulatedField_GetAddressString(t1 *testing.T) {
+	type fields struct {
+		FieldType    FieldType
+		Name         string
+		DataTypeSize model.SimulatedDataTypeSizes
+		Quantity     uint16
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		want   string
+	}{
+		{
+			name: "simple",
+			fields: fields{
+				FieldType:    FieldRandom,
+				Name:         "test",
+				DataTypeSize: model.SimulatedDataTypeSizes_BOOL,
+				Quantity:     1,
+			},
+			want: "RANDOM/test:BOOL[1]",
+		},
+	}
+	for _, tt := range tests {
+		t1.Run(tt.name, func(t1 *testing.T) {
+			t := SimulatedField{
+				FieldType:    tt.fields.FieldType,
+				Name:         tt.fields.Name,
+				DataTypeSize: tt.fields.DataTypeSize,
+				Quantity:     tt.fields.Quantity,
+			}
+			if got := t.GetAddressString(); got != tt.want {
+				t1.Errorf("GetAddressString() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestSimulatedField_GetDataTypeSize(t1 *testing.T) {
+	type fields struct {
+		FieldType    FieldType
+		Name         string
+		DataTypeSize model.SimulatedDataTypeSizes
+		Quantity     uint16
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		want   model.SimulatedDataTypeSizes
+	}{
+		{
+			name: "simple",
+			fields: fields{
+				FieldType:    FieldRandom,
+				Name:         "test",
+				DataTypeSize: model.SimulatedDataTypeSizes_BOOL,
+				Quantity:     1,
+			},
+			want: model.SimulatedDataTypeSizes_BOOL,
+		},
+	}
+	for _, tt := range tests {
+		t1.Run(tt.name, func(t1 *testing.T) {
+			t := SimulatedField{
+				FieldType:    tt.fields.FieldType,
+				Name:         tt.fields.Name,
+				DataTypeSize: tt.fields.DataTypeSize,
+				Quantity:     tt.fields.Quantity,
+			}
+			if got := t.GetDataTypeSize(); got != tt.want {
+				t1.Errorf("GetDataTypeSize() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestSimulatedField_GetFieldType(t1 *testing.T) {
+	type fields struct {
+		FieldType    FieldType
+		Name         string
+		DataTypeSize model.SimulatedDataTypeSizes
+		Quantity     uint16
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		want   FieldType
+	}{
+		{
+			name: "simple",
+			fields: fields{
+				FieldType:    FieldRandom,
+				Name:         "test",
+				DataTypeSize: model.SimulatedDataTypeSizes_BOOL,
+				Quantity:     1,
+			},
+			want: FieldRandom,
+		},
+	}
+	for _, tt := range tests {
+		t1.Run(tt.name, func(t1 *testing.T) {
+			t := SimulatedField{
+				FieldType:    tt.fields.FieldType,
+				Name:         tt.fields.Name,
+				DataTypeSize: tt.fields.DataTypeSize,
+				Quantity:     tt.fields.Quantity,
+			}
+			if got := t.GetFieldType(); got != tt.want {
+				t1.Errorf("GetFieldType() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestSimulatedField_GetName(t1 *testing.T) {
+	type fields struct {
+		FieldType    FieldType
+		Name         string
+		DataTypeSize model.SimulatedDataTypeSizes
+		Quantity     uint16
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		want   string
+	}{
+		{
+			name: "simple",
+			fields: fields{
+				FieldType:    FieldRandom,
+				Name:         "test",
+				DataTypeSize: model.SimulatedDataTypeSizes_BOOL,
+				Quantity:     1,
+			},
+			want: "test",
+		},
+	}
+	for _, tt := range tests {
+		t1.Run(tt.name, func(t1 *testing.T) {
+			t := SimulatedField{
+				FieldType:    tt.fields.FieldType,
+				Name:         tt.fields.Name,
+				DataTypeSize: tt.fields.DataTypeSize,
+				Quantity:     tt.fields.Quantity,
+			}
+			if got := t.GetName(); got != tt.want {
+				t1.Errorf("GetName() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestSimulatedField_GetQuantity(t1 *testing.T) {
+	type fields struct {
+		FieldType    FieldType
+		Name         string
+		DataTypeSize model.SimulatedDataTypeSizes
+		Quantity     uint16
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		want   uint16
+	}{
+		{
+			name: "simple",
+			fields: fields{
+				FieldType:    FieldRandom,
+				Name:         "test",
+				DataTypeSize: model.SimulatedDataTypeSizes_BOOL,
+				Quantity:     1,
+			},
+			want: 1,
+		},
+	}
+	for _, tt := range tests {
+		t1.Run(tt.name, func(t1 *testing.T) {
+			t := SimulatedField{
+				FieldType:    tt.fields.FieldType,
+				Name:         tt.fields.Name,
+				DataTypeSize: tt.fields.DataTypeSize,
+				Quantity:     tt.fields.Quantity,
+			}
+			if got := t.GetQuantity(); got != tt.want {
+				t1.Errorf("GetQuantity() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestSimulatedField_GetTypeName(t1 *testing.T) {
+	type fields struct {
+		FieldType    FieldType
+		Name         string
+		DataTypeSize model.SimulatedDataTypeSizes
+		Quantity     uint16
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		want   string
+	}{
+		{
+			name: "simple",
+			fields: fields{
+				FieldType:    FieldRandom,
+				Name:         "test",
+				DataTypeSize: model.SimulatedDataTypeSizes_BOOL,
+				Quantity:     1,
+			},
+			want: "BOOL",
+		},
+	}
+	for _, tt := range tests {
+		t1.Run(tt.name, func(t1 *testing.T) {
+			t := SimulatedField{
+				FieldType:    tt.fields.FieldType,
+				Name:         tt.fields.Name,
+				DataTypeSize: tt.fields.DataTypeSize,
+				Quantity:     tt.fields.Quantity,
+			}
+			if got := t.GetTypeName(); got != tt.want {
+				t1.Errorf("GetTypeName() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
diff --git a/plc4go/internal/plc4go/simulated/Reader.go b/plc4go/internal/plc4go/simulated/Reader.go
new file mode 100644
index 0000000..48d7ab0
--- /dev/null
+++ b/plc4go/internal/plc4go/simulated/Reader.go
@@ -0,0 +1,84 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package simulated
+
+import (
+	model2 "github.com/apache/plc4x/plc4go/internal/plc4go/spi/model"
+	"github.com/apache/plc4x/plc4go/pkg/plc4go/model"
+	"github.com/apache/plc4x/plc4go/pkg/plc4go/values"
+	"strconv"
+	"time"
+)
+
+type Reader struct {
+	device  *Device
+	options map[string][]string
+}
+
+func NewReader(device *Device, options map[string][]string) Reader {
+	return Reader{
+		device:  device,
+		options: options,
+	}
+}
+
+func (r Reader) Read(readRequest model.PlcReadRequest) <-chan model.PlcReadRequestResult {
+	ch := make(chan model.PlcReadRequestResult)
+	go func() {
+		// Possibly add a delay.
+		if delayString, ok := r.options["readDelay"]; ok {
+			if len(delayString) == 1 {
+				delay, err := strconv.Atoi(delayString[0])
+				if err == nil {
+					time.Sleep(time.Duration(delay) * time.Millisecond)
+				}
+			}
+		}
+
+		// Process the request
+		responseCodes := make(map[string]model.PlcResponseCode)
+		responseValues := make(map[string]values.PlcValue)
+		for _, fieldName := range readRequest.GetFieldNames() {
+			field := readRequest.GetField(fieldName)
+			simulatedField, ok := field.(SimulatedField)
+			if !ok {
+				responseCodes[fieldName] = model.PlcResponseCode_INVALID_ADDRESS
+				responseValues[fieldName] = nil
+			} else {
+				value := r.device.Get(simulatedField)
+				if value == nil {
+					responseCodes[fieldName] = model.PlcResponseCode_NOT_FOUND
+					responseValues[fieldName] = nil
+				} else {
+					responseCodes[fieldName] = model.PlcResponseCode_OK
+					responseValues[fieldName] = *value
+				}
+			}
+		}
+
+		// Emit the response
+		ch <- &model2.DefaultPlcReadRequestResult{
+			Request:  readRequest,
+			Response: model2.NewDefaultPlcReadResponse(readRequest, responseCodes, responseValues),
+			Err:      nil,
+		}
+	}()
+	return ch
+}
diff --git a/plc4go/internal/plc4go/simulated/Reader_test.go b/plc4go/internal/plc4go/simulated/Reader_test.go
new file mode 100644
index 0000000..1a84e63
--- /dev/null
+++ b/plc4go/internal/plc4go/simulated/Reader_test.go
@@ -0,0 +1,202 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package simulated
+
+import (
+	"github.com/apache/plc4x/plc4go/internal/plc4go/s7"
+	model4 "github.com/apache/plc4x/plc4go/internal/plc4go/s7/readwrite/model"
+	model2 "github.com/apache/plc4x/plc4go/internal/plc4go/simulated/readwrite/model"
+	model3 "github.com/apache/plc4x/plc4go/internal/plc4go/spi/model"
+	values2 "github.com/apache/plc4x/plc4go/internal/plc4go/spi/values"
+	"github.com/apache/plc4x/plc4go/pkg/plc4go/model"
+	"github.com/apache/plc4x/plc4go/pkg/plc4go/values"
+	"reflect"
+	"testing"
+	"time"
+)
+
+func TestReader_Read(t *testing.T) {
+	type fields struct {
+		device  *Device
+		options map[string][]string
+	}
+	type args struct {
+		fields     map[string]model.PlcField
+		fieldNames []string
+	}
+	tests := []struct {
+		name         string
+		fields       fields
+		args         args
+		want         model.PlcReadResponse
+		delayAtLeast time.Duration
+	}{
+		{
+			name: "simple state",
+			fields: fields{
+				device: &Device{
+					Name: "hurz",
+					State: map[SimulatedField]*values.PlcValue{
+						NewSimulatedField(FieldState, "test", model2.SimulatedDataTypeSizes_BOOL, 1): ToReference(values2.NewPlcBOOL(true)),
+					},
+				},
+				options: map[string][]string{},
+			},
+			args: args{
+				fields: map[string]model.PlcField{
+					"test": NewSimulatedField(FieldState, "test", model2.SimulatedDataTypeSizes_BOOL, 1),
+				},
+				fieldNames: []string{"test"},
+			},
+			want: model3.NewDefaultPlcReadResponse(nil,
+				map[string]model.PlcResponseCode{
+					"test": model.PlcResponseCode_OK,
+				},
+				map[string]values.PlcValue{
+					"test": values2.NewPlcBOOL(true),
+				}),
+			delayAtLeast: 0,
+		},
+		{
+			name: "simple state delayed",
+			fields: fields{
+				device: &Device{
+					Name: "hurz",
+					State: map[SimulatedField]*values.PlcValue{
+						NewSimulatedField(FieldState, "test", model2.SimulatedDataTypeSizes_BOOL, 1): ToReference(values2.NewPlcBOOL(true)),
+					},
+				},
+				options: map[string][]string{
+					"readDelay": {"1000"},
+				},
+			},
+			args: args{
+				fields: map[string]model.PlcField{
+					"test": NewSimulatedField(FieldState, "test", model2.SimulatedDataTypeSizes_BOOL, 1),
+				},
+				fieldNames: []string{"test"},
+			},
+			want: model3.NewDefaultPlcReadResponse(nil,
+				map[string]model.PlcResponseCode{
+					"test": model.PlcResponseCode_OK,
+				},
+				map[string]values.PlcValue{
+					"test": values2.NewPlcBOOL(true),
+				}),
+			delayAtLeast: 1000,
+		},
+		{
+			name: "state not found",
+			fields: fields{
+				device: &Device{
+					Name: "hurz",
+					State: map[SimulatedField]*values.PlcValue{
+						NewSimulatedField(FieldState, "test", model2.SimulatedDataTypeSizes_BOOL, 1): ToReference(values2.NewPlcBOOL(true)),
+					},
+				},
+				options: map[string][]string{},
+			},
+			args: args{
+				fields: map[string]model.PlcField{
+					"test": NewSimulatedField(FieldState, "lalala", model2.SimulatedDataTypeSizes_BOOL, 1),
+				},
+				fieldNames: []string{"test"},
+			},
+			want: model3.NewDefaultPlcReadResponse(nil,
+				map[string]model.PlcResponseCode{
+					"test": model.PlcResponseCode_NOT_FOUND,
+				},
+				map[string]values.PlcValue{
+					"test": nil,
+				}),
+			delayAtLeast: 0,
+		},
+		// Passing in a completely wrong type of field.
+		{
+			name: "invalid field type",
+			fields: fields{
+				device: &Device{
+					Name: "hurz",
+					State: map[SimulatedField]*values.PlcValue{
+						NewSimulatedField(FieldState, "test", model2.SimulatedDataTypeSizes_BOOL, 1): ToReference(values2.NewPlcBOOL(true)),
+					},
+				},
+				options: map[string][]string{},
+			},
+			args: args{
+				fields: map[string]model.PlcField{
+					"test": s7.PlcField{
+						FieldType:   s7.S7Field,
+						MemoryArea:  model4.MemoryArea_DATA_BLOCKS,
+						BlockNumber: 1,
+						ByteOffset:  1,
+						BitOffset:   0,
+						NumElements: 1,
+						Datatype:    model4.TransportSize_BOOL,
+					},
+				},
+				fieldNames: []string{"test"},
+			},
+			want: model3.NewDefaultPlcReadResponse(nil,
+				map[string]model.PlcResponseCode{
+					"test": model.PlcResponseCode_INVALID_ADDRESS,
+				},
+				map[string]values.PlcValue{
+					"test": nil,
+				}),
+			delayAtLeast: 0,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			r := NewReader(tt.fields.device, tt.fields.options)
+			readRequest := model3.NewDefaultPlcReadRequest(tt.args.fields, tt.args.fieldNames, r, nil)
+			timeBeforeReadRequest := time.Now()
+			readResponseChannel := r.Read(readRequest)
+			select {
+			case readResponse := <-readResponseChannel:
+				timeAfterReadRequest := time.Now()
+				// If an expected delay was defined, check if closing
+				// took at least this long.
+				if tt.delayAtLeast > 0 {
+					pingTime := timeAfterReadRequest.Sub(timeBeforeReadRequest)
+					if pingTime < tt.delayAtLeast {
+						t.Errorf("Reader.Read() completed too fast. Expected at least %v but returned after %v", tt.delayAtLeast, pingTime)
+					}
+				}
+				if !reflect.DeepEqual(readResponse.GetRequest(), readRequest) {
+					t.Errorf("Reader.Read() ReadRequest = %v, want %v", readResponse.GetRequest(), readRequest)
+				}
+				for _, fieldName := range readRequest.GetFieldNames() {
+					if !reflect.DeepEqual(readResponse.GetResponse().GetResponseCode(fieldName), tt.want.GetResponseCode(fieldName)) {
+						t.Errorf("Reader.Read() PlcResponse.ResponseCode = %v, want %v",
+							readResponse.GetResponse().GetResponseCode(fieldName), tt.want.GetResponseCode(fieldName))
+					}
+					if !reflect.DeepEqual(readResponse.GetResponse().GetValue(fieldName), tt.want.GetValue(fieldName)) {
+						t.Errorf("Reader.Read() PlcResponse.Value = %v, want %v",
+							readResponse.GetResponse().GetValue(fieldName), tt.want.GetValue(fieldName))
+					}
+				}
+			case <-time.After(3 * time.Second):
+				t.Errorf("Reader.Read() got timeout")
+			}
+		})
+	}
+}
diff --git a/plc4go/internal/plc4go/simulated/ValueHandler.go b/plc4go/internal/plc4go/simulated/ValueHandler.go
new file mode 100644
index 0000000..dc1e155
--- /dev/null
+++ b/plc4go/internal/plc4go/simulated/ValueHandler.go
@@ -0,0 +1,37 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package simulated
+
+import (
+	"github.com/apache/plc4x/plc4go/pkg/plc4go/model"
+	"github.com/apache/plc4x/plc4go/pkg/plc4go/values"
+)
+
+type ValueHandler struct {
+}
+
+func NewValueHandler() ValueHandler {
+	return ValueHandler{}
+}
+
+func (v ValueHandler) NewPlcValue(field model.PlcField, value interface{}) (values.PlcValue, error) {
+	//TODO implement me
+	panic("implement me")
+}
diff --git a/plc4go/internal/plc4go/simulated/Writer.go b/plc4go/internal/plc4go/simulated/Writer.go
new file mode 100644
index 0000000..e830b7f
--- /dev/null
+++ b/plc4go/internal/plc4go/simulated/Writer.go
@@ -0,0 +1,76 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package simulated
+
+import (
+	model2 "github.com/apache/plc4x/plc4go/internal/plc4go/spi/model"
+	"github.com/apache/plc4x/plc4go/pkg/plc4go/model"
+	"strconv"
+	"time"
+)
+
+type Writer struct {
+	device  *Device
+	options map[string][]string
+}
+
+func NewWriter(device *Device, options map[string][]string) Writer {
+	return Writer{
+		device:  device,
+		options: options,
+	}
+}
+
+func (w Writer) Write(writeRequest model.PlcWriteRequest) <-chan model.PlcWriteRequestResult {
+	ch := make(chan model.PlcWriteRequestResult)
+	go func() {
+		// Possibly add a delay.
+		if delayString, ok := w.options["writeDelay"]; ok {
+			if len(delayString) == 1 {
+				delay, err := strconv.Atoi(delayString[0])
+				if err == nil {
+					time.Sleep(time.Duration(delay) * time.Millisecond)
+				}
+			}
+		}
+
+		// Process the request
+		responseCodes := map[string]model.PlcResponseCode{}
+		for _, fieldName := range writeRequest.GetFieldNames() {
+			field := writeRequest.GetField(fieldName)
+			simulatedField, ok := field.(SimulatedField)
+			if !ok {
+				responseCodes[fieldName] = model.PlcResponseCode_INVALID_ADDRESS
+			} else {
+				plcValue := writeRequest.GetValue(fieldName)
+				w.device.Set(simulatedField, &plcValue)
+				responseCodes[fieldName] = model.PlcResponseCode_OK
+			}
+		}
+
+		// Emit the response
+		ch <- &model2.DefaultPlcWriteRequestResult{
+			Request:  writeRequest,
+			Response: model2.NewDefaultPlcWriteResponse(writeRequest, responseCodes),
+			Err:      nil,
+		}
+	}()
+	return ch
+}
diff --git a/plc4go/internal/plc4go/simulated/Writer_test.go b/plc4go/internal/plc4go/simulated/Writer_test.go
new file mode 100644
index 0000000..7312446
--- /dev/null
+++ b/plc4go/internal/plc4go/simulated/Writer_test.go
@@ -0,0 +1,214 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package simulated
+
+import (
+	"github.com/apache/plc4x/plc4go/internal/plc4go/s7"
+	model4 "github.com/apache/plc4x/plc4go/internal/plc4go/s7/readwrite/model"
+	model2 "github.com/apache/plc4x/plc4go/internal/plc4go/simulated/readwrite/model"
+	model3 "github.com/apache/plc4x/plc4go/internal/plc4go/spi/model"
+	values2 "github.com/apache/plc4x/plc4go/internal/plc4go/spi/values"
+	"github.com/apache/plc4x/plc4go/pkg/plc4go/model"
+	"github.com/apache/plc4x/plc4go/pkg/plc4go/values"
+	"reflect"
+	"testing"
+	"time"
+)
+
+func TestWriter_Write(t *testing.T) {
+	type fields struct {
+		device  *Device
+		options map[string][]string
+	}
+	type args struct {
+		fields     map[string]model.PlcField
+		values     map[string]values.PlcValue
+		fieldNames []string
+	}
+	tests := []struct {
+		name         string
+		fields       fields
+		args         args
+		want         model.PlcWriteResponse
+		newState     map[SimulatedField]*values.PlcValue
+		delayAtLeast time.Duration
+	}{
+		{
+			name: "simple state",
+			fields: fields{
+				device: &Device{
+					Name:  "hurz",
+					State: map[SimulatedField]*values.PlcValue{},
+				},
+				options: map[string][]string{},
+			},
+			args: args{
+				fields: map[string]model.PlcField{
+					"test": NewSimulatedField(FieldState, "test", model2.SimulatedDataTypeSizes_BOOL, 1),
+				},
+				values: map[string]values.PlcValue{
+					"test": values2.NewPlcBOOL(true),
+				},
+				fieldNames: []string{"test"},
+			},
+			want: model3.NewDefaultPlcWriteResponse(nil,
+				map[string]model.PlcResponseCode{
+					"test": model.PlcResponseCode_OK,
+				}),
+			newState: map[SimulatedField]*values.PlcValue{
+				NewSimulatedField(FieldState, "test", model2.SimulatedDataTypeSizes_BOOL, 1): ToReference(values2.NewPlcBOOL(true)),
+			},
+			delayAtLeast: 0,
+		},
+		{
+			name: "simple state overwrite",
+			fields: fields{
+				device: &Device{
+					Name: "hurz",
+					State: map[SimulatedField]*values.PlcValue{
+						NewSimulatedField(FieldState, "test", model2.SimulatedDataTypeSizes_BOOL, 1): ToReference(values2.NewPlcBOOL(true)),
+					},
+				},
+				options: map[string][]string{},
+			},
+			args: args{
+				fields: map[string]model.PlcField{
+					"test": NewSimulatedField(FieldState, "test", model2.SimulatedDataTypeSizes_BOOL, 1),
+				},
+				values: map[string]values.PlcValue{
+					"test": values2.NewPlcBOOL(false),
+				},
+				fieldNames: []string{"test"},
+			},
+			want: model3.NewDefaultPlcWriteResponse(nil,
+				map[string]model.PlcResponseCode{
+					"test": model.PlcResponseCode_OK,
+				}),
+			newState: map[SimulatedField]*values.PlcValue{
+				NewSimulatedField(FieldState, "test", model2.SimulatedDataTypeSizes_BOOL, 1): ToReference(values2.NewPlcBOOL(false)),
+			},
+			delayAtLeast: 0,
+		},
+		{
+			name: "simple state delayed",
+			fields: fields{
+				device: &Device{
+					Name: "hurz",
+					State: map[SimulatedField]*values.PlcValue{
+						NewSimulatedField(FieldState, "test", model2.SimulatedDataTypeSizes_BOOL, 1): ToReference(values2.NewPlcBOOL(true)),
+					},
+				},
+				options: map[string][]string{
+					"writeDelay": {"1000"},
+				},
+			},
+			args: args{
+				fields: map[string]model.PlcField{
+					"test": NewSimulatedField(FieldState, "test", model2.SimulatedDataTypeSizes_BOOL, 1),
+				},
+				values: map[string]values.PlcValue{
+					"test": values2.NewPlcBOOL(false),
+				},
+				fieldNames: []string{"test"},
+			},
+			want: model3.NewDefaultPlcWriteResponse(nil,
+				map[string]model.PlcResponseCode{
+					"test": model.PlcResponseCode_OK,
+				}),
+			newState: map[SimulatedField]*values.PlcValue{
+				NewSimulatedField(FieldState, "test", model2.SimulatedDataTypeSizes_BOOL, 1): ToReference(values2.NewPlcBOOL(false)),
+			},
+			delayAtLeast: 1000,
+		},
+		// Passing in a completely wrong type of field.
+		{
+			name: "invalid field type",
+			fields: fields{
+				device: &Device{
+					Name: "hurz",
+					State: map[SimulatedField]*values.PlcValue{
+						NewSimulatedField(FieldState, "test", model2.SimulatedDataTypeSizes_BOOL, 1): ToReference(values2.NewPlcBOOL(true)),
+					},
+				},
+				options: map[string][]string{},
+			},
+			args: args{
+				fields: map[string]model.PlcField{
+					"test": s7.PlcField{
+						FieldType:   s7.S7Field,
+						MemoryArea:  model4.MemoryArea_DATA_BLOCKS,
+						BlockNumber: 1,
+						ByteOffset:  1,
+						BitOffset:   0,
+						NumElements: 1,
+						Datatype:    model4.TransportSize_BOOL,
+					},
+				},
+				values: map[string]values.PlcValue{
+					"test": values2.NewPlcBOOL(false),
+				},
+				fieldNames: []string{"test"},
+			},
+			want: model3.NewDefaultPlcWriteResponse(nil,
+				map[string]model.PlcResponseCode{
+					"test": model.PlcResponseCode_INVALID_ADDRESS,
+				}),
+			newState: map[SimulatedField]*values.PlcValue{
+				NewSimulatedField(FieldState, "test", model2.SimulatedDataTypeSizes_BOOL, 1): ToReference(values2.NewPlcBOOL(true)),
+			},
+			delayAtLeast: 0,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			w := NewWriter(tt.fields.device, tt.fields.options)
+			writeRequest := model3.NewDefaultPlcWriteRequest(tt.args.fields, tt.args.fieldNames, tt.args.values, w, nil)
+			timeBeforeWriteRequest := time.Now()
+			writeResponseChannel := w.Write(writeRequest)
+			select {
+			case writeResponse := <-writeResponseChannel:
+				timeAfterWriteRequest := time.Now()
+				// If an expected delay was defined, check if closing
+				// took at least this long.
+				if tt.delayAtLeast > 0 {
+					pingTime := timeAfterWriteRequest.Sub(timeBeforeWriteRequest)
+					if pingTime < tt.delayAtLeast {
+						t.Errorf("Writer.Write() completed too fast. Expected at least %v but returned after %v", tt.delayAtLeast, pingTime)
+					}
+				}
+				if !reflect.DeepEqual(writeResponse.GetRequest(), writeRequest) {
+					t.Errorf("Writer.Write() ReadRequest = %v, want %v", writeResponse.GetRequest(), writeRequest)
+				}
+				for _, fieldName := range writeRequest.GetFieldNames() {
+					if !reflect.DeepEqual(writeResponse.GetResponse().GetResponseCode(fieldName), tt.want.GetResponseCode(fieldName)) {
+						t.Errorf("Writer.Write() PlcResponse.ResponseCode = %v, want %v",
+							writeResponse.GetResponse().GetResponseCode(fieldName), tt.want.GetResponseCode(fieldName))
+					}
+				}
+				if !reflect.DeepEqual(tt.fields.device.State, tt.newState) {
+					t.Errorf("Writer.Write() Device State = %v, want %v",
+						tt.fields.device.State, tt.newState)
+				}
+			case <-time.After(3 * time.Second):
+				t.Errorf("Reader.Read() got timeout")
+			}
+		})
+	}
+}
diff --git a/plc4go/internal/plc4go/utils/pool/PlcConnectionPool.go b/plc4go/internal/plc4go/utils/pool/PlcConnectionPool.go
new file mode 100644
index 0000000..f1be9e5
--- /dev/null
+++ b/plc4go/internal/plc4go/utils/pool/PlcConnectionPool.go
@@ -0,0 +1,158 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package pool
+
+import (
+	"github.com/apache/plc4x/plc4go/internal/plc4go/spi/default"
+	"github.com/apache/plc4x/plc4go/pkg/plc4go"
+	"github.com/pkg/errors"
+	"github.com/viney-shih/go-lock"
+	"time"
+)
+
+type PlcConnectionPool struct {
+	driverManager plc4go.PlcDriverManager
+
+	// Maximum duration a connection can be used per lease.
+	// If the connection is used for a longer time, it is forcefully removed from the client.
+	maxLeaseTime time.Duration
+	maxWaitTime  time.Duration
+
+	poolLock    lock.RWMutex
+	connections map[string]*PooledPlcConnection
+}
+
+func NewPlcConnectionPool(driverManager plc4go.PlcDriverManager) *PlcConnectionPool {
+	return NewPlcConnectionPoolWithMaxLeaseTime(driverManager, time.Second*20)
+}
+
+func NewPlcConnectionPoolWithMaxLeaseTime(driverManager plc4go.PlcDriverManager, maxLeaseTime time.Duration) *PlcConnectionPool {
+	return &PlcConnectionPool{
+		driverManager: driverManager,
+		maxLeaseTime:  maxLeaseTime,
+		maxWaitTime:   maxLeaseTime * 5,
+		poolLock:      lock.NewCASMutex(),
+		connections:   make(map[string]*PooledPlcConnection),
+	}
+}
+
+func (t *PlcConnectionPool) GetConnection(connectionString string) <-chan plc4go.PlcConnectionConnectResult {
+	ch := make(chan plc4go.PlcConnectionConnectResult)
+
+	go func() {
+		// Check if we've already got this connection
+		t.poolLock.Lock()
+		defer t.poolLock.Unlock()
+		// Try to get a connection for the given url.
+		// If this returns ok, this means there is already a connection
+		// available, so we'll try to use that. If it fails, we need
+		// to create a completely new connection.
+		if connection, ok := t.connections[connectionString]; ok {
+			// Use an existing connection
+
+			// Check if the connection is available.
+			if connection.state == StateIdle {
+				// As soon as we have the lock, return the connection.
+				pooledConnection := t.connections[connectionString]
+				ch <- _default.NewDefaultPlcConnectionConnectResult(pooledConnection, nil)
+			} else if connection.state == StateInUse {
+				// If the connection is currently busy, add the new channel to the queue for this connection.
+				pooledConnection := t.connections[connectionString]
+				pooledConnection.enqueue(ch)
+			} else {
+				ch <- _default.NewDefaultPlcConnectionConnectResult(nil, errors.New("timeout"))
+			}
+		} else {
+			// Create a new connection.
+
+			pooledPlcConnection := NewPooledPlcConnection(connectionString, t)
+			t.connections[connectionString] = pooledPlcConnection
+
+			// Initialize the new connection.
+			connectionResultChan := t.driverManager.GetConnection(connectionString)
+
+			// Allow us to finish this function and return the lock quickly
+			go func() {
+				// Wait for the connection to be established.
+				connectionResult := <-connectionResultChan
+
+				// If the connection was successful, pass the active connection into the container.
+				// If something went wrong, we have to remove the connection from the pool and return the error.
+				if connectionResult.GetErr() == nil {
+					// Make sure we have the lock here so all following operations will execute atomically.
+					pooledPlcConnection.lock.Lock()
+					defer pooledPlcConnection.lock.Unlock()
+
+					// Inject the real connection into the container.
+					pooledPlcConnection.activeConnection = connectionResult.GetConnection()
+					// Mark the connection as being used.
+					pooledPlcConnection.state = StateInUse
+
+					// Return the pooled connection to the client.
+					ch <- _default.NewDefaultPlcConnectionCloseResult(pooledPlcConnection, nil)
+				} else {
+					// Mark the connection as broken.
+					pooledPlcConnection.state = StateInvalid
+
+					// Remove the broken connection from the pool.
+					t.poolLock.Lock()
+					defer t.poolLock.Unlock()
+					delete(t.connections, connectionString)
+
+					// Forward the error to the client.
+					ch <- _default.NewDefaultPlcConnectionConnectResult(nil, connectionResult.GetErr())
+				}
+			}()
+		}
+	}()
+
+	return ch
+}
+
+func (t *PlcConnectionPool) returnConnection(pooledConnection *PooledPlcConnection) error {
+	// If the connection is marked as "invalid", destroy it and remove it from the pool.
+	if pooledConnection.state == StateInvalid {
+		// At least try to close the invalid connection.
+		pooledConnection.activeConnection.Close()
+
+		// TODO: Either try to reconnect or cancel all waiting connections
+
+		// Remove the connection from the pool.
+		t.poolLock.Lock()
+		defer t.poolLock.Unlock()
+		delete(t.connections, pooledConnection.connectionString)
+		return nil
+	}
+
+	pooledConnection.lock.Lock()
+	defer pooledConnection.lock.Unlock()
+	// Check how many others are waiting for this connection.
+	if len(pooledConnection.queue) > 0 {
+		// There are waiting clients, give the connection to the next client in the line.
+		next := pooledConnection.queue[0]
+		pooledConnection.queue = pooledConnection.queue[1:]
+		next <- _default.NewDefaultPlcConnectionConnectResult(pooledConnection, nil)
+	} else {
+		// Otherwise, just mark the connection as idle.
+		pooledConnection.state = StateIdle
+	}
+
+	return nil
+}
diff --git a/plc4go/internal/plc4go/utils/pool/PlcConnectionPool_test.go b/plc4go/internal/plc4go/utils/pool/PlcConnectionPool_test.go
new file mode 100644
index 0000000..919e375
--- /dev/null
+++ b/plc4go/internal/plc4go/utils/pool/PlcConnectionPool_test.go
@@ -0,0 +1,88 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package pool
+
+import (
+	"github.com/apache/plc4x/plc4go/internal/plc4go/simulated"
+	"github.com/apache/plc4x/plc4go/pkg/plc4go"
+	"testing"
+	"time"
+)
+
+func TestPlcConnectionPool_GetConnection(t1 *testing.T) {
+	type fields struct {
+		driverManager plc4go.PlcDriverManager
+	}
+	type args struct {
+		connectionString string
+	}
+	tests := []struct {
+		name        string
+		fields      fields
+		args        args
+		wantErr     bool
+		wantTimeout bool
+	}{
+		{name: "simple",
+			fields: fields{
+				driverManager: func() plc4go.PlcDriverManager {
+					driverManager := plc4go.NewPlcDriverManager()
+					driverManager.RegisterDriver(simulated.NewDriver())
+					return driverManager
+				}(),
+			}, args: args{
+				connectionString: "simulated://1.2.3.4:42",
+			},
+			wantErr:     false,
+			wantTimeout: false,
+		},
+		{name: "simpleWithTimeout",
+			fields: fields{
+				driverManager: func() plc4go.PlcDriverManager {
+					driverManager := plc4go.NewPlcDriverManager()
+					driverManager.RegisterDriver(simulated.NewDriver())
+					return driverManager
+				}(),
+			}, args: args{
+				connectionString: "simulated://1.2.3.4:42?connectionDelay=5",
+			},
+			wantErr:     false,
+			wantTimeout: true,
+		},
+	}
+	for _, tt := range tests {
+		t1.Run(tt.name, func(t1 *testing.T) {
+			t := NewPlcConnectionPool(tt.fields.driverManager)
+			got := t.GetConnection(tt.args.connectionString)
+			select {
+			case connectResult := <-got:
+				if tt.wantErr && (connectResult.GetErr() == nil) {
+					t1.Errorf("PlcConnectionPool.GetConnection() = %v, wantErr %v", connectResult.GetErr(), tt.wantErr)
+				} else if connectResult.GetErr() != nil {
+					t1.Errorf("PlcConnectionPool.GetConnection() error = %v, wantErr %v", connectResult.GetErr(), tt.wantErr)
+				}
+			case <-time.After(3 * time.Second):
+				if !tt.wantTimeout {
+					t1.Errorf("PlcConnectionPool.GetConnection() got timeout")
+				}
+			}
+		})
+	}
+}
diff --git a/plc4go/internal/plc4go/utils/pool/PooledPlcConnection.go b/plc4go/internal/plc4go/utils/pool/PooledPlcConnection.go
new file mode 100644
index 0000000..20765cc
--- /dev/null
+++ b/plc4go/internal/plc4go/utils/pool/PooledPlcConnection.go
@@ -0,0 +1,188 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package pool
+
+import (
+	_default "github.com/apache/plc4x/plc4go/internal/plc4go/spi/default"
+	"github.com/apache/plc4x/plc4go/pkg/plc4go"
+	"github.com/apache/plc4x/plc4go/pkg/plc4go/model"
+	"github.com/viney-shih/go-lock"
+	"time"
+)
+
+type PooledPlcConnectionState int32
+
+const (
+	StateInitialized PooledPlcConnectionState = iota
+	StateIdle
+	StateInUse
+	StateInvalid
+)
+
+type PooledPlcConnection struct {
+	connectionString string
+	// Reference to the pool (used for giving back connection)
+	connectionPool *PlcConnectionPool
+
+	// The lock for manipulating the pools state.
+	lock lock.Mutex
+	// The actual connection being pooled.
+	activeConnection plc4go.PlcConnection
+	// The current state of this connection.
+	state PooledPlcConnectionState
+	// Queue of waiting clients.
+	queue []chan plc4go.PlcConnectionConnectResult
+}
+
+func NewPooledPlcConnection(connectionString string, connectionPool *PlcConnectionPool) *PooledPlcConnection {
+	return &PooledPlcConnection{
+		connectionString: connectionString,
+		state:            StateInitialized,
+		lock:             lock.NewCASMutex(),
+		queue:            make([]chan plc4go.PlcConnectionConnectResult, 0),
+		connectionPool:   connectionPool,
+	}
+}
+
+func (t *PooledPlcConnection) setActiveConnection(activeConnection plc4go.PlcConnection) {
+	t.lock.Lock()
+	defer t.lock.Unlock()
+	t.activeConnection = activeConnection
+}
+
+func (t *PooledPlcConnection) setState(state PooledPlcConnectionState) {
+	t.lock.Lock()
+	defer t.lock.Unlock()
+	t.state = state
+}
+
+func (t *PooledPlcConnection) enqueue(ch chan plc4go.PlcConnectionConnectResult) {
+	t.lock.Lock()
+	defer t.lock.Unlock()
+	t.queue = append(t.queue, ch)
+}
+
+func (t *PooledPlcConnection) Connect() <-chan plc4go.PlcConnectionConnectResult {
+	if t.activeConnection == nil {
+		panic("No active connection")
+	}
+	panic("Called 'Connect' on a pooled connection")
+}
+
+func (t *PooledPlcConnection) BlockingClose() {
+	if t.activeConnection == nil {
+		panic("No active connection")
+	}
+
+	// Call close and wait for the operation to finish.
+	<-t.Close()
+}
+
+func (t *PooledPlcConnection) Close() <-chan plc4go.PlcConnectionCloseResult {
+	if t.activeConnection == nil {
+		panic("No active connection")
+	}
+
+	result := make(chan plc4go.PlcConnectionCloseResult)
+
+	go func() {
+		// Check if the connection is still alive, if it is, put it back into the pool
+		pingResults := t.Ping()
+		pingTimeout := time.NewTimer(time.Second * 5)
+		select {
+		case pingResult := <-pingResults:
+			{
+				if pingResult.GetErr() != nil {
+					// Mark the connection as broken ...
+					t.state = StateInvalid
+				}
+			}
+		case <-pingTimeout.C:
+			{
+				// Mark the connection as broken ...
+				t.state = StateInvalid
+			}
+		}
+
+		// Return the connection to the pool and don't actually close it.
+		err := t.connectionPool.returnConnection(t)
+
+		// Finish closing the connection.
+		result <- _default.NewDefaultPlcConnectionCloseResult(t, err)
+	}()
+
+	return result
+}
+
+func (t *PooledPlcConnection) IsConnected() bool {
+	if t.activeConnection == nil {
+		panic("No active connection")
+	}
+	return t.activeConnection.IsConnected()
+}
+
+func (t *PooledPlcConnection) Ping() <-chan plc4go.PlcConnectionPingResult {
+	if t.activeConnection == nil {
+		panic("No active connection")
+	}
+	return t.activeConnection.Ping()
+}
+
+func (t *PooledPlcConnection) GetMetadata() model.PlcConnectionMetadata {
+	if t.activeConnection == nil {
+		panic("No active connection")
+	}
+	return t.activeConnection.GetMetadata()
+}
+
+func (t *PooledPlcConnection) ReadRequestBuilder() model.PlcReadRequestBuilder {
+	if t.activeConnection == nil {
+		panic("No active connection")
+	}
+	return t.activeConnection.ReadRequestBuilder()
+}
+
+func (t *PooledPlcConnection) WriteRequestBuilder() model.PlcWriteRequestBuilder {
+	if t.activeConnection == nil {
+		panic("No active connection")
+	}
+	return t.activeConnection.WriteRequestBuilder()
+}
+
+func (t *PooledPlcConnection) SubscriptionRequestBuilder() model.PlcSubscriptionRequestBuilder {
+	if t.activeConnection == nil {
+		panic("No active connection")
+	}
+	return t.activeConnection.SubscriptionRequestBuilder()
+}
+
+func (t *PooledPlcConnection) UnsubscriptionRequestBuilder() model.PlcUnsubscriptionRequestBuilder {
+	if t.activeConnection == nil {
+		panic("No active connection")
+	}
+	return t.activeConnection.UnsubscriptionRequestBuilder()
+}
+
+func (t *PooledPlcConnection) BrowseRequestBuilder() model.PlcBrowseRequestBuilder {
+	if t.activeConnection == nil {
+		panic("No active connection")
+	}
+	return t.activeConnection.BrowseRequestBuilder()
+}
diff --git a/plc4go/pkg/plc4go/pool/plc_connection_pool.go b/plc4go/pkg/plc4go/pool/plc_connection_pool.go
new file mode 100644
index 0000000..1a91b9d
--- /dev/null
+++ b/plc4go/pkg/plc4go/pool/plc_connection_pool.go
@@ -0,0 +1,20 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package pool