Updated Message Handling to new MessageBroker

Support ESP32S3 and ESP32C3 while compiling

Makefile

@@ -13,6 +13,15 @@ get_code_gen:
 gen_prot:
 	./alox.protogen -i prot.json -o main/uart
 
+switch_to_s3:
+	idf.py set-target esp32s3
+	cp sdkconfig.s3 sdkconfig
+	idf.py build
+
+switch_to_c3:
+	idf.py set-target esp32c3
+	cp sdkconfig.c3 sdkconfig
+	idf.py build
 
 buildIdf:
 	idf.py build 
@@ -20,6 +29,23 @@ buildIdf:
 flashMini:
 	idf.py flash -p /dev/ttyACM0 
 
+flashMini2:
+	idf.py flash -p /dev/ttyACM1
+
+flashMini3:
+	idf.py flash -p /dev/ttyACM2
+
+flashCluster:
+	idf.py flash -p /dev/ttyACM1
+	idf.py flash -p /dev/ttyACM2
+	idf.py flash -p /dev/ttyACM3
+	idf.py flash -p /dev/ttyACM4
+	idf.py flash -p /dev/ttyACM5
+	idf.py flash -p /dev/ttyACM6
+	idf.py flash -p /dev/ttyACM7
+	idf.py flash -p /dev/ttyACM8
+
+
 monitorMini:
 	idf.py monitor -p /dev/ttyACM0 
 

goTool/go.mod

@@ -0,0 +1,24 @@
+module alox.tool
+
+go 1.24.5
+
+require (
+	github.com/pterm/pterm v0.12.81
+	go.bug.st/serial v1.6.4
+)
+
+require (
+	atomicgo.dev/cursor v0.2.0 // indirect
+	atomicgo.dev/keyboard v0.2.9 // indirect
+	atomicgo.dev/schedule v0.1.0 // indirect
+	github.com/containerd/console v1.0.5 // indirect
+	github.com/creack/goselect v0.1.2 // indirect
+	github.com/gookit/color v1.5.4 // indirect
+	github.com/lithammer/fuzzysearch v1.1.8 // indirect
+	github.com/mattn/go-runewidth v0.0.16 // indirect
+	github.com/rivo/uniseg v0.4.7 // indirect
+	github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
+	golang.org/x/sys v0.33.0 // indirect
+	golang.org/x/term v0.32.0 // indirect
+	golang.org/x/text v0.26.0 // indirect
+)

goTool/go.sum

@@ -0,0 +1,124 @@
+atomicgo.dev/assert v0.0.2 h1:FiKeMiZSgRrZsPo9qn/7vmr7mCsh5SZyXY4YGYiYwrg=
+atomicgo.dev/assert v0.0.2/go.mod h1:ut4NcI3QDdJtlmAxQULOmA13Gz6e2DWbSAS8RUOmNYQ=
+atomicgo.dev/cursor v0.2.0 h1:H6XN5alUJ52FZZUkI7AlJbUc1aW38GWZalpYRPpoPOw=
+atomicgo.dev/cursor v0.2.0/go.mod h1:Lr4ZJB3U7DfPPOkbH7/6TOtJ4vFGHlgj1nc+n900IpU=
+atomicgo.dev/keyboard v0.2.9 h1:tOsIid3nlPLZ3lwgG8KZMp/SFmr7P0ssEN5JUsm78K8=
+atomicgo.dev/keyboard v0.2.9/go.mod h1:BC4w9g00XkxH/f1HXhW2sXmJFOCWbKn9xrOunSFtExQ=
+atomicgo.dev/schedule v0.1.0 h1:nTthAbhZS5YZmgYbb2+DH8uQIZcTlIrd4eYr3UQxEjs=
+atomicgo.dev/schedule v0.1.0/go.mod h1:xeUa3oAkiuHYh8bKiQBRojqAMq3PXXbJujjb0hw8pEU=
+github.com/MarvinJWendt/testza v0.1.0/go.mod h1:7AxNvlfeHP7Z/hDQ5JtE3OKYT3XFUeLCDE2DQninSqs=
+github.com/MarvinJWendt/testza v0.2.1/go.mod h1:God7bhG8n6uQxwdScay+gjm9/LnO4D3kkcZX4hv9Rp8=
+github.com/MarvinJWendt/testza v0.2.8/go.mod h1:nwIcjmr0Zz+Rcwfh3/4UhBp7ePKVhuBExvZqnKYWlII=
+github.com/MarvinJWendt/testza v0.2.10/go.mod h1:pd+VWsoGUiFtq+hRKSU1Bktnn+DMCSrDrXDpX2bG66k=
+github.com/MarvinJWendt/testza v0.2.12/go.mod h1:JOIegYyV7rX+7VZ9r77L/eH6CfJHHzXjB69adAhzZkI=
+github.com/MarvinJWendt/testza v0.3.0/go.mod h1:eFcL4I0idjtIx8P9C6KkAuLgATNKpX4/2oUqKc6bF2c=
+github.com/MarvinJWendt/testza v0.4.2/go.mod h1:mSdhXiKH8sg/gQehJ63bINcCKp7RtYewEjXsvsVUPbE=
+github.com/MarvinJWendt/testza v0.5.2 h1:53KDo64C1z/h/d/stCYCPY69bt/OSwjq5KpFNwi+zB4=
+github.com/MarvinJWendt/testza v0.5.2/go.mod h1:xu53QFE5sCdjtMCKk8YMQ2MnymimEctc4n3EjyIYvEY=
+github.com/atomicgo/cursor v0.0.1/go.mod h1:cBON2QmmrysudxNBFthvMtN32r3jxVRIvzkUiF/RuIk=
+github.com/containerd/console v1.0.3/go.mod h1:7LqA/THxQ86k76b8c/EMSiaJ3h1eZkMkXar0TQ1gf3U=
+github.com/containerd/console v1.0.5 h1:R0ymNeydRqH2DmakFNdmjR2k0t7UPuiOV/N/27/qqsc=
+github.com/containerd/console v1.0.5/go.mod h1:YynlIjWYF8myEu6sdkwKIvGQq+cOckRm6So2avqoYAk=
+github.com/creack/goselect v0.1.2 h1:2DNy14+JPjRBgPzAd1thbQp4BSIihxcBf0IXhQXDRa0=
+github.com/creack/goselect v0.1.2/go.mod h1:a/NhLweNvqIYMuxcMOuWY516Cimucms3DglDzQP3hKY=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/gookit/color v1.4.2/go.mod h1:fqRyamkC1W8uxl+lxCQxOT09l/vYfZ+QeiX3rKQHCoQ=
+github.com/gookit/color v1.5.0/go.mod h1:43aQb+Zerm/BWh2GnrgOQm7ffz7tvQXEKV6BFMl7wAo=
+github.com/gookit/color v1.5.4 h1:FZmqs7XOyGgCAxmWyPslpiok1k05wmY3SJTytgvYFs0=
+github.com/gookit/color v1.5.4/go.mod h1:pZJOeOS8DM43rXbp4AZo1n9zCU2qjpcRko0b6/QJi9w=
+github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
+github.com/klauspost/cpuid/v2 v2.0.10/go.mod h1:g2LTdtYhdyuGPqyWyv7qRAmj1WBqxuObKfj5c0PQa7c=
+github.com/klauspost/cpuid/v2 v2.0.12/go.mod h1:g2LTdtYhdyuGPqyWyv7qRAmj1WBqxuObKfj5c0PQa7c=
+github.com/klauspost/cpuid/v2 v2.2.3 h1:sxCkb+qR91z4vsqw4vGGZlDgPz3G7gjaLyK3V8y70BU=
+github.com/klauspost/cpuid/v2 v2.2.3/go.mod h1:RVVoqg1df56z8g3pUjL/3lE5UfnlrJX8tyFgg4nqhuY=
+github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/lithammer/fuzzysearch v1.1.8 h1:/HIuJnjHuXS8bKaiTMeeDlW2/AyIWk2brx1V8LFgLN4=
+github.com/lithammer/fuzzysearch v1.1.8/go.mod h1:IdqeyBClc3FFqSzYq/MXESsS4S0FsZ5ajtkr5xPLts4=
+github.com/mattn/go-runewidth v0.0.13/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
+github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
+github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
+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/pterm/pterm v0.12.27/go.mod h1:PhQ89w4i95rhgE+xedAoqous6K9X+r6aSOI2eFF7DZI=
+github.com/pterm/pterm v0.12.29/go.mod h1:WI3qxgvoQFFGKGjGnJR849gU0TsEOvKn5Q8LlY1U7lg=
+github.com/pterm/pterm v0.12.30/go.mod h1:MOqLIyMOgmTDz9yorcYbcw+HsgoZo3BQfg2wtl3HEFE=
+github.com/pterm/pterm v0.12.31/go.mod h1:32ZAWZVXD7ZfG0s8qqHXePte42kdz8ECtRyEejaWgXU=
+github.com/pterm/pterm v0.12.33/go.mod h1:x+h2uL+n7CP/rel9+bImHD5lF3nM9vJj80k9ybiiTTE=
+github.com/pterm/pterm v0.12.36/go.mod h1:NjiL09hFhT/vWjQHSj1athJpx6H8cjpHXNAK5bUw8T8=
+github.com/pterm/pterm v0.12.40/go.mod h1:ffwPLwlbXxP+rxT0GsgDTzS3y3rmpAO1NMjUkGTYf8s=
+github.com/pterm/pterm v0.12.81 h1:ju+j5I2++FO1jBKMmscgh5h5DPFDFMB7epEjSoKehKA=
+github.com/pterm/pterm v0.12.81/go.mod h1:TyuyrPjnxfwP+ccJdBTeWHtd/e0ybQHkOS/TakajZCw=
+github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
+github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
+github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
+github.com/sergi/go-diff v1.2.0 h1:XU+rvMAioB0UC3q1MFrIQy4Vo5/4VsRDQQXHsEya6xQ=
+github.com/sergi/go-diff v1.2.0/go.mod h1:STckp+ISIX8hZLjrqAeVduY0gWCT9IjLuqbuNXdaHfM=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
+github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
+github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+github.com/xo/terminfo v0.0.0-20210125001918-ca9a967f8778/go.mod h1:2MuV+tbUrU1zIOPMxZ5EncGwgmMJsa+9ucAQZXxsObs=
+github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e h1:JVG44RsyaB9T2KIHavMF/ppJZNG9ZpyihvCd0w101no=
+github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e/go.mod h1:RbqR21r5mrJuqunuUZ/Dhy/avygyECGrLceyNeo4LiM=
+github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
+go.bug.st/serial v1.6.4 h1:7FmqNPgVp3pu2Jz5PoPtbZ9jJO5gnEnZIvnI1lzve8A=
+go.bug.st/serial v1.6.4/go.mod h1:nofMJxTeNVny/m6+KaafC6vJGj3miwQZ6vW4BZUGJPI=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
+golang.org/x/exp v0.0.0-20220909182711-5c715a9e8561 h1:MDc5xs78ZrZr3HMQugiXOAkSZtfTpbJLDr/lwfgO53E=
+golang.org/x/exp v0.0.0-20220909182711-5c715a9e8561/go.mod h1:cyybsKvd6eL0RnXn6p/Grxp8F5bW7iYuBgsNCOHpMYE=
+golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
+golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
+golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.1.0/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-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/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-20211013075003-97ac67df715c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220319134239-a9b59b0215f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw=
+golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/term v0.0.0-20210220032956-6a3ed077a48d/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/term v0.0.0-20210615171337-6886f2dfbf5b/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
+golang.org/x/term v0.32.0 h1:DR4lr0TjUs3epypdhTOkMmuF5CDFJ/8pOnbzMZPQ7bg=
+golang.org/x/term v0.32.0/go.mod h1:uZG1FhGx848Sqfsq4/DlJr3xGGsYMu/L5GW4abiaEPQ=
+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.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
+golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
+golang.org/x/text v0.26.0 h1:P42AVeLghgTYr4+xUnTRKDMqpar+PtX7KWuNQL21L8M=
+golang.org/x/text v0.26.0/go.mod h1:QK15LZJUUQVJxhz7wXgxSy/CJaTFjd0G+YLonydOVQA=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
+golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

goTool/main.go

@@ -0,0 +1,508 @@
+package main
+
+import (
+	"context"
+	"encoding/binary"
+	"flag"
+	"fmt"
+	"log"
+	"os"
+	"time"
+
+	"github.com/pterm/pterm"
+	"go.bug.st/serial"
+)
+
+type ParserState int
+
+const (
+	// MISC
+	UART_ECHO        = 0x01
+	UART_VERSION     = 0x02
+	UART_CLIENT_INFO = 0x03
+
+	// OTA
+	UART_OTA_START   = 0x10
+	UART_OTA_PAYLOAD = 0x11
+	UART_OTA_END     = 0x12
+	UART_OTA_STATUS  = 0x13
+)
+
+const (
+	WAITING_FOR_START_BYTE ParserState = iota
+	ESCAPED_MESSAGE_ID
+	GET_MESSAGE_ID
+	IN_PAYLOD
+	ESCAPED_PAYLOAD_BYTE
+)
+
+const (
+	START_BYTE  = 0xAA
+	ESCAPE_BYTE = 0xBB
+	END_BYTE    = 0xCC
+)
+
+type ParseError int
+
+const (
+	WRONG_CHECKSUM ParseError = iota
+	UNEXPECETD_BYTE
+)
+
+type MessageReceive struct {
+	raw_message     []byte
+	parsed_message  []byte
+	checksum        byte
+	error           ParseError
+	state           ParserState
+	write_index     int
+	raw_write_index int
+}
+
+type OTASyncManager struct {
+	OTA_MessageCounter         int
+	OTA_PayloadMessageSequence int
+	NewOTAMessage              chan MessageReceive
+	TimeoutMessage             time.Duration
+}
+
+func (ot *OTASyncManager) WaitForNextMessageTimeout() (*MessageReceive, error) {
+	select {
+	case msg := <-ot.NewOTAMessage:
+		return &msg, nil
+	case <-time.After(ot.TimeoutMessage):
+		return nil, fmt.Errorf("Message Timeout")
+	}
+}
+
+func initMessageReceive(mr *MessageReceive) {
+	mr.raw_message = make([]byte, 1024*4)
+	mr.parsed_message = make([]byte, 1024*4)
+	mr.checksum = 0
+	mr.error = 0
+	mr.write_index = 0
+	mr.raw_write_index = 0
+	mr.state = WAITING_FOR_START_BYTE
+}
+
+func addByteToRawBuffer(mr *MessageReceive, pbyte byte) {
+	mr.raw_message[mr.raw_write_index] = pbyte
+	mr.raw_write_index += 1
+}
+func addByteToParsedBuffer(mr *MessageReceive, pbyte byte) {
+	mr.parsed_message[mr.write_index] = pbyte
+	mr.write_index += 1
+	mr.checksum ^= pbyte
+}
+
+func parse_uart_ota_payload_payload(payloadBuffer []byte, payload_len int) {
+	//fmt.Printf("RAW BUFFER: % 02X", payloadBuffer[:payload_len])
+	if payload_len != 4 {
+		fmt.Printf("Payload should be 4 is %v", payload_len)
+		return
+	}
+
+	fmt.Printf("Sequence %v, WriteIndex %v", binary.LittleEndian.Uint16(payloadBuffer[0:1]), binary.LittleEndian.Uint16(payloadBuffer[2:3]))
+}
+
+func parse_uart_version_payload(payloadBuffer []byte, payload_len int) {
+	type payload_data struct {
+		Version   uint16
+		BuildHash [7]uint8
+	}
+
+	tableHeaders := pterm.TableData{
+		{"Version", "Buildhash"},
+	}
+
+	tableData := tableHeaders
+
+	tableData = append(tableData, []string{
+		fmt.Sprintf("%d", binary.LittleEndian.Uint16(payloadBuffer[1:3])),
+		fmt.Sprintf("%s", payloadBuffer[3:10]),
+	})
+
+	err := pterm.DefaultTable.WithHasHeader().WithBoxed().WithData(tableData).Render()
+	if err != nil {
+		fmt.Printf("Fehler beim Rendern der Tabelle: %s\n", err)
+	}
+
+}
+
+func parse_uart_client_info_payload(payloadBuffer []byte, payload_len int) {
+
+	type payload_data struct {
+		ClientID           uint8
+		IsAvailable        uint8
+		SlotIsUsed         uint8
+		MACAddr            [6]uint8
+		LastPing           uint32
+		LastSuccessfulPing uint32
+		Version            uint16
+	}
+
+	tableHeaders := pterm.TableData{
+		{"Client ID", "Verfügbar", "Genutzt", "MAC-Adresse", "Last Ping", "Letzter Erfolg Ping", "Version"},
+	}
+
+	tableData := tableHeaders
+
+	currentOffset := 2
+
+	const (
+		ENTRY_LEN                = 19
+		OFFSET_MAC_ADDR          = 3
+		OFFSET_LAST_PING         = 9
+		OFFSET_LAST_SUCCESS_PING = 13
+		OFFSET_VERSION           = 17
+	)
+
+	for i := 0; i < int(payloadBuffer[1]); i++ {
+		if currentOffset+ENTRY_LEN > payload_len {
+			fmt.Printf("Fehler: Payload zu kurz für Client-Eintrag %d\n", i)
+			break
+		}
+
+		entryBytes := payloadBuffer[currentOffset : currentOffset+ENTRY_LEN]
+
+		var clientData payload_data
+
+		clientData.ClientID = entryBytes[0]
+		clientData.IsAvailable = entryBytes[1]
+		clientData.SlotIsUsed = entryBytes[2]
+
+		copy(clientData.MACAddr[:], entryBytes[OFFSET_MAC_ADDR:OFFSET_MAC_ADDR+6])
+
+		clientData.LastPing = binary.LittleEndian.Uint32(entryBytes[OFFSET_LAST_PING : OFFSET_LAST_PING+4])
+		clientData.LastSuccessfulPing = binary.LittleEndian.Uint32(entryBytes[OFFSET_LAST_SUCCESS_PING : OFFSET_LAST_SUCCESS_PING+4])
+		clientData.Version = binary.LittleEndian.Uint16(entryBytes[OFFSET_VERSION : OFFSET_VERSION+2])
+
+		// Füge die geparsten Daten als String-Slice zur Tabelle hinzu
+		tableData = append(tableData, []string{
+			fmt.Sprintf("%d", clientData.ClientID),
+			fmt.Sprintf("%d", clientData.IsAvailable),
+			fmt.Sprintf("%d", clientData.SlotIsUsed),
+			fmt.Sprintf("%X:%X:%X:%X:%X:%X",
+				clientData.MACAddr[0], clientData.MACAddr[1], clientData.MACAddr[2],
+				clientData.MACAddr[3], clientData.MACAddr[4], clientData.MACAddr[5]),
+			fmt.Sprintf("%d", clientData.LastPing),
+			fmt.Sprintf("%d", clientData.LastSuccessfulPing),
+			fmt.Sprintf("%d", clientData.Version),
+		})
+
+		currentOffset += ENTRY_LEN
+	}
+	err := pterm.DefaultTable.WithHasHeader().WithBoxed().WithData(tableData).Render()
+	if err != nil {
+		fmt.Printf("Fehler beim Rendern der Tabelle: %s\n", err)
+	}
+}
+
+func message_receive_callback(mr MessageReceive) {
+	log.Printf("Message Received: % 02X\n", mr.raw_message[:mr.raw_write_index])
+	switch mr.parsed_message[0] {
+	case byte(UART_ECHO):
+		break
+	case UART_VERSION:
+		parse_uart_version_payload(mr.parsed_message, mr.write_index)
+		break
+	case UART_CLIENT_INFO:
+		parse_uart_client_info_payload(mr.parsed_message, mr.write_index)
+		break
+	case UART_OTA_START:
+		OTA_UpdateHandler.NewOTAMessage <- mr
+		break
+	case UART_OTA_PAYLOAD:
+		parse_uart_ota_payload_payload(mr.parsed_message, mr.write_index)
+		OTA_UpdateHandler.NewOTAMessage <- mr
+		break
+	case UART_OTA_END:
+		OTA_UpdateHandler.NewOTAMessage <- mr
+		break
+	case UART_OTA_STATUS:
+		OTA_UpdateHandler.NewOTAMessage <- mr
+		break
+	}
+}
+
+func message_receive_failed_callback(mr MessageReceive) {
+	log.Printf("Error Message Received: % 02X\n", mr.raw_message[:mr.raw_write_index])
+}
+
+func parseByte(mr *MessageReceive, pbyte byte) {
+	addByteToRawBuffer(mr, pbyte)
+	switch mr.state {
+	case WAITING_FOR_START_BYTE:
+		if pbyte == START_BYTE {
+			initMessageReceive(mr)
+			mr.state = GET_MESSAGE_ID
+			addByteToRawBuffer(mr, pbyte)
+		}
+		// ignore every other byte
+		break
+	case GET_MESSAGE_ID:
+		if pbyte == ESCAPE_BYTE {
+			mr.state = ESCAPED_MESSAGE_ID
+		} else {
+			addByteToParsedBuffer(mr, pbyte)
+			mr.state = IN_PAYLOD
+		}
+		break
+	case ESCAPED_MESSAGE_ID:
+		addByteToParsedBuffer(mr, pbyte)
+		mr.state = IN_PAYLOD
+		break
+	case IN_PAYLOD:
+		if pbyte == ESCAPE_BYTE {
+			mr.state = ESCAPED_PAYLOAD_BYTE
+			break
+		}
+		if pbyte == START_BYTE {
+			mr.error = UNEXPECETD_BYTE
+			go message_receive_failed_callback(*mr)
+			initMessageReceive(mr)
+			return
+		}
+		if pbyte == END_BYTE {
+			if mr.checksum != 0 { // checksum wrong
+				mr.error = WRONG_CHECKSUM
+				go message_receive_failed_callback(*mr)
+				initMessageReceive(mr)
+				return
+			}
+			go message_receive_callback(*mr)
+			initMessageReceive(mr)
+			break
+		}
+		// normal case
+		addByteToParsedBuffer(mr, pbyte)
+		break
+	case ESCAPED_PAYLOAD_BYTE:
+		addByteToParsedBuffer(mr, pbyte)
+		mr.state = IN_PAYLOD
+		break
+	default:
+		panic(fmt.Sprintf("unexpected main.ParserState: %#v", mr.state))
+	}
+}
+
+func buildMessage(payloadBuffer []byte, payload_len int, sendBuffer []byte) int {
+	var writeIndex int
+	checksum := byte(0x00)
+	writeIndex = 0
+	sendBuffer[writeIndex] = START_BYTE
+	writeIndex++
+	for i := range payload_len {
+		b := payloadBuffer[i]
+		if b == START_BYTE || b == ESCAPE_BYTE || b == END_BYTE {
+			sendBuffer[writeIndex] = ESCAPE_BYTE
+			writeIndex++
+		}
+		sendBuffer[writeIndex] = b
+		writeIndex++
+		checksum ^= b
+	}
+	if checksum == START_BYTE || checksum == ESCAPE_BYTE || checksum == END_BYTE {
+		sendBuffer[writeIndex] = ESCAPE_BYTE
+		writeIndex++
+	}
+	sendBuffer[writeIndex] = checksum
+	writeIndex++
+	sendBuffer[writeIndex] = END_BYTE
+	writeIndex++
+	return writeIndex
+}
+
+func sendMessage(port serial.Port, sendBuffer []byte) {
+	n, err := port.Write(sendBuffer)
+	if err != nil {
+		log.Printf("Could not Send %v to Serial Port", sendBuffer)
+	}
+	if n < len(sendBuffer) {
+		log.Printf("Did not send all data %v, only send %v", len(sendBuffer), n)
+	}
+	fmt.Printf("Send Message % 02X\n", sendBuffer[:n])
+}
+
+var (
+	updatePath        string
+	OTA_UpdateHandler OTASyncManager
+)
+
+func main() {
+	flag.StringVar(&updatePath, "update", "", "Path to Updatefile")
+	flag.Parse()
+
+	OTA_UpdateHandler = OTASyncManager{
+		OTA_MessageCounter:         0,
+		OTA_PayloadMessageSequence: 0,
+		NewOTAMessage:              make(chan MessageReceive),
+		TimeoutMessage:             time.Millisecond * 30000,
+	}
+
+	mode := &serial.Mode{
+		//BaudRate: 115200,
+		BaudRate: 921600,
+	}
+	port, err := serial.Open("/dev/ttyUSB0", mode)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	ctx, cancle := context.WithCancel(context.Background())
+	defer cancle()
+
+	go func() {
+		buff := make([]byte, 1024)
+		mr := MessageReceive{}
+		initMessageReceive(&mr)
+		for {
+			select {
+			case <-ctx.Done():
+				return
+			default:
+				n, err := port.Read(buff)
+				if err != nil {
+					log.Print(err)
+					break
+				}
+				if n == 0 {
+					fmt.Println("\nEOF")
+					break
+				}
+				for _, b := range buff[:n] {
+					parseByte(&mr, b)
+				}
+				//fmt.Printf("Empfangen: % 02X\n", string(buff[:n]))
+				break
+			}
+		}
+	}()
+
+	if updatePath != "" {
+		// start update
+		update, err := os.ReadFile(updatePath)
+		if err != nil {
+			log.Printf("Could not read Update file %v", err)
+			return
+		}
+		log.Printf("Update Buffer read, update size %v", len(update))
+		log.Printf("Gonna break it down in 200 Bytes packages will send %v packages", len(update)/200)
+
+		// start
+		payload_buffer := make([]byte, 1024)
+		send_buffer := make([]byte, 1024)
+		payload_buffer[0] = UART_OTA_START
+		n := buildMessage(payload_buffer, 1, send_buffer)
+		sendMessage(port, send_buffer[:n])
+		msg, err := OTA_UpdateHandler.WaitForNextMessageTimeout()
+		if err != nil {
+			log.Printf("Error Message not acked %v", err)
+		} else {
+			if msg.parsed_message[2] != 0x00 {
+				log.Printf("Update Start failed %v", msg.parsed_message[2])
+				return
+			} else {
+				log.Printf("Update Start confirmed Updating Partition %v", msg.parsed_message[1])
+			}
+		}
+
+		update_write_index := 0
+		// write update parts
+		for update_write_index < len(update) {
+			payload_buffer = make([]byte, 1024)
+			send_buffer = make([]byte, 1024)
+			payload_buffer[0] = UART_OTA_PAYLOAD
+
+			write_len := min(200, len(update)-update_write_index)
+
+			//end_payload_len := min(update_write_index+200, len(update))
+
+			copy(payload_buffer[1:write_len+1], update[update_write_index:update_write_index+write_len])
+			n = buildMessage(payload_buffer, write_len+1, send_buffer)
+			sendMessage(port, send_buffer[:n])
+			msg, err := OTA_UpdateHandler.WaitForNextMessageTimeout()
+			if err != nil {
+				log.Printf("Error Message not acked %v", err)
+				return
+			} else {
+				seqCounter := binary.LittleEndian.Uint16(msg.parsed_message[1:3])
+				buff_write_index := binary.LittleEndian.Uint16(msg.parsed_message[3:5])
+				log.Printf("Sequenzce Counter: %d, Update buffer Write Index: %d", seqCounter, buff_write_index)
+			}
+			update_write_index += 200
+		}
+
+		log.Printf("Update übertragen beende hier!!!")
+		// end
+		payload_buffer = make([]byte, 1024)
+		send_buffer = make([]byte, 1024)
+		payload_buffer[0] = UART_OTA_END
+		n = buildMessage(payload_buffer, 1, send_buffer)
+		sendMessage(port, send_buffer[:n])
+
+		_, err = OTA_UpdateHandler.WaitForNextMessageTimeout()
+		if err != nil {
+			log.Printf("Error Message not acked %v", err)
+			return
+		} else {
+			log.Printf("Message Waiting hat funktionioert")
+		}
+		return
+	}
+
+	for {
+		var input string
+		_, err := fmt.Scanln(&input)
+		if err != nil {
+			log.Fatalf("Could not read from stdin")
+		}
+		fmt.Printf("Input %v", input)
+
+		switch input {
+		case "q":
+			return
+		case "1":
+			payload_buffer := make([]byte, 1024)
+			send_buffer := make([]byte, 1024)
+			payload_buffer[0] = UART_ECHO
+			n := buildMessage(payload_buffer, 1, send_buffer)
+			sendMessage(port, send_buffer[:n])
+			break
+		case "2":
+			payload_buffer := make([]byte, 1024)
+			send_buffer := make([]byte, 1024)
+			payload_buffer[0] = UART_VERSION
+			n := buildMessage(payload_buffer, 1, send_buffer)
+			sendMessage(port, send_buffer[:n])
+			break
+		case "3":
+			payload_buffer := make([]byte, 1024)
+			send_buffer := make([]byte, 1024)
+			payload_buffer[0] = UART_CLIENT_INFO
+			n := buildMessage(payload_buffer, 1, send_buffer)
+			sendMessage(port, send_buffer[:n])
+			break
+		case "4": // start update
+			payload_buffer := make([]byte, 1024)
+			send_buffer := make([]byte, 1024)
+			payload_buffer[0] = UART_OTA_START
+			n := buildMessage(payload_buffer, 1, send_buffer)
+			sendMessage(port, send_buffer[:n])
+			break
+		case "5": // send payload
+			payload_buffer := make([]byte, 1024)
+			send_buffer := make([]byte, 1024)
+			payload_buffer[0] = UART_OTA_PAYLOAD
+			for i := range 200 {
+				payload_buffer[i+1] = byte(i)
+			}
+			n := buildMessage(payload_buffer, 201, send_buffer)
+			sendMessage(port, send_buffer[:n])
+			break
+		case "6": // end update
+		default:
+			fmt.Printf("Not a valid input")
+		}
+	}
+}

main/CMakeLists.txt

@@ -1,4 +1,4 @@
-idf_component_register(SRCS "main.c" "uart_handler.c" "communication_handler.c" "client_handler.c" "message_parser.c" "message_builder.c" "message_handler.c"
+idf_component_register(SRCS "main.c" "uart_handler.c" "communication_handler.c" "client_handler.c" "message_parser.c" "message_builder.c" "message_handler.c" "ota_update.c"
                        INCLUDE_DIRS ".")
 
 # Get the short Git commit hash of the current HEAD.

main/client_handler.h

@@ -1,7 +1,7 @@
 #ifndef CLIENT_HANDLER_H
 #define CLIENT_HANDLER_H
 
-#include "portmacro.h"
+#include "freertos/FreeRTOS.h"
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
@@ -28,6 +28,7 @@ typedef struct {
   uint8_t macAddr[MAC_LENGTH];
   TickType_t lastSuccessfullPing;
   TickType_t lastPing;
+  uint16_t clientVersion;
 } ClientInfo;
 
 typedef struct {

main/communication_handler.c

@@ -1,3 +1,4 @@
+#include "esp_err.h"
 #include "esp_log.h"
 #include "esp_now.h"
 #include "esp_timer.h"
@@ -8,41 +9,129 @@
 #include <stdbool.h>
 #include <stdint.h>
 #include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
 
 static const char *TAG = "ALOX - COM";
 
+static struct ESP_MessageBroker mr;
+static QueueHandle_t ESP_recieved_message_queue;
+
+void free_ESPNOW_MessageInfo(ESPNOW_MessageInfo *msg) {
+  if (msg->esp_now_info.src_addr) {
+    free(msg->esp_now_info.src_addr);
+    msg->esp_now_info.src_addr = NULL;
+  }
+  if (msg->esp_now_info.des_addr) {
+    free(msg->esp_now_info.des_addr);
+    msg->esp_now_info.des_addr = NULL;
+  }
+  if (msg->esp_now_info.rx_ctrl) {
+    free(msg->esp_now_info.rx_ctrl);
+    msg->esp_now_info.rx_ctrl = NULL;
+  }
+  if (msg->data) {
+    free(msg->data);
+    msg->data = NULL;
+  }
+}
+
+void ESP_InitMessageBroker(QueueHandle_t msg_queue_handle) {
+  mr.num_direct_callbacks = 0;
+  mr.num_task_callbacks = 0;
+  ESP_recieved_message_queue = msg_queue_handle;
+  return;
+}
+
+void ESP_RegisterFunction(CommandPages command,
+                          ESP_RegisterFunctionCallback callback) {
+  mr.FunctionList[mr.num_direct_callbacks].MSGID = command;
+  mr.FunctionList[mr.num_direct_callbacks].callback = callback;
+  mr.num_direct_callbacks++;
+  return;
+}
+
+void ESP_RegisterTask(CommandPages command, ESP_RegisterTaskCallback callback) {
+  mr.TaskList[mr.num_task_callbacks].MSGID = command;
+  mr.TaskList[mr.num_task_callbacks].task = callback;
+  mr.num_task_callbacks++;
+}
+
+void ESP_MessageBrokerTask(void *param) {
+  ESPNOW_MessageInfo received_msg;
+  ESP_MessageBrokerTaskParams_t *task_params =
+      (ESP_MessageBrokerTaskParams_t *)param;
+
+  // Extrahiere die einzelnen Parameter
+  QueueHandle_t msg_queue = task_params->message_queue;
+
+  if (msg_queue == NULL) {
+    ESP_LOGE(TAG, "Message queue not initialized. Terminating task.");
+    vTaskDelete(NULL);
+  }
+
+  ESP_LOGI(TAG, "Message broker task started.");
+
+  while (1) {
+    if (xQueueReceive(msg_queue, &received_msg, portMAX_DELAY)) {
+
+      ESP_LOGI(TAG, "Broker got message trying to relay it now");
+      const BaseMessage *message = (const BaseMessage *)received_msg.data;
+      ESP_LOGI(TAG, "Broker searching for command page %d",
+               message->commandPage);
+      for (int i = 0; i < mr.num_direct_callbacks;
+           i++) { // TODO: there should not be a loop needed here
+        if (mr.FunctionList[i].MSGID == message->commandPage) {
+          mr.FunctionList[i].callback(&received_msg.esp_now_info,
+                                      received_msg.data, received_msg.data_len);
+          ESP_LOGI(TAG, "Broker found matching msgid %d",
+                   mr.FunctionList[i].MSGID);
+          free_ESPNOW_MessageInfo(&received_msg);
+        }
+      }
+      for (int i = 0; i < mr.num_direct_callbacks; i++) {
+        // if (mr.FunctionList[i].MSGID == received_msg.msgid) {
+        //  TODO: Not yet implemented
+        //  Only send data to task, task should be created beforhead and wait
+        //  for new data in the queue.
+        //}
+      }
+    }
+  }
+}
+
 QueueHandle_t messageQueue = NULL; // Warteschlange für empfangene Nachrichten
-bool hasMaster = false;
+static bool hasMaster = false;
 static ClientList *esp_client_list;
+static uint8_t channelNumber = 0;
 
 #define MAC_STRING_BUFFER_SIZE 18
 
-void init_com(ClientList *clients) {
+int init_com(ClientList *clients, uint8_t wifi_channel) {
   // Initialisiere die Kommunikations-Warteschlange
-  messageQueue = xQueueCreate(MESSAGE_QUEUE_SIZE, sizeof(BaseMessage));
+  messageQueue = xQueueCreate(MESSAGE_QUEUE_SIZE, sizeof(ESPNOW_MessageInfo));
   if (messageQueue == NULL) {
     ESP_LOGE(TAG, "Message queue creation failed");
+    return -1;
   }
 
   esp_client_list = clients;
   hasMaster = false;
+  channelNumber = wifi_channel;
+  return 0;
 }
 
-void add_peer(uint8_t *macAddr) {
+int add_peer(uint8_t *macAddr) {
   esp_now_peer_info_t peerInfo = {
-      .channel =
-          0, // Standardkanal, sollte uit den anderen Geräten übereinstimmen
+      .channel = channelNumber,
       .ifidx = ESP_IF_WIFI_STA,
-      .encrypt = false, // Keine Verschlüsselung (kann geändert werden)
+      .encrypt = false, // Keine Verschlüsselung // TODO: should be changed
   };
   memcpy(peerInfo.peer_addr, macAddr, ESP_NOW_ETH_ALEN);
 
   esp_err_t result = esp_now_add_peer(&peerInfo);
   if (result == ESP_OK) {
-    ESP_LOGI(TAG, "Peer added: %02X:%02X:%02X:%02X:%02X:%02X",
-             peerInfo.peer_addr[0], peerInfo.peer_addr[1],
-             peerInfo.peer_addr[2], peerInfo.peer_addr[3],
-             peerInfo.peer_addr[4], peerInfo.peer_addr[5]);
+    ESP_LOGI(TAG, "Peer added: " MACSTR, MAC2STR(peerInfo.peer_addr));
 
     if (!IS_BROADCAST_ADDR(macAddr)) {
       int ret = add_client(esp_client_list, peerInfo.peer_addr);
@@ -50,6 +139,7 @@ void add_peer(uint8_t *macAddr) {
         ESP_LOGE(TAG, "Client could not be added to client handler, removing "
                       "it from esp now client list!");
         esp_now_del_peer(peerInfo.peer_addr);
+        return -1;
       }
       ESP_LOGI(TAG, "New client added.");
     }
@@ -62,25 +152,20 @@ void add_peer(uint8_t *macAddr) {
     }
   } else {
     ESP_LOGE(TAG, "Failed to add peer: %s", esp_err_to_name(result));
+    return -1;
   }
-}
-
-void MACtoString(const uint8_t *macAddr, char *outputBuffer) {
-  sprintf(outputBuffer, "%02X:%02X:%02X:%02X:%02X:%02X", macAddr[0], macAddr[1],
-          macAddr[2], macAddr[3], macAddr[4], macAddr[5]);
+  return 0;
 }
 
 BaseMessage MessageBuilder(CommandPages commandPage, PayloadUnion payload,
                            size_t payload_size) {
   BaseMessage message;
 
-  // Initialisierung der BaseMessage
   message.commandPage = commandPage;
   message.version = 1;
   message.length = (uint16_t)payload_size;
 
-  // Kopieren des Payloads in die Union
-  memset(&message.payload, 0, sizeof(message.payload)); // Sicherheitsmaßnahme
+  memset(&message.payload, 0, sizeof(message.payload));
   memcpy(&message.payload, &payload, payload_size);
 
   return message;
@@ -95,32 +180,31 @@ void master_broadcast_task(void *param) {
 
     ESP_ERROR_CHECK(esp_now_send(broadcast_address, (uint8_t *)&message,
                                  sizeof(BaseMessage)));
-    ESP_LOGI(TAG, "Broadcast Message sent");
+
+    // ESP_LOGI(TAG, "Broadcast Message sent");
     vTaskDelay(pdMS_TO_TICKS(5000));
   }
 }
 
 void master_broadcast_ping(void *param) {
   while (1) {
-    // BroadCastPayload payload = {};
     PingPayload payload = {};
     payload.timestamp = esp_timer_get_time();
     BaseMessage message =
         MessageBuilder(PingPage, *(PayloadUnion *)&payload, sizeof(payload));
     ESP_ERROR_CHECK(esp_now_send(broadcast_address, (uint8_t *)&message,
                                  sizeof(BaseMessage)));
-    ESP_LOGI(TAG, "Broadcast PING Message sent");
+    // ESP_LOGI(TAG, "Broadcast PING Message sent");
     vTaskDelay(pdMS_TO_TICKS(2500));
   }
 }
 
 void master_ping_task(void *param) {
-  char macBuffer[MAC_STRING_BUFFER_SIZE];
   while (1) {
     for (size_t i = 0; i < MAX_CLIENTS; i++) {
       if (esp_client_list->Clients[i].isAvailable) {
-        MACtoString(esp_client_list->Clients[i].macAddr, macBuffer);
-        ESP_LOGI(TAG, "SEND PING TO %zu: %s", i, macBuffer);
+        ESP_LOGI(TAG, "SEND PING TO %zu: " MACSTR, i,
+                 MAC2STR(esp_client_list->Clients[i].macAddr));
         PingPayload payload = {};
         payload.timestamp = esp_timer_get_time();
         BaseMessage message = MessageBuilder(
@@ -134,153 +218,264 @@ void master_ping_task(void *param) {
   }
 }
 
-void master_receive_callback(const esp_now_recv_info_t *esp_now_info,
-                             const uint8_t *data, int data_len) {
-  char macBuffer[MAC_STRING_BUFFER_SIZE];
-  ESP_LOGI(TAG, "MASTER GOT MESSAGE");
-
+void master_StatusCallback(const esp_now_recv_info_t *esp_now_info,
+                           const uint8_t *data, int data_len) {
   const BaseMessage *message = (const BaseMessage *)data;
-  switch (message->commandPage) {
-  case StatusPage:
-    ESP_LOGI(TAG, "GOT STATUS MESSAGE");
-    break;
-  case PingPage:
-    ESP_LOGI(TAG, "GOT PING MESSAGE");
-    uint32_t currentTime = esp_timer_get_time();
-    uint32_t diff = currentTime - message->payload.ping_payload.timestamp;
 
-    ESP_LOGI(TAG, "Start: %lu, End: %lu, Diff: %lu, Ping: %lu",
-             message->payload.ping_payload.timestamp, currentTime, diff,
-             diff / 1000); // ping in ms
+  ESP_LOGI(TAG, "SRC " MACSTR, MAC2STR(esp_now_info->src_addr));
+  ESP_LOGI(TAG,
+           "Status Message Received: status: %d, runningPartition: %d, uptime: "
+           "%d, version: %d",
+           message->payload.status_payload.status,
+           message->payload.status_payload.runningPartition,
+           message->payload.status_payload.uptime,
+           message->payload.status_payload.version);
+}
 
+void master_RegisterCallback(const esp_now_recv_info_t *esp_now_info,
+                             const uint8_t *data, int data_len) {
+  BaseMessage replyMessage = {};
+  const BaseMessage *message = (const BaseMessage *)data;
+
+  ESP_LOGI(TAG, "WILL REGISTER DEVICE");
+  esp_now_peer_info_t checkPeerInfo;
+  esp_err_t checkPeer =
+      esp_now_get_peer(esp_now_info->src_addr, &checkPeerInfo);
+  switch (checkPeer) {
+  case (ESP_OK):
+    ESP_LOGI(TAG, "CLIENT BEKANNT");
     int id = get_client_id(esp_client_list, esp_now_info->src_addr);
-    if (id >= 0) {
-      esp_client_list->Clients[id].lastSuccessfullPing = xTaskGetTickCount();
-      esp_client_list->Clients[id].lastPing = (diff / 1000);
-      MACtoString(esp_now_info->src_addr, macBuffer);
-      ESP_LOGI(TAG, "Updated client %d: %s last ping time to %lu", id,
-               macBuffer, esp_client_list->Clients[id].lastSuccessfullPing);
-    }
+    esp_client_list->Clients[id].isAvailable = true;
+    esp_client_list->Clients[id].lastSuccessfullPing = xTaskGetTickCount();
+    ESP_LOGI(TAG, "Updated client %d last ping time to %lu", id,
+             esp_client_list->Clients[id].lastSuccessfullPing);
     break;
-  case BroadCastPage:
-    ESP_LOGI(TAG, "MASTER SHOULD NOT GET BROADCAST MESSAGE, is there another "
-                  "master calling?");
+  case (ESP_ERR_ESPNOW_NOT_INIT):
+    ESP_LOGI(TAG, "Not initalised");
     break;
-  case RegisterPage:
-    ESP_LOGI(TAG, "WILL REGISTER DEVICE");
-    esp_now_peer_info_t checkPeerInfo;
-    esp_err_t checkPeer =
-        esp_now_get_peer(esp_now_info->src_addr, &checkPeerInfo);
-    switch (checkPeer) {
-    case (ESP_OK):
-      ESP_LOGI(TAG, "CLIENT BEKANNT");
-      int id = get_client_id(esp_client_list, esp_now_info->src_addr);
-      esp_client_list->Clients[id].isAvailable = true;
-      esp_client_list->Clients[id].lastSuccessfullPing = xTaskGetTickCount();
-      ESP_LOGI(TAG, "Updated client %d last ping time to %lu", id,
-               esp_client_list->Clients[id].lastSuccessfullPing);
-      break;
-    case (ESP_ERR_ESPNOW_NOT_INIT):
-      ESP_LOGI(TAG, "Not initalised");
-      break;
-    case (ESP_ERR_ESPNOW_ARG):
-      ESP_LOGI(TAG, "ESP ERR ESPNOW_ARG");
-      break;
-    case (ESP_ERR_ESPNOW_NOT_FOUND):
-      ESP_LOGI(TAG, "CLIENT WIRD IN DIE LISTE AUFGENOMMEN");
-      add_peer(esp_now_info->src_addr);
-      break;
-    default:
-      ESP_LOGI(TAG, "Unknown Message %i", checkPeer);
+  case (ESP_ERR_ESPNOW_ARG):
+    ESP_LOGI(TAG, "ESP ERR ESPNOW_ARG");
+    break;
+  case (ESP_ERR_ESPNOW_NOT_FOUND):
+    ESP_LOGI(TAG, "CLIENT WIRD IN DIE LISTE AUFGENOMMEN " MACSTR,
+             MAC2STR(esp_now_info->src_addr));
+    int peer_err = add_peer(esp_now_info->src_addr);
+    if (peer_err < 0) {
+      ESP_LOGE(TAG, "Could not add ESP TO ClientList %d", peer_err);
     }
+    ESP_LOGI(TAG, "FRAGE CLIENT STATUS AN");
+
+    GetStatusPayload payload = {};
+    replyMessage = MessageBuilder(GetStatusPage, *(PayloadUnion *)&payload,
+                                  sizeof(payload));
+    esp_err_t err = esp_now_send(esp_now_info->src_addr,
+                                 (uint8_t *)&replyMessage, sizeof(BaseMessage));
+    if (err != ESP_OK) {
+      ESP_LOGE(TAG, "Could not send Message Error %s", esp_err_to_name(err));
+    }
+
     break;
   default:
-    ESP_LOGI(TAG, "Unknown CommandPage %i", message->commandPage);
-    break;
+    ESP_LOGI(TAG, "Unknown Message %i", checkPeer);
   }
 }
-void client_receive_callback(const esp_now_recv_info_t *esp_now_info,
+
+void master_pingCallback(const esp_now_recv_info_t *esp_now_info,
+                         const uint8_t *data, int data_len) {
+  BaseMessage replyMessage = {};
+  const BaseMessage *message = (const BaseMessage *)data;
+
+  ESP_LOGI(TAG, "GOT PING MESSAGE");
+  uint32_t currentTime = esp_timer_get_time();
+  uint32_t diff = currentTime - message->payload.ping_payload.timestamp;
+
+  ESP_LOGI(TAG, "Start: %lu, End: %lu, Diff: %lu, Ping: %lu",
+           message->payload.ping_payload.timestamp, currentTime, diff,
+           diff / 1000); // ping in ms
+
+  int id = get_client_id(esp_client_list, esp_now_info->src_addr);
+  if (id >= 0) {
+    esp_client_list->Clients[id].lastSuccessfullPing = xTaskGetTickCount();
+    esp_client_list->Clients[id].lastPing = (diff / 1000);
+    ESP_LOGI(TAG, "Updated client %d: " MACSTR " last ping time to %lu", id,
+             MAC2STR(esp_now_info->src_addr),
+             esp_client_list->Clients[id].lastSuccessfullPing);
+  }
+}
+
+void master_broadcastCallback(const esp_now_recv_info_t *esp_now_info,
+                              const uint8_t *data, int data_len) {
+  ESP_LOGI(TAG,
+           "Master should not recieve Broadcast is there another master "
+           "Calling got message from " MACSTR,
+           MAC2STR(esp_now_info->src_addr));
+}
+
+void ESPNOW_RegisterMasterCallbacks() {
+  ESP_RegisterFunction(StatusPage, master_StatusCallback);
+  ESP_RegisterFunction(RegisterPage, master_RegisterCallback);
+  ESP_RegisterFunction(PingPage, master_pingCallback);
+  ESP_RegisterFunction(BroadCastPage, master_broadcastCallback);
+}
+
+void slave_broadcastCallback(const esp_now_recv_info_t *esp_now_info,
                              const uint8_t *data, int data_len) {
-  char macBuffer[MAC_STRING_BUFFER_SIZE];
-  ESP_LOGI(TAG, "SLAVE GOT MESSAGE");
-  MACtoString(esp_now_info->src_addr, macBuffer);
-  ESP_LOGI(TAG, "Received message from: %s", macBuffer);
-  ESP_LOGI(TAG, "Message: %.*s", data_len, data);
+  BaseMessage replyMessage = {};
+  const BaseMessage *message = (const BaseMessage *)data;
+
+  ESP_LOGI(TAG, "GOT BROADCAST MESSAGE");
+  if (!hasMaster) {
+    if (IS_BROADCAST_ADDR(esp_now_info->des_addr)) {
+      ESP_LOGI(TAG, "GOT BROADCAST MESSAGE ATTEMPTING TO REGISTER TO MASTER!");
+      add_peer(esp_now_info->src_addr);
+      replyMessage =
+          MessageBuilder(RegisterPage, *(PayloadUnion *)&message->payload,
+                         sizeof(message->payload));
+      ESP_ERROR_CHECK(esp_now_send(esp_now_info->src_addr,
+                                   (uint8_t *)&replyMessage,
+                                   sizeof(BaseMessage)));
+      hasMaster = true;
+    }
+  } else {
+    ESP_LOGI(TAG, "Already have master wont register by the new one");
+  }
+}
+void slave_getstatusCallback(const esp_now_recv_info_t *esp_now_info,
+                             const uint8_t *data, int data_len) {
+  BaseMessage replyMessage = {};
+  const BaseMessage *message = (const BaseMessage *)data;
+
+  StatusPayload payload = {
+      .status = 1,
+      .runningPartition = 1,
+      .uptime = 100,
+      .version = 0x0002,
+
+  };
+  replyMessage =
+      MessageBuilder(StatusPage, *(PayloadUnion *)&payload, sizeof(payload));
+  ESP_ERROR_CHECK(esp_now_send(esp_now_info->src_addr, (uint8_t *)&replyMessage,
+                               sizeof(BaseMessage)));
+}
+void slave_pingCallback(const esp_now_recv_info_t *esp_now_info,
+                        const uint8_t *data, int data_len) {
+  if (!hasMaster)
+    return;
 
   BaseMessage replyMessage = {};
-
   const BaseMessage *message = (const BaseMessage *)data;
-  switch (message->commandPage) {
-  case StatusPage:
-    ESP_LOGI(TAG, "GOT STATUS MESSAGE");
-    break;
-  case PingPage:
-    ESP_LOGI(TAG, "GOT PING MESSAGE");
-    replyMessage = MessageBuilder(PingPage, *(PayloadUnion *)&message->payload,
-                                  sizeof(message->payload));
-    ESP_ERROR_CHECK(esp_now_send(
-        esp_now_info->src_addr, (uint8_t *)&replyMessage, sizeof(BaseMessage)));
-    break;
-  case BroadCastPage:
-    ESP_LOGI(TAG, "GOT BROADCAST MESSAGE");
-    if (!hasMaster) {
-      if (IS_BROADCAST_ADDR(esp_now_info->des_addr)) {
-        ESP_LOGI(TAG,
-                 "GOT BROADCAST MESSAGE ATTEMPTING TO REGISTER TO MASTER!");
-        add_peer(esp_now_info->src_addr);
-        replyMessage =
-            MessageBuilder(RegisterPage, *(PayloadUnion *)&message->payload,
-                           sizeof(message->payload));
-        ESP_ERROR_CHECK(esp_now_send(esp_now_info->src_addr,
-                                     (uint8_t *)&replyMessage,
-                                     sizeof(BaseMessage)));
-        hasMaster = true;
-      }
-    }
-    break;
-  case RegisterPage:
-    break;
-  default:
-    ESP_LOGI(TAG, "GOT UNKONW MESSAGE");
-    break;
+
+  ESP_LOGI(TAG, "GOT PING MESSAGE");
+  replyMessage = MessageBuilder(PingPage, *(PayloadUnion *)&message->payload,
+                                sizeof(message->payload));
+  ESP_ERROR_CHECK(esp_now_send(esp_now_info->src_addr, (uint8_t *)&replyMessage,
+                               sizeof(BaseMessage)));
+}
+
+void ESPNOW_RegisterSlaveCallbacks() {
+  ESP_RegisterFunction(BroadCastPage, slave_broadcastCallback);
+  ESP_RegisterFunction(GetStatusPage, slave_getstatusCallback);
+  ESP_RegisterFunction(PingPage, slave_pingCallback);
+}
+
+void master_receive_callback(const esp_now_recv_info_t *esp_now_info,
+                             const uint8_t *data, int data_len) {
+  ESP_LOGI(TAG, "MASTER GOT MESSAGE");
+
+  // Allokiere Speicher für die Daten und kopiere sie
+  uint8_t *copied_data = (uint8_t *)malloc(data_len);
+  if (copied_data == NULL) {
+    ESP_LOGE(TAG, "Failed to allocate memory for message data.");
+    return;
   }
+  memcpy(copied_data, data, data_len);
+
+  // Fülle die neue Struktur mit kopierten Daten
+  ESPNOW_MessageInfo msg_info;
+  msg_info.esp_now_info.src_addr = malloc(6);
+  if (msg_info.esp_now_info.src_addr) {
+    memcpy(msg_info.esp_now_info.src_addr, esp_now_info->src_addr, 6);
+  }
+
+  // Speicher für des_addr kopieren
+  msg_info.esp_now_info.des_addr = malloc(6);
+  if (msg_info.esp_now_info.des_addr) {
+    memcpy(msg_info.esp_now_info.des_addr, esp_now_info->des_addr, 6);
+  }
+
+  // rx_ctrl Struktur kopieren
+  msg_info.esp_now_info.rx_ctrl = malloc(sizeof(wifi_pkt_rx_ctrl_t));
+  if (msg_info.esp_now_info.rx_ctrl) {
+    memcpy(msg_info.esp_now_info.rx_ctrl, esp_now_info->rx_ctrl,
+           sizeof(wifi_pkt_rx_ctrl_t));
+  }
+
+  msg_info.data = copied_data;
+  msg_info.data_len = data_len;
+
+  if (xQueueSend(ESP_recieved_message_queue, &msg_info, portMAX_DELAY) !=
+      pdPASS) {
+    // Fehlerbehandlung: Queue voll oder Senden fehlgeschlagen
+    ESP_LOGE(TAG, "Failed to send parsed message to queue.");
+  }
+  return;
+}
+
+void client_receive_callback(const esp_now_recv_info_t *esp_now_info,
+                             const uint8_t *data, int data_len) {
+  ESP_LOGI(TAG, "SLAVE GOT MESSAGE");
+  ESP_LOGI(TAG, "Received message from: " MACSTR,
+           MAC2STR(esp_now_info->src_addr));
+
+  uint8_t *copied_data = (uint8_t *)malloc(data_len);
+  if (copied_data == NULL) {
+    ESP_LOGE(TAG, "Failed to allocate memory for message data.");
+    return;
+  }
+  memcpy(copied_data, data, data_len);
+
+  // Fülle die neue Struktur mit kopierten Daten
+  ESPNOW_MessageInfo msg_info;
+  memcpy(&msg_info.esp_now_info, esp_now_info, sizeof(esp_now_recv_info_t));
+  msg_info.data = copied_data;
+  msg_info.data_len = data_len;
+
+  if (xQueueSend(ESP_recieved_message_queue, &msg_info, portMAX_DELAY) !=
+      pdPASS) {
+    // Fehlerbehandlung: Queue voll oder Senden fehlgeschlagen
+    ESP_LOGE(TAG, "Failed to send parsed message to queue.");
+  }
+  return;
 }
 
 void client_data_sending_task(void *param) {
   while (1) {
     const char *dataToSend = "DATA:42";
     ESP_LOGI(TAG, "SEND DATA");
-    esp_now_send(NULL, (uint8_t *)dataToSend,
-                 strlen(dataToSend)); // Sende Daten an Master
+    esp_now_send(NULL, (uint8_t *)dataToSend, strlen(dataToSend));
     vTaskDelay(pdMS_TO_TICKS(5000));
   }
 }
 
 void client_monitor_task(void *pvParameters) {
-  char macBuffer[MAC_STRING_BUFFER_SIZE];
-  TickType_t timeout_ticks =
-      pdMS_TO_TICKS(CLIENT_TIMEOUT_MS); // Timeout in Ticks
-  TickType_t interval_ticks =
-      pdMS_TO_TICKS(CHECK_INTERVAL_MS); // Prüfintervall in Ticks
+  TickType_t timeout_ticks = pdMS_TO_TICKS(CLIENT_TIMEOUT_MS);
+  TickType_t interval_ticks = pdMS_TO_TICKS(CHECK_INTERVAL_MS);
 
   while (1) {
-    TickType_t now = xTaskGetTickCount(); // Aktuelle Zeit in Ticks
+    TickType_t now = xTaskGetTickCount();
 
     for (int i = 0; i < MAX_CLIENTS; i++) {
       if (esp_client_list->Clients[i].isAvailable) {
         TickType_t time_diff =
             now - esp_client_list->Clients[i].lastSuccessfullPing;
 
-        // Prüfen, ob der Client als "nicht verfügbar" markiert werden soll
         if (time_diff > timeout_ticks) {
           esp_client_list->Clients[i].isAvailable = false;
-          MACtoString(esp_client_list->Clients[i].macAddr, macBuffer);
-          ESP_LOGW(TAG, "Client %d (MAC: %s) is unavailable", macBuffer);
+          ESP_LOGW(TAG, "Client %d (MAC: " MACSTR ") is unavailable",
+                   MAC2STR(esp_client_list->Clients[i].macAddr));
         }
       }
     }
-
-    // Task für das Prüfintervall anhalten
     vTaskDelay(interval_ticks);
   }
 }

main/communication_handler.h

@@ -11,6 +11,7 @@
 #include <stdint.h>
 #include <stdio.h>
 #include <string.h>
+#include <sys/types.h>
 
 #define BROADCAST_INTERVAL_MS 500
 
@@ -21,40 +22,92 @@ static uint8_t broadcast_address[ESP_NOW_ETH_ALEN] = {0xFF, 0xFF, 0xFF,
 #define IS_BROADCAST_ADDR(addr)                                                \
   (memcmp(addr, broadcast_address, ESP_NOW_ETH_ALEN) == 0)
 
+#define MAC2STR(a) (a)[0], (a)[1], (a)[2], (a)[3], (a)[4], (a)[5]
+#define MACSTR "%02X:%02X:%02X:%02X:%02X:%02X"
+
 #define MESSAGE_QUEUE_SIZE 10
 
 typedef enum {
-  BroadCastPage,
+  OTA_PREP_UPGRADE,
+  OTA_SEND_PAYLOAD,
+  OTA_WRITE_UPDATE_BUFFER,
+  OTA_SEND_MISSING,
+  OTA_UPDATE_INFO,
+  OTA_END_UPGRADE,
   StatusPage,
+  GetStatusPage,
+  ConfigPage,
   PingPage,
+  BroadCastPage,
   RegisterPage,
 } CommandPages;
 
-typedef struct {
-  uint32_t uptime;
+typedef struct __attribute__((packed)) {
+
+} OTA_PREP_UPGRADE_Payload;
+
+typedef struct __attribute__((packed)) {
+} OTA_SEND_PAYLOAD_Payload;
+typedef struct __attribute__((packed)) {
+} OTA_WRITE_UPDATE_BUFFER_Payload;
+typedef struct __attribute__((packed)) {
+} OTA_SEND_MISSING_Payload;
+typedef struct __attribute__((packed)) {
+} OTA_UPDATE_INFO_Payload;
+typedef struct __attribute__((packed)) {
+} OTA_END_UPGRADE_Payload;
+
+typedef struct __attribute__((packed)) {
+  uint16_t version; // software version
+  uint8_t runningPartition;
   uint8_t status;
+  uint32_t uptime;
 } StatusPayload;
 
-typedef struct {
+typedef struct __attribute__((packed)) {
+} GetStatusPayload;
+
+typedef struct __attribute__((packed)) {
+  uint8_t timeslot;
+} ConfigPayload;
+
+typedef struct __attribute__((packed)) {
   uint32_t timestamp;
 } PingPayload;
 
-typedef struct {
+typedef struct __attribute__((packed)) {
 } BroadCastPayload;
 
-typedef struct {
+typedef struct __attribute__((packed)) {
   bool familierClient;
 } RegisterPayload;
 
-typedef union {
+// TODO: Check checksum fields
+typedef struct __attribute__((packed)) {
+  uint16_t length;  // length of complete firmware
+  uint8_t checksum; // checksum of firmware
+} FirmwarePrepPayload;
+
+// TODO: Check checksum fields
+typedef struct __attribute__((packed)) {
+  uint8_t length;
+  uint8_t checksum;
+  uint32_t address;
+  uint8_t payload[240]; // TODO: need a way to figure out a safe value for this
+} FirmwarePayload;
+
+typedef union __attribute__((packed)) {
   StatusPayload status_payload;
+  ConfigPayload config_payload;
   PingPayload ping_payload;
   BroadCastPayload broadcast_payload;
   RegisterPayload register_payload;
+  FirmwarePrepPayload firmware_prep_payload;
+  FirmwarePayload firmware_payload;
 } PayloadUnion;
 
-typedef struct {
-  uint16_t version;
+typedef struct __attribute__((packed)) {
+  uint16_t version; // protcol version
   CommandPages commandPage;
   uint16_t length;
   PayloadUnion payload;
@@ -63,10 +116,50 @@ typedef struct {
 static_assert(sizeof(BaseMessage) <= 255,
               "BaseMessage darf nicht größer als 255 sein");
 
-void init_com(ClientList *clients);
+typedef void (*ESP_RegisterFunctionCallback)(
+    const esp_now_recv_info_t *esp_now_info, const uint8_t *data, int data_len);
+typedef void (*ESP_RegisterTaskCallback)(
+    const esp_now_recv_info_t *esp_now_info, const uint8_t *data, int data_len);
+
+struct ESP_RegisterdFunction {
+  CommandPages MSGID;
+  ESP_RegisterFunctionCallback callback;
+};
+
+struct ESP_RegisterdTask {
+  CommandPages MSGID;
+  ESP_RegisterTaskCallback task;
+};
+
+struct ESP_MessageBroker {
+  struct ESP_RegisterdFunction FunctionList[64];
+  uint8_t num_direct_callbacks;
+  struct ESP_RegisterdTask TaskList[64];
+  uint8_t num_task_callbacks;
+};
+
+typedef struct {
+  QueueHandle_t message_queue;
+} ESP_MessageBrokerTaskParams_t;
+
+typedef struct {
+  esp_now_recv_info_t esp_now_info;
+  uint8_t *data;
+  int data_len;
+} ESPNOW_MessageInfo;
+
+void ESP_InitMessageBroker(QueueHandle_t msg_queue_handle);
+void ESP_RegisterFunction(CommandPages command,
+                          ESP_RegisterFunctionCallback callback);
+void ESP_RegisterTask(CommandPages command, ESP_RegisterTaskCallback callback);
+void ESP_MessageBrokerTask(void *param);
+
+void ESPNOW_RegisterMasterCallbacks();
+void ESPNOW_RegisterSlaveCallbacks();
+
+int init_com(ClientList *clients, uint8_t wifi_channel);
 int getNextFreeClientId();
-void add_peer(uint8_t *macAddr);
-void MACtoString(const uint8_t *macAddr, char *outputBuffer);
+int add_peer(uint8_t *macAddr);
 BaseMessage MessageBuilder(CommandPages commandPage, PayloadUnion payload,
                            size_t payload_size);
 
@@ -79,6 +172,7 @@ void master_receive_callback(const esp_now_recv_info_t *esp_now_info,
 void client_receive_callback(const esp_now_recv_info_t *esp_now_info,
                              const uint8_t *data, int data_len);
 void client_data_sending_task(void *param);
+void client_send_random_data_task(void *param);
 void client_monitor_task(void *pvParameters);
 
 #endif

main/main.c

@@ -1,7 +1,11 @@
 #include "client_handler.h"
 #include "driver/gpio.h"
 #include "driver/uart.h"
+#include "esp_err.h"
 #include "esp_log.h"
+#include "esp_log_buffer.h"
+#include "esp_ota_ops.h"
+#include "esp_partition.h"
 #include "esp_phy_init.h"
 #include "esp_rom_gpio.h"
 #include "esp_timer.h"
@@ -10,12 +14,12 @@
 #include "hal/uart_types.h"
 #include "message_handler.h"
 #include "message_parser.h"
+#include "nvs.h"
 #include "nvs_flash.h"
 
-#include "glob.h"
 #include "communication_handler.h"
 #include "main.h"
-#include "portmacro.h"
+#include "ota_update.h"
 #include "uart_handler.h"
 #include <stdbool.h>
 #include <stddef.h>
@@ -24,30 +28,24 @@
 #include <sys/types.h>
 
 #include "message_builder.h"
-
-typedef struct {
-  QueueHandle_t message_queue;
-  uint8_t *send_buffer;
-  size_t send_buffer_size;
-} MessageBrokerTaskParams_t;
+#include "uart_msg_ids.h"
 
 static const char *TAG = "ALOX - MAIN";
 static const uint16_t version = 0x0001;
 static uint8_t send_message_buffer[1024];
+static uint8_t send_message_payload_buffer[512];
+
 static MessageBrokerTaskParams_t broker_task_params;
+static ESP_MessageBrokerTaskParams_t esp_broker_task_params;
 
 ClientList clientList = {.Clients = {{0}}, .ClientCount = 0};
 
-typedef void (*RegisterTaskCallback)(uint8_t msgid, const uint8_t *payload,
-                                     size_t payload_len, uint8_t *send_buffer,
-                                     size_t send_buffer_size);
-
 void echoCallback(uint8_t msgid, const uint8_t *payload, size_t payload_len,
+                  uint8_t *send_payload_buffer, size_t send_payload_buffer_size,
                   uint8_t *send_buffer, size_t send_buffer_size) {
-  // Code für den Button-Press
   ESP_LOGI(TAG, "Echo command 0x01...");
-  int len =
-      build_message(0x01, payload, payload_len, send_buffer, send_buffer_size);
+  int len = build_message(UART_ECHO, payload, payload_len, send_buffer,
+                          send_buffer_size);
   if (len < 0) {
     ESP_LOGE(TAG,
              "Error Building UART Message: payload_len, %d, sendbuffer_size: "
@@ -60,18 +58,25 @@ void echoCallback(uint8_t msgid, const uint8_t *payload, size_t payload_len,
 }
 
 void versionCallback(uint8_t msgid, const uint8_t *payload, size_t payload_len,
-                     uint8_t *send_buffer, size_t send_buffer_size) {
-  // Code für den Button-Press
+                     uint8_t *send_payload_buffer,
+                     size_t send_payload_buffer_size, uint8_t *send_buffer,
+                     size_t send_buffer_size) {
   ESP_LOGI(TAG, "Version command 0x02...");
   size_t git_build_hash_len = strlen(BUILD_GIT_HASH);
+  size_t needed_buffer_size = 2 + git_build_hash_len;
 
-  uint8_t send_payload[2 + git_build_hash_len];
-  send_payload[0] = (uint8_t)(version & 0xFF);
-  send_payload[1] = (uint8_t)((version >> 8) & 0xFF);
-  memcpy(&send_payload[2], &BUILD_GIT_HASH, git_build_hash_len);
+  if (send_payload_buffer_size < needed_buffer_size) {
+    ESP_LOGE(TAG, "send_payload_buffer to small size %d need %d",
+             send_payload_buffer_size, needed_buffer_size);
+    return;
+  }
 
-  int len = build_message(0x02, send_payload, sizeof(send_payload), send_buffer,
-                          send_buffer_size);
+  send_payload_buffer[0] = (uint8_t)(version & 0xFF);
+  send_payload_buffer[1] = (uint8_t)((version >> 8) & 0xFF);
+  memcpy(&send_payload_buffer[2], &BUILD_GIT_HASH, git_build_hash_len);
+
+  int len = build_message(UART_VERSION, send_payload_buffer, needed_buffer_size,
+                          send_buffer, send_buffer_size);
   if (len < 0) {
     ESP_LOGE(TAG,
              "Error Building UART Message: payload_len, %d, sendbuffer_size: "
@@ -83,19 +88,20 @@ void versionCallback(uint8_t msgid, const uint8_t *payload, size_t payload_len,
 }
 
 void clientInfoCallback(uint8_t msgid, const uint8_t *payload,
-                        size_t payload_len, uint8_t *send_buffer,
+                        size_t payload_len, uint8_t *send_payload_buffer,
+                        size_t send_payload_buffer_size, uint8_t *send_buffer,
                         size_t send_buffer_size) {
   ESP_LOGI(TAG, "Client Info Command 0x03...");
-  static uint8_t entryLength = 17;
+  static uint8_t entryLength = 19;
+  uint8_t needed_buffer_size = 1 + entryLength * clientList.ClientCount;
 
-  ESP_LOGE(TAG, "clientList.ClientCount = %d", clientList.ClientCount);
+  if (send_payload_buffer_size < needed_buffer_size) {
+    ESP_LOGE(TAG, "send_payload_buffer to small size %d need %d",
+             send_payload_buffer_size, needed_buffer_size);
+    return;
+  }
 
-  uint8_t payload_size = 1 + entryLength * clientList.ClientCount;
-
-  ESP_LOGE(TAG, "payload_size = %d", payload_size);
-
-  uint8_t send_payload[payload_size];
-  send_payload[0] = clientList.ClientCount;
+  send_payload_buffer[0] = clientList.ClientCount;
   uint8_t offsetMult = 0;
 
   uint8_t used_slots = 0;
@@ -104,7 +110,6 @@ void clientInfoCallback(uint8_t msgid, const uint8_t *payload,
       used_slots++;
     }
   }
-  ESP_LOGE("SPECIAL", "USED SLOTS: %d", used_slots);
 
   uint8_t loop_sanity_counter = 0;
 
@@ -112,30 +117,38 @@ void clientInfoCallback(uint8_t msgid, const uint8_t *payload,
     if (clientList.Clients[i].slotIsUsed) {
       loop_sanity_counter++;
       if (loop_sanity_counter > clientList.ClientCount) {
-        ESP_LOGE("SPECIAL", "DAS KANN NICHT SEIN");
-        ESP_LOGE("SPECIAL", "loop_santy_count: %d, client_count: %d", loop_sanity_counter, clientList.ClientCount);
+        ESP_LOGE("SPECIAL",
+                 "ERROR SANITY CHECK FAILED: loop_sanity_count: %d, "
+                 "client_count: %d",
+                 loop_sanity_counter, clientList.ClientCount);
       }
       size_t offset = 1 + (entryLength * offsetMult++);
 
       ESP_LOGE("SPECIAL", "OFFSET %d", offset);
-      send_payload[offset] = i;
-      send_payload[offset + 1] = clientList.Clients[i].isAvailable;
-      send_payload[offset + 2] = clientList.Clients[i].slotIsUsed;
-      memcpy(&send_payload[offset + 3], clientList.Clients[i].macAddr,
+      send_payload_buffer[offset] = i;
+      send_payload_buffer[offset + 1] = clientList.Clients[i].isAvailable;
+      send_payload_buffer[offset + 2] = clientList.Clients[i].slotIsUsed;
+      memcpy(&send_payload_buffer[offset + 3], clientList.Clients[i].macAddr,
              MAC_LENGTH);
-      memcpy(&send_payload[offset + 9], &clientList.Clients[i].lastPing, 4);
-      memcpy(&send_payload[offset + 13],
+      memcpy(&send_payload_buffer[offset + 9], &clientList.Clients[i].lastPing,
+             4);
+      memcpy(&send_payload_buffer[offset + 13],
              &clientList.Clients[i].lastSuccessfullPing, 4);
+      memcpy(&send_payload_buffer[offset + 17],
+             &clientList.Clients[i].clientVersion, 2);
     }
   }
 
-  int len = build_message(0x04, send_payload, sizeof(send_payload), send_buffer,
-                          send_buffer_size);
+  int len = build_message(UART_CLIENT_INFO, send_payload_buffer,
+                          needed_buffer_size, send_buffer, send_buffer_size);
+
+  // ESP_LOG_BUFFER_HEX("SEND BUFFER: ", send_buffer, send_buffer_size);
+
   if (len < 0) {
     ESP_LOGE(TAG,
              "Error Building UART Message: payload_len, %d, sendbuffer_size: "
              "%d, mes_len(error): %d",
-             payload_len, send_buffer_size, len);
+             needed_buffer_size, send_buffer_size, len);
     return;
   }
   uart_write_bytes(MASTER_UART, send_buffer, len);
@@ -166,8 +179,7 @@ void app_main(void) {
   wifi_config_t wifi_config = {
       .sta =
           {
-              .channel = 1, // Kanal 1, stelle sicher, dass alle Geräte
-                            // denselben Kanal verwenden
+              .channel = 1,
           },
   };
   ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));
@@ -181,11 +193,84 @@ void app_main(void) {
     ESP_ERROR_CHECK(esp_now_register_recv_cb(client_receive_callback));
   }
 
-  init_com(&clientList);
+  ret = init_com(&clientList, 1);
+  if (ret < 0) {
+    ESP_LOGE(TAG, "Could not Init ESP NOW Communication!");
+  }
+
+  esp_partition_iterator_t partition_iter = esp_partition_find(
+      ESP_PARTITION_TYPE_ANY, ESP_PARTITION_SUBTYPE_ANY, NULL);
+
+  while (partition_iter != NULL) {
+    const esp_partition_t *part1 = esp_partition_get(partition_iter);
+    ESP_LOGI(TAG, "Partition: %s, Address: %d, Size %d", part1->label,
+             part1->address, part1->size);
+    partition_iter = esp_partition_next(partition_iter);
+  }
+
+  const esp_partition_t *running = esp_ota_get_running_partition();
+  ESP_LOGI(TAG, "OTA: Running Partition: %s", running->label);
+  uint8_t ota_part_count = esp_ota_get_app_partition_count();
+  ESP_LOGI(TAG, "OTA: Got %d OTA Partitions", ota_part_count);
+
+  esp_ota_img_states_t ota_state;
+  if (esp_ota_get_state_partition(running, &ota_state) == ESP_OK) {
+    ESP_LOGI(TAG, "OTA: Partition State : %d", ota_state);
+    if (ota_state == ESP_OTA_IMG_PENDING_VERIFY) {
+      // run diagnostic function ...
+      bool diagnostic_is_ok = true; // TODO: a real function that checks if
+                                    // everything is running properly
+      if (diagnostic_is_ok) {
+        ESP_LOGI(
+            TAG,
+            "Diagnostics completed successfully! Continuing execution ...");
+        // esp_ota_mark_app_valid_cancel_rollback();
+      } else {
+        ESP_LOGE(
+            TAG,
+            "Diagnostics failed! Start rollback to the previous version ...");
+        // esp_ota_mark_app_invalid_rollback_and_reboot();
+      }
+    }
+  }
+
+  const char nvs_part_name[] = "nvs_data";
+  const char nvs_namespace_name[] = "saved_clients";
+  ret = nvs_flash_init_partition(nvs_part_name);
+  if (ret == ESP_ERR_NVS_NO_FREE_PAGES ||
+      ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
+    ESP_ERROR_CHECK(nvs_flash_erase_partition(nvs_part_name));
+    ret = nvs_flash_init_partition(nvs_part_name);
+  }
+  ESP_ERROR_CHECK(ret);
+  nvs_handle_t nt;
+  ESP_ERROR_CHECK(nvs_open_from_partition(nvs_part_name, nvs_namespace_name,
+                                          NVS_READWRITE, &nt));
+
+  int32_t outval;
+  ret = nvs_get_i32(nt, "test_entry", &outval);
+  if (ret == ESP_ERR_NVS_NOT_FOUND) {
+    ESP_ERROR_CHECK(nvs_set_i32(nt, "test_entry", 6969));
+    ESP_ERROR_CHECK(nvs_commit(nt));
+    ESP_LOGE(TAG, "Nichts im Flash gefunden hab was dahin geschrieben");
+  } else if (ret == ESP_OK) {
+    ESP_LOGE(TAG, "DAS WAR IM FLASH %d", outval);
+  }
+  nvs_close(nt);
+
+  QueueHandle_t espnow_message_queue =
+      xQueueCreate(10, sizeof(ESPNOW_MessageInfo));
+  ESP_InitMessageBroker(espnow_message_queue);
+
+  esp_broker_task_params.message_queue = espnow_message_queue;
+  xTaskCreate(ESP_MessageBrokerTask, "espnow_message_broker_task", 4096,
+              (void *)&esp_broker_task_params, 4, NULL);
 
   // Tasks starten basierend auf Master/Client
   if (isMaster) {
     ESP_LOGI(TAG, "Started in Mastermode");
+    ESPNOW_RegisterMasterCallbacks();
+
     add_peer(broadcast_address);
     xTaskCreate(master_broadcast_task, "MasterBroadcast", 4096, NULL, 1, NULL);
     //  xTaskCreate(master_ping_task, "MasterPing", 4096, NULL, 1, NULL);
@@ -203,6 +288,9 @@ void app_main(void) {
     broker_task_params.message_queue = parsed_message_queue;
     broker_task_params.send_buffer = send_message_buffer;
     broker_task_params.send_buffer_size = sizeof(send_message_buffer);
+    broker_task_params.payload_buffer = send_message_payload_buffer;
+    broker_task_params.payload_buffer_size =
+        sizeof(send_message_payload_buffer);
 
     xTaskCreate(MessageBrokerTask, "message_handler_task", 4096,
                 (void *)&broker_task_params, 5, NULL);
@@ -211,12 +299,15 @@ void app_main(void) {
     RegisterCallback(0x02, versionCallback);
     RegisterCallback(0x03, clientInfoCallback);
 
+    init_ota();
+
     // xTaskCreate(uart_status_task, "MasterUartStatusTask", 4096, NULL, 1,
     // NULL); xTaskCreate(SendClientInfoTask, "SendCientInfo", 4096, NULL, 1,
     // NULL);
   } else {
     ESP_LOGI(TAG, "Started in Slavemode");
-    xTaskCreate(client_data_sending_task, "ClientDataSending", 4096, NULL, 1,
-                NULL);
+    ESPNOW_RegisterSlaveCallbacks();
+    // xTaskCreate(client_data_sending_task, "ClientDataSending", 4096, NULL, 1,
+    //             NULL);
   }
 }

main/main.h

@@ -14,6 +14,10 @@
 #include <stdio.h>
 #include <string.h>
 
+#ifdef CONFIG_IDF_TARGET_ESP32S3
+#define MASTER_MODE_PIN GPIO_NUM_1 // Jumper-Erkennungspin
+#elif CONFIG_IDF_TARGET_ESP32C3
 #define MASTER_MODE_PIN GPIO_NUM_0 // Jumper-Erkennungspin
+#endif
 
 #endif

main/message_builder.c

@@ -20,8 +20,8 @@ bool add_byte_with_length_check(uint8_t byte, size_t write_index, uint8_t *data,
 int build_message(uint8_t msgid, const uint8_t *payload, size_t payload_len,
                   uint8_t *msg_buffer, size_t msg_buffer_size) {
 
-  ESP_LOGE("BM", "payload_len %d, msg_buffer_size %d", payload_len + 4,
-           msg_buffer_size);
+  //ESP_LOGE("BM", "payload_len %d, msg_buffer_size %d", payload_len + 4,
+  //         msg_buffer_size);
   if (payload_len + 4 > msg_buffer_size) {
     return PayloadBiggerThenBuffer;
   }
@@ -75,6 +75,5 @@ int build_message(uint8_t msgid, const uint8_t *payload, size_t payload_len,
   msg_buffer[write_index++] = checksum;
   msg_buffer[write_index++] = EndByte;
 
-  ESP_LOGE("BM", "MESSAGE FERTIG GEBAUT");
   return write_index;
 }

main/message_handler.c

@@ -6,12 +6,6 @@
 static struct MessageBroker mr;
 static char *TAG = "ALOX - Message Handler";
 
-typedef struct {
-  QueueHandle_t message_queue;
-  uint8_t *send_buffer;
-  size_t send_buffer_size;
-} MessageBrokerTaskParams_t;
-
 void InitMessageBroker() {
   mr.num_direct_callbacks = 0;
   mr.num_task_callbacks = 0;
@@ -40,6 +34,8 @@ void MessageBrokerTask(void *param) {
   QueueHandle_t msg_queue = task_params->message_queue;
   uint8_t *send_message_buffer = task_params->send_buffer;
   size_t send_message_buffer_size = task_params->send_buffer_size;
+  uint8_t *send_payload_buffer = task_params->payload_buffer;
+  size_t send_payload_buffer_size = task_params->payload_buffer_size;
 
   if (msg_queue == NULL) {
     ESP_LOGE(TAG, "Message queue not initialized. Terminating task.");
@@ -50,13 +46,14 @@ void MessageBrokerTask(void *param) {
 
   while (1) {
     if (xQueueReceive(msg_queue, &received_msg, portMAX_DELAY)) {
-      ESP_LOGI(TAG, "Received message from queue: MSGID=0x%02X, Length=%u",
-               received_msg.msgid, received_msg.payload_len);
+      //ESP_LOGI(TAG, "Received message from queue: MSGID=0x%02X, Length=%u",
+      //         received_msg.msgid, received_msg.payload_len);
 
       for (int i = 0; i < mr.num_direct_callbacks; i++) {
         if (mr.FunctionList[i].MSGID == received_msg.msgid) {
           mr.FunctionList[i].callback(
               received_msg.msgid, received_msg.data, received_msg.payload_len,
+              send_payload_buffer, send_payload_buffer_size,
               send_message_buffer, send_message_buffer_size);
         }
       }

main/message_handler.h

@@ -5,12 +5,26 @@
 #include <stddef.h>
 #include <stdint.h>
 
+typedef struct {
+  QueueHandle_t message_queue;
+  uint8_t *send_buffer;
+  size_t send_buffer_size;
+  uint8_t *payload_buffer;
+  size_t payload_buffer_size;
+} MessageBrokerTaskParams_t;
+
 typedef void (*RegisterFunctionCallback)(uint8_t msgid, const uint8_t *payload,
                                          size_t payload_len,
+                                         uint8_t *send_payload_buffer,
+                                         size_t send_payload_buffer_size,
                                          uint8_t *send_buffer,
                                          size_t send_buffer_size);
+
 typedef void (*RegisterTaskCallback)(uint8_t msgid, const uint8_t *payload,
-                                     size_t payload_len, uint8_t *send_buffer,
+                                     size_t payload_len,
+                                     uint8_t *send_payload_buffer,
+                                     size_t send_payload_buffer_size,
+                                     uint8_t *send_buffer,
                                      size_t send_buffer_size);
 
 struct RegisterdFunction {

main/message_parser.h

@@ -4,7 +4,7 @@
 #include <stddef.h>
 #include <stdint.h>
 
-#define MAX_MESSAGE_PAYLOAD_LENGTH 128
+#define MAX_MESSAGE_PAYLOAD_LENGTH 512
 #define MAX_TOTAL_CONTENT_LENGTH (MAX_MESSAGE_PAYLOAD_LENGTH + 1)
 
 enum ParserState {
@@ -33,7 +33,7 @@ struct MessageReceive {
   enum ParserError error;
   uint8_t messageid;
   uint8_t message[MAX_MESSAGE_PAYLOAD_LENGTH];
-  uint8_t index;
+  uint16_t index;
   uint8_t checksum;
 };
 

main/ota_update.c

@@ -0,0 +1,215 @@
+#include "ota_update.h"
+#include "driver/uart.h"
+#include "esp_err.h"
+#include "esp_log.h"
+#include "esp_ota_ops.h"
+#include "esp_partition.h"
+#include "esp_system.h"
+#include "message_builder.h"
+#include "message_handler.h"
+#include "uart_handler.h"
+#include "uart_msg_ids.h"
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+#define MAX(a, b) ((a) > (b) ? (a) : (b))
+#define MIN(a, b) ((a) < (b) ? (a) : (b))
+
+static uint8_t update_buffer[UPDATE_BUFFER_SIZE];
+static uint16_t update_buffer_write_index;
+static uint32_t update_size;
+static uint16_t sequenz_counter; // how often the update buffer gets written
+static const char *TAG = "ALOX - OTA";
+static esp_ota_handle_t update_handle;
+
+int prepare_ota_update() {
+  const esp_partition_t *running = esp_ota_get_running_partition();
+  ESP_LOGI(TAG, "OTA: Running Partition: %s", running->label);
+  int part = 0;
+
+  char partition_to_update[] = "ota_0";
+  if (strcmp(running->label, "ota_0") == 0) {
+    strcpy(partition_to_update, "ota_1");
+    part = 1;
+  }
+
+  const esp_partition_t *update_partition = esp_partition_find_first(
+      ESP_PARTITION_TYPE_APP, ESP_PARTITION_SUBTYPE_ANY, partition_to_update);
+
+  // Check if the partition was found
+  if (update_partition == NULL) {
+    ESP_LOGE(TAG, "Failed to find OTA partition: %s", partition_to_update);
+    return -1; // Or handle the error appropriately
+  }
+
+  ESP_LOGI(TAG, "Gonna write OTA Update in Partition: %s",
+           update_partition->label);
+
+  esp_err_t err =
+      esp_ota_begin(update_partition, OTA_SIZE_UNKNOWN, &update_handle);
+  if (err != ESP_OK) {
+    ESP_LOGE(TAG, "esp_ota_begin failed (%s)", esp_err_to_name(err));
+    esp_ota_abort(update_handle);
+    return -2;
+  }
+
+  ESP_LOGI(TAG, "OTA update started successfully.");
+  return part;
+}
+
+void start_uart_update(uint8_t msgid, const uint8_t *payload,
+                       size_t payload_len, uint8_t *send_payload_buffer,
+                       size_t send_payload_buffer_size, uint8_t *send_buffer,
+                       size_t send_buffer_size) {
+  ESP_LOGI(TAG, "OTA Update Start Uart Command");
+
+  vTaskPrioritySet(NULL, 2);
+
+  update_size = 0;
+
+  int part = prepare_ota_update();
+
+  // Message:
+  // byte partition
+  // byte error
+
+  if (part < 0) {
+    send_payload_buffer[1] = (part * -1) & 0xff;
+  } else {
+    send_payload_buffer[0] = part & 0xff;
+  }
+
+  int send_payload_len = 2;
+  int len = build_message(UART_OTA_START, send_payload_buffer, send_payload_len,
+                          send_buffer, send_buffer_size);
+  if (len < 0) {
+    ESP_LOGE(TAG,
+             "Error Building UART Message: payload_len, %d, sendbuffer_size: "
+             "%d, mes_len(error): %d",
+             payload_len, send_buffer_size, len);
+    return;
+  }
+
+  uart_write_bytes(MASTER_UART, send_buffer, len);
+}
+
+esp_err_t write_ota_update(uint32_t write_len, const uint8_t *payload) {
+  if (update_buffer_write_index > UPDATE_BUFFER_SIZE - write_len) {
+    // ESP_LOGI(TAG, "Writing Data to Update BUffer Sequence %d, writing Data
+    // %d",
+    //          sequenz_counter, write_len);
+    // write to ota
+    esp_err_t err =
+        esp_ota_write(update_handle, update_buffer, update_buffer_write_index);
+    if (err != ESP_OK) {
+      return err;
+    }
+
+    update_buffer_write_index = 0;
+    sequenz_counter++;
+    return err;
+  }
+
+  memcpy(&update_buffer[update_buffer_write_index], payload, write_len);
+  update_buffer_write_index += write_len;
+  return ESP_OK;
+}
+
+void payload_uart_update(uint8_t msgid, const uint8_t *payload,
+                         size_t payload_len, uint8_t *send_payload_buffer,
+                         size_t send_payload_buffer_size, uint8_t *send_buffer,
+                         size_t send_buffer_size) {
+  // ESP_LOGI(TAG, "OTA Update Payload Uart Command");
+
+  uint32_t write_len = MIN(UPDATE_PAYLOAD_SIZE, payload_len);
+  update_size += write_len;
+
+  esp_err_t err = write_ota_update(write_len, payload);
+
+  if (err != ESP_OK) {
+    ESP_LOGE(TAG, "GOT ESP ERROR WRITE OTA %d", err);
+  }
+
+  size_t send_payload_len = 4;
+  memcpy(send_payload_buffer, &sequenz_counter, 2);
+  memcpy(&send_payload_buffer[2], &update_buffer_write_index, 2);
+  send_payload_buffer[4] = 0x00; // error
+
+  int len = build_message(UART_OTA_PAYLOAD, send_payload_buffer,
+                          send_payload_len, send_buffer, send_buffer_size);
+  if (len < 0) {
+    ESP_LOGE(TAG,
+             "Error Building UART Message: payload_len, %d, sendbuffer_size: "
+             "%d, mes_len(error): %d",
+             payload_len, send_buffer_size, len);
+    return;
+  }
+
+  uart_write_bytes(MASTER_UART, send_buffer, len);
+}
+
+esp_err_t end_ota_update() {
+  esp_err_t err =
+      esp_ota_write(update_handle, update_buffer, update_buffer_write_index);
+  if (err != ESP_OK) {
+    ESP_LOGE(TAG, "GOT ESP ERROR WRITE OTA %d", err);
+  }
+
+  err = esp_ota_end(update_handle);
+  if (err != ESP_OK) {
+    ESP_LOGE(TAG, "GOT ESP ERROR WRITE OTA %d", err);
+  }
+
+  ESP_LOGE(TAG, "UPDATE ENDE UPDATGE SIZE SIND %d BYTES", update_size);
+
+  // Hol dir die zuletzt geschriebene Partition
+  const esp_partition_t *partition = esp_ota_get_next_update_partition(NULL);
+  if (partition == NULL) {
+    ESP_LOGE(TAG, "Failed to get updated partition");
+    err = ESP_FAIL;
+  }
+
+  // Setze sie als Boot-Partition
+  ESP_LOGE(TAG, "Setzte nächste Partition auf %s", partition->label);
+  err = esp_ota_set_boot_partition(partition);
+  if (err != ESP_OK) {
+    ESP_LOGE(TAG, "esp_ota_set_boot_partition failed: %s",
+             esp_err_to_name(err));
+  }
+  return err;
+}
+
+void end_uart_update(uint8_t msgid, const uint8_t *payload, size_t payload_len,
+                     uint8_t *send_payload_buffer,
+                     size_t send_payload_buffer_size, uint8_t *send_buffer,
+                     size_t send_buffer_size) {
+  ESP_LOGI(TAG, "OTA Update End Uart Command");
+
+  esp_err_t err = end_ota_update();
+
+  // message ret esp_err_t
+  int send_payload_len = 1;
+  send_payload_buffer[0] = err & 0xff;
+  int len = build_message(UART_OTA_END, send_payload_buffer, send_payload_len,
+                          send_buffer, send_buffer_size);
+  if (len < 0) {
+    ESP_LOGE(TAG,
+             "Error Building UART Message: payload_len, %d, sendbuffer_size: "
+             "%d, mes_len(error): %d",
+             payload_len, send_buffer_size, len);
+    return;
+  }
+
+  uart_write_bytes(MASTER_UART, send_buffer, len);
+
+  vTaskPrioritySet(NULL, 1);
+}
+
+void write_ota_update_from_uart_task(void *param) {}
+
+void init_ota() {
+  RegisterCallback(UART_OTA_START, start_uart_update);
+  RegisterCallback(UART_OTA_PAYLOAD, payload_uart_update);
+  RegisterCallback(UART_OTA_END, end_uart_update);
+}

main/ota_update.h

@@ -0,0 +1,25 @@
+#ifndef OTA_UPDATE_H
+#define OTA_UPDATE_H
+
+#include "esp_err.h"
+#include <stdint.h>
+#include <sys/types.h>
+#define UPDATE_BUFFER_SIZE 4000
+#define UPDATE_PAYLOAD_SIZE 200
+#define UPDATE_MAX_SEQUENZES (UPDATE_BUFFER_SIZE / UPDATE_PAYLOAD_SIZE)
+
+void init_ota();
+
+enum OTA_UPDATE_STATES {
+  IDEL,
+  START_REQUESTED,
+  WAITING_FOR_PAYLOAD,
+  WRITING_OTA_TO_PARTITION,
+
+};
+
+int prepare_ota_update();
+esp_err_t write_ota_update(uint32_t write_len, const uint8_t *payload);
+esp_err_t end_ota_update();
+
+#endif

main/uart_handler.c

@@ -18,7 +18,7 @@ static const char *TAG = "ALOX - UART";
 static QueueHandle_t parsed_message_queue;
 
 void init_uart(QueueHandle_t msg_queue_handle) {
-  uart_config_t uart_config = {.baud_rate = 115200,
+  uart_config_t uart_config = {.baud_rate = 921600, // 921600, 115200
                                .data_bits = UART_DATA_8_BITS,
                                .parity = UART_PARITY_DISABLE,
                                .stop_bits = UART_STOP_BITS_1,
@@ -61,9 +61,9 @@ void send_message_hook(const uint8_t *buffer, size_t length) {
 
 void HandleMessageReceivedCallback(uint8_t msgid, const uint8_t *payload,
                                    size_t payload_len) {
-  ESP_LOGI(TAG, "GOT UART MESSAGE MSGID: %02X, Len: %u bytes \nMSG: ", msgid,
+  /*ESP_LOGI(TAG, "GOT UART MESSAGE MSGID: %02X, Len: %u bytes \nMSG: ", msgid,
            payload_len, payload);
-  ESP_LOG_BUFFER_HEX(TAG, payload, payload_len);
+  ESP_LOG_BUFFER_HEX(TAG, payload, payload_len);*/
 
   ParsedMessage_t msg_to_send;
   msg_to_send.msgid = msgid;

main/uart_handler.h

@@ -6,9 +6,15 @@
 #include <stddef.h>
 #include <stdint.h>
 
+#ifdef CONFIG_IDF_TARGET_ESP32S3
+#define MASTER_UART UART_NUM_1
+#define TXD_PIN (GPIO_NUM_2)
+#define RXD_PIN (GPIO_NUM_3)
+#elif CONFIG_IDF_TARGET_ESP32C3
 #define MASTER_UART UART_NUM_1
 #define TXD_PIN (GPIO_NUM_1)
 #define RXD_PIN (GPIO_NUM_2)
+#endif
 
 #define BUF_SIZE (256)
 

main/uart_msg_ids.h

@@ -0,0 +1,17 @@
+#ifndef UART_MSG_IDS_H
+#define UART_MSG_IDS_H
+
+enum UART_MSG_IDS {
+  // MISC
+  UART_ECHO = 0x01,
+  UART_VERSION = 0x02,
+  UART_CLIENT_INFO = 0x03,
+
+  // OTA
+  UART_OTA_START = 0x10,
+  UART_OTA_PAYLOAD = 0x11,
+  UART_OTA_END = 0x12,
+  UART_OTA_STATUS = 0x13,
+};
+
+#endif

readme.md

@@ -2,54 +2,123 @@
 
 ## Struktur einer Nachricht
 
-    0xAA = Startbyte  
-    checksum = XOR über alle Bytes (ohne Startbyte und Checksum-Byte)
+- Control Bytes:
+    - 0xAA = Startbyte  
+    - 0xBB = EscapeByte
+    - 0xCC = EndByte
     
-## Nachrichtenaufbau (Message Frame)
+checksum = XOR über alle Bytes (ohne Control Bytes und Checksum-Byte)
 
-[ Startbyte ] [ Length ] [ CommandPage ] [ Payload (variabel) ] [ Checksum ]
+Command, Payload und Checksum werden Escaped sollten sie einem Control Byte ensteprechend
+| Startbyte | Command | Payload (variable) | Checksum | Endbyte |
+|-----------|---------|--------------------|----------|---------|
 
 ### Felder im Detail:
 
-- **Length** (`uint8_t`):  
-  Gibt die Gesamtlänge der Nachricht **ab `CommandPage` bis einschließlich `Payload`** an.  
-
-- **CommandPage** (`uint8_t`):  
-  Gibt an, welcher Nachrichtentyp oder Befehl gesendet wird.
+- **Command** (`uint8_t`):  
+  Gibt an, welcher Nachrichtentyp gesendet wird.
 
 - **Payload** (`variabel`):  
-  Datenfeld mit variabler Länge, abhängig vom `CommandPage`.
+  Datenfeld mit variabler Länge, abhängig vom `Command`.
 
 - **Checksum** (`uint8_t`):  
-  XOR über alle Bytes ab `Length` bis einschließlich `Payload`.  
-
-### Nachrichten von PC zu ESP:
-
-clientid: 0x00 für master, 0xFF für broadcast, ansonsten 0xA0-0xB3 // 19 Clients
-
-### RequestPing 0xE1
-Payload: byte: clientid
-### RequestInfo 0xE2
-Payload: byte: clientid
-### RequestRestart 0xE3
-Payload: byte: clientid
-### PrepareFirmwareUpdate 0xF1
-Payload: none 
-### FirmwareUpdateLine 0xF2
-Payload: firmware line 240Bytes MAX 
-### ExecuteFirmwareUpdate 0xF3
-Payload: none 
-
-### Nachrichten von ESP zu PC:
+  XOR über aller Bytes von `Command` und `Payload`.  
 
 
+### Messages
 
----
+Command: 
+- UART_ECHO        = 0x01
+- UART_VERSION     = 0x02
+- UART_CLIENT_INFO = 0x03
 
-# Roadmap 
-- [ ] SEND STATUS OF DEVICE OVER UART
-- [ ] CONFIGURE PEERS OVER MASTER
-- [ ] SAVE PIN CONFIG ON PEERS
+Grundlegend sind alle Zahlenwerte im LittleEndian format!
+
+#### UART_ECHO:
+
+- Send Message: AA 01 01 CC
+- Message Received: AA 01 01 CC
+
+Sendet zurück was geschickt wird.
+
+#### UART_VERSION:
+
+| Offset | Länge (Bytes) | Bezeichnung | Beschreibung     |
+|--------|---------------|-------------|------------------|
+| 0      | 2             | Version     | Software Version |
+| 2      | 7             | BuildHash   | Git Hash         |
+
+
+- Send Message: AA 02 02 CC
+- Message Received: AA 02 01 00 33 62 35 36 30 37 39 6F CC
+
+| Version | Buildhash |
+|---------|-----------|
+| 1       | 3b56078   |
+
+
+Sendet die Version und den Buildhash vom Master zurück.
+
+#### UART_CLIENT_INFO:
+
+Das erste Datenbyte nach dem Commando gibt an wie viele Client Infos in dieser Nachricht vorhanden sind.
+
+Danach teilt sich ein Eintrag wie Folgt auf:
+| Offset | Länge (Bytes) | Bezeichnung                | Beschreibung                                                  |
+|--------|---------------|----------------------------|---------------------------------------------------------------|
+| 0      | 1             | Client ID                  | Eindeutige ID des Clients.                                    |
+| 1      | 1             | Ist verfügbar              | Boolean-Wert (0 = nein, 1 = ja), ob der Client verfügbar ist. |
+| 2      | 1             | Slot genutzt               | Boolean-Wert (0 = nein, 1 = ja), ob der Slot belegt ist.      |
+| 3      | 6             | MAC-Adresse                | Die Hardware-Adresse des Clients.                             |
+| 9      | 4             | Letzter Ping               | Zeit in Millisekunden seit dem letzten Ping.                  |
+| 13     | 4             | Letzter erfolgreicher Ping | Zeit in Millisekunden seit dem letzten erfolgreichen Ping.    |
+| 17     | 2             | Version                    | Versionsnummer des Clients.                                   |
+
+##### Ein Client
+
+- Send Message: AA 03 03 CC
+- Message Received: AA 03 01 00 01 01 50 78 7D 18 89 F8 34 00 00 00 61 1F 00 00 02 00 76 CC
+
+| Client ID | Verfügbar | Genutzt | MAC-Adresse       | Last Ping | Last Successful Ping | Version |
+|-----------|-----------|---------|-------------------|-----------|----------------------|---------|
+| 0         | 1         | 1       | 50:78:7D:18:89:F8 | 52        | 8033                 | 2       |
+
+##### Zwei Clients
+
+- Send Message: AA 03 03 CC
+- Message Received: AA 03 02 00 01 01 50 78 7D 18 89 F8 22 00 00 00 F4 2A 01 00 02 00 01 01 01 50 78 7D 18 0C B4 10 00 00 00 F1 2A 01 00 02 00 FE CC
+
+| Client ID | Verfügbar | Genutzt | MAC-Adresse       | Last Ping | Last Successful Ping | Version |
+|-----------|-----------|---------|-------------------|-----------|----------------------|---------|
+| 0         | 1         | 1       | 50:78:7D:18:89:F8 | 34        | 76532                | 2       |
+| 1         | 1         | 1       | 50:78:7D:18:C:B4  | 16        | 76529                | 2       |
+
+#### UART_CLIENT_INPUT:
+
+Die Identifizierung wird hier anhand der vorher gesendeten ClientID gemacht also muss einmal vorher `UART_CLIENT_INFO` aufgerufen werden.
+
+Das erste Datenbyte nach dem Commando gibt an wie viele Client Infos in dieser Nachricht vorhanden sind.
+
+Danach teilt sich ein Eintrag wie Folgt auf:
+| Offset | Länge (Bytes) | Bezeichnung | Beschreibung                                                                     |
+|--------|---------------|-------------|----------------------------------------------------------------------------------|
+| 0      | 1             | Client ID   | Eindeutige ID des Clients.                                                       |
+| 1      | 4             | LageX       | Float Wert von der X Lage.                                                       |
+| 5      | 4             | LageY       | Float Wert von der Y Lage.                                                       |
+| 9      | 4             | InputMaske  | Int32 Wert der als Bitmaske genutzt wird um bis zu 32 Boolische Werte anzugeben. |
+
+Inputmaske:
+Taster1, Taster2, IOError1, IOErro2, AkkuStand1, AkkuStand2 (2 Bit kodiert für 25%,50%,75%,100%), rest unbelegt, default 0
+
+| Bit1 | Bit2 | Akkustand |
+|------|------|-----------|
+| 0    | 0    | 25%       |
+| 0    | 1    | 50%       |
+| 1    | 0    | 75%       |
+| 1    | 1    | 100%      |
+
+
+<div style="page-break-after: always;"></div>
 
 # Machbarkeits-Studie
 
@@ -177,3 +246,55 @@ techn. Anforderungen hinreichend gut umsetzen lassen.
 und ob diese den ursprünglichen Anforderungen entsprechen.
 
 
+
+## OTA-Update Technische Umsetzung:
+
+### Vorrausetzung:
+- Update File steht bereit und ist unter 2MB groß.
+- UART Verbindung steht
+- ESP Funktioniert einwandfrei
+- ESP Läuft auf Partition A, Partition B soll geupdated werden
+
+### Erste Schritt:
+- Update in 200Byte stücke zerhacken und stück für stück per UART an den Master schicken
+- Uart Protokol hat schon eine fehlercheck für die Übertragung drinnen
+- Firmware wird in Partition B geschrieben
+- OTA API Validiert Firmware am ende
+
+#### Hier könnte man schon einen Neustart machen und Validieren ob die Firmware für den Master läuft!
+#### Denn angeblich kann man beim ESP die aktuell laufende Partition auslesen
+
+### Zweiter Schritt:
+- Master liest in 200Byte stücken die Firmware aus seiner Partition B aus
+- Und schickt per Broadcast die ersten 20 Packete an die Clients
+- Die clients haben 4KB Buffer vorgesehen wo sie die 20 Packete unterbringen können
+- Master Forder Ack Bitmaske an zur Validierung das alle 20 Packete da sind
+- Sollten in der Bitmaske zeilen fehlen gibt der Master per unicast die fehlenden Zeilen an die Entsprechend Clients erneut
+- ESP NOW kümmert sich hier um die Datenintigrität
+- Wenn alle ihre ersten 20 packete haben gibt der master das go und alle schreiben die ersten 20 packete weg.
+- Der master aktuallisiert den fortschritt für alle clients -> dann kann man das auch abfragen per uart und hat eine Fortschrittsanzeige
+- Alle melden sich zurück wenn sie fertig sind mit dem schreiben per ota und der buffer leer ist.
+- Repeat bis alle Daten da sind
+
+Hier hab ich mal grob gerechnet:
+2MB in 200Byte Schritten -> 10.000 Packete
+10.000 Packete in 20er Schritten -> 500 Sequencen
+Retries und Acks mal aussen vor hab ich leider keinen richtigen anhaltspunkt wie lang das dauern kann.
+Aber 500* ca 300ms => ist schonmal 150sekunden nur für das acken das die Packete da sind. Annahme hier das die maximal latenz beim Ping mit 16 Clients ca 300ms sind.
+Entsprechend mit Daten und retries... ja kp, Gemini schätzt max 10min. Wird sich zeigen. Da addiert sich zu viel auf.
+
+- Alle Clients validieren ihren firmware
+- Sollte das bei einem nicht klappen muss man hier nochmal gucken ob man den ganzen process nochmal von vorne anstößt nur mit dem fehlenden client...
+
+### Dritter Schritt:
+- Alle Clients rebooten
+- Clients geben rückmeldung ob das Update funktioniert
+
+#### Hier müssten war noch entscheiden was passiert wenn das Update bei nur ein paar funktionert hat?
+#### Was passiert wenn das Update garnicht funktioniert hat, behält der master dann auch seinen stand?
+#### Entsprechend hätte man ihn vorher auch nicht neustarten dürfen
+
+- Sollten alle Clients ihr go geben startet der Master auch neu
+#### Wenn das Master Update jetzt fehlschlägt sagt er den clients bescheid und die booten auch wieder um?
+
+Gibt halt noch ein zwar sachen die man sich überlegen muss aber ich denke den rest hab ich soweit ausgearbeitet

sdkconfig.old

@@ -3,25 +3,37 @@
 # Espressif IoT Development Framework (ESP-IDF) 5.5.0 Project Configuration
 #
 CONFIG_SOC_ADC_SUPPORTED=y
-CONFIG_SOC_DEDICATED_GPIO_SUPPORTED=y
 CONFIG_SOC_UART_SUPPORTED=y
+CONFIG_SOC_PCNT_SUPPORTED=y
+CONFIG_SOC_PHY_SUPPORTED=y
+CONFIG_SOC_WIFI_SUPPORTED=y
+CONFIG_SOC_TWAI_SUPPORTED=y
 CONFIG_SOC_GDMA_SUPPORTED=y
 CONFIG_SOC_AHB_GDMA_SUPPORTED=y
 CONFIG_SOC_GPTIMER_SUPPORTED=y
-CONFIG_SOC_TWAI_SUPPORTED=y
+CONFIG_SOC_LCDCAM_SUPPORTED=y
+CONFIG_SOC_LCDCAM_I80_LCD_SUPPORTED=y
+CONFIG_SOC_LCDCAM_RGB_LCD_SUPPORTED=y
+CONFIG_SOC_MCPWM_SUPPORTED=y
+CONFIG_SOC_DEDICATED_GPIO_SUPPORTED=y
+CONFIG_SOC_CACHE_SUPPORT_WRAP=y
+CONFIG_SOC_ULP_SUPPORTED=y
+CONFIG_SOC_ULP_FSM_SUPPORTED=y
+CONFIG_SOC_RISCV_COPROC_SUPPORTED=y
 CONFIG_SOC_BT_SUPPORTED=y
-CONFIG_SOC_ASYNC_MEMCPY_SUPPORTED=y
+CONFIG_SOC_USB_OTG_SUPPORTED=y
 CONFIG_SOC_USB_SERIAL_JTAG_SUPPORTED=y
-CONFIG_SOC_TEMP_SENSOR_SUPPORTED=y
-CONFIG_SOC_XT_WDT_SUPPORTED=y
-CONFIG_SOC_PHY_SUPPORTED=y
-CONFIG_SOC_WIFI_SUPPORTED=y
+CONFIG_SOC_CCOMP_TIMER_SUPPORTED=y
+CONFIG_SOC_ASYNC_MEMCPY_SUPPORTED=y
 CONFIG_SOC_SUPPORTS_SECURE_DL_MODE=y
 CONFIG_SOC_EFUSE_KEY_PURPOSE_FIELD=y
-CONFIG_SOC_EFUSE_HAS_EFUSE_RST_BUG=y
 CONFIG_SOC_EFUSE_SUPPORTED=y
+CONFIG_SOC_SDMMC_HOST_SUPPORTED=y
 CONFIG_SOC_RTC_FAST_MEM_SUPPORTED=y
+CONFIG_SOC_RTC_SLOW_MEM_SUPPORTED=y
 CONFIG_SOC_RTC_MEM_SUPPORTED=y
+CONFIG_SOC_PSRAM_DMA_CAPABLE=y
+CONFIG_SOC_XT_WDT_SUPPORTED=y
 CONFIG_SOC_I2S_SUPPORTED=y
 CONFIG_SOC_RMT_SUPPORTED=y
 CONFIG_SOC_SDM_SUPPORTED=y
@@ -30,6 +42,7 @@ CONFIG_SOC_LEDC_SUPPORTED=y
 CONFIG_SOC_I2C_SUPPORTED=y
 CONFIG_SOC_SYSTIMER_SUPPORTED=y
 CONFIG_SOC_SUPPORT_COEXISTENCE=y
+CONFIG_SOC_TEMP_SENSOR_SUPPORTED=y
 CONFIG_SOC_AES_SUPPORTED=y
 CONFIG_SOC_MPI_SUPPORTED=y
 CONFIG_SOC_SHA_SUPPORTED=y
@@ -38,9 +51,10 @@ CONFIG_SOC_DIG_SIGN_SUPPORTED=y
 CONFIG_SOC_FLASH_ENC_SUPPORTED=y
 CONFIG_SOC_SECURE_BOOT_SUPPORTED=y
 CONFIG_SOC_MEMPROT_SUPPORTED=y
+CONFIG_SOC_TOUCH_SENSOR_SUPPORTED=y
 CONFIG_SOC_BOD_SUPPORTED=y
 CONFIG_SOC_CLK_TREE_SUPPORTED=y
-CONFIG_SOC_ASSIST_DEBUG_SUPPORTED=y
+CONFIG_SOC_MPU_SUPPORTED=y
 CONFIG_SOC_WDT_SUPPORTED=y
 CONFIG_SOC_SPI_FLASH_SUPPORTED=y
 CONFIG_SOC_RNG_SUPPORTED=y
@@ -48,21 +62,20 @@ CONFIG_SOC_LIGHT_SLEEP_SUPPORTED=y
 CONFIG_SOC_DEEP_SLEEP_SUPPORTED=y
 CONFIG_SOC_LP_PERIPH_SHARE_INTERRUPT=y
 CONFIG_SOC_PM_SUPPORTED=y
+CONFIG_SOC_SIMD_INSTRUCTION_SUPPORTED=y
 CONFIG_SOC_XTAL_SUPPORT_40M=y
-CONFIG_SOC_AES_SUPPORT_DMA=y
-CONFIG_SOC_AES_GDMA=y
-CONFIG_SOC_AES_SUPPORT_AES_128=y
-CONFIG_SOC_AES_SUPPORT_AES_256=y
+CONFIG_SOC_APPCPU_HAS_CLOCK_GATING_BUG=y
+CONFIG_SOC_ADC_RTC_CTRL_SUPPORTED=y
 CONFIG_SOC_ADC_DIG_CTRL_SUPPORTED=y
 CONFIG_SOC_ADC_ARBITER_SUPPORTED=y
 CONFIG_SOC_ADC_DIG_IIR_FILTER_SUPPORTED=y
 CONFIG_SOC_ADC_MONITOR_SUPPORTED=y
 CONFIG_SOC_ADC_DMA_SUPPORTED=y
 CONFIG_SOC_ADC_PERIPH_NUM=2
-CONFIG_SOC_ADC_MAX_CHANNEL_NUM=5
+CONFIG_SOC_ADC_MAX_CHANNEL_NUM=10
 CONFIG_SOC_ADC_ATTEN_NUM=4
-CONFIG_SOC_ADC_DIGI_CONTROLLER_NUM=1
-CONFIG_SOC_ADC_PATT_LEN_MAX=8
+CONFIG_SOC_ADC_DIGI_CONTROLLER_NUM=2
+CONFIG_SOC_ADC_PATT_LEN_MAX=24
 CONFIG_SOC_ADC_DIGI_MIN_BITWIDTH=12
 CONFIG_SOC_ADC_DIGI_MAX_BITWIDTH=12
 CONFIG_SOC_ADC_DIGI_RESULT_BYTES=4
@@ -78,40 +91,43 @@ CONFIG_SOC_ADC_SELF_HW_CALI_SUPPORTED=y
 CONFIG_SOC_ADC_SHARED_POWER=y
 CONFIG_SOC_APB_BACKUP_DMA=y
 CONFIG_SOC_BROWNOUT_RESET_SUPPORTED=y
-CONFIG_SOC_SHARED_IDCACHE_SUPPORTED=y
-CONFIG_SOC_CACHE_MEMORY_IBANK_SIZE=0x4000
-CONFIG_SOC_CPU_CORES_NUM=1
+CONFIG_SOC_CACHE_WRITEBACK_SUPPORTED=y
+CONFIG_SOC_CACHE_FREEZE_SUPPORTED=y
+CONFIG_SOC_CACHE_ACS_INVALID_STATE_ON_PANIC=y
+CONFIG_SOC_CPU_CORES_NUM=2
 CONFIG_SOC_CPU_INTR_NUM=32
-CONFIG_SOC_CPU_HAS_FLEXIBLE_INTC=y
-CONFIG_SOC_CPU_HAS_CSR_PC=y
-CONFIG_SOC_CPU_BREAKPOINTS_NUM=8
-CONFIG_SOC_CPU_WATCHPOINTS_NUM=8
-CONFIG_SOC_CPU_WATCHPOINT_MAX_REGION_SIZE=0x80000000
-CONFIG_SOC_DS_SIGNATURE_MAX_BIT_LEN=3072
+CONFIG_SOC_CPU_HAS_FPU=y
+CONFIG_SOC_HP_CPU_HAS_MULTIPLE_CORES=y
+CONFIG_SOC_CPU_BREAKPOINTS_NUM=2
+CONFIG_SOC_CPU_WATCHPOINTS_NUM=2
+CONFIG_SOC_CPU_WATCHPOINT_MAX_REGION_SIZE=64
+CONFIG_SOC_SIMD_PREFERRED_DATA_ALIGNMENT=16
+CONFIG_SOC_DS_SIGNATURE_MAX_BIT_LEN=4096
 CONFIG_SOC_DS_KEY_PARAM_MD_IV_LENGTH=16
 CONFIG_SOC_DS_KEY_CHECK_MAX_WAIT_US=1100
 CONFIG_SOC_AHB_GDMA_VERSION=1
 CONFIG_SOC_GDMA_NUM_GROUPS_MAX=1
-CONFIG_SOC_GDMA_PAIRS_PER_GROUP_MAX=3
+CONFIG_SOC_GDMA_PAIRS_PER_GROUP=5
+CONFIG_SOC_GDMA_PAIRS_PER_GROUP_MAX=5
+CONFIG_SOC_AHB_GDMA_SUPPORT_PSRAM=y
 CONFIG_SOC_GPIO_PORT=1
-CONFIG_SOC_GPIO_PIN_COUNT=22
+CONFIG_SOC_GPIO_PIN_COUNT=49
 CONFIG_SOC_GPIO_SUPPORT_PIN_GLITCH_FILTER=y
 CONFIG_SOC_GPIO_FILTER_CLK_SUPPORT_APB=y
+CONFIG_SOC_GPIO_SUPPORT_RTC_INDEPENDENT=y
 CONFIG_SOC_GPIO_SUPPORT_FORCE_HOLD=y
-CONFIG_SOC_GPIO_SUPPORT_DEEPSLEEP_WAKEUP=y
-CONFIG_SOC_GPIO_IN_RANGE_MAX=21
-CONFIG_SOC_GPIO_OUT_RANGE_MAX=21
-CONFIG_SOC_GPIO_DEEP_SLEEP_WAKE_VALID_GPIO_MASK=0
-CONFIG_SOC_GPIO_DEEP_SLEEP_WAKE_SUPPORTED_PIN_CNT=6
-CONFIG_SOC_GPIO_VALID_DIGITAL_IO_PAD_MASK=0x00000000003FFFC0
-CONFIG_SOC_GPIO_CLOCKOUT_BY_GPIO_MATRIX=y
+CONFIG_SOC_GPIO_VALID_GPIO_MASK=0x1FFFFFFFFFFFF
+CONFIG_SOC_GPIO_IN_RANGE_MAX=48
+CONFIG_SOC_GPIO_OUT_RANGE_MAX=48
+CONFIG_SOC_GPIO_VALID_DIGITAL_IO_PAD_MASK=0x0001FFFFFC000000
+CONFIG_SOC_GPIO_CLOCKOUT_BY_IO_MUX=y
 CONFIG_SOC_GPIO_CLOCKOUT_CHANNEL_NUM=3
 CONFIG_SOC_GPIO_SUPPORT_HOLD_IO_IN_DSLP=y
 CONFIG_SOC_DEDIC_GPIO_OUT_CHANNELS_NUM=8
 CONFIG_SOC_DEDIC_GPIO_IN_CHANNELS_NUM=8
-CONFIG_SOC_DEDIC_PERIPH_ALWAYS_ENABLE=y
-CONFIG_SOC_I2C_NUM=1
-CONFIG_SOC_HP_I2C_NUM=1
+CONFIG_SOC_DEDIC_GPIO_OUT_AUTO_ENABLE=y
+CONFIG_SOC_I2C_NUM=2
+CONFIG_SOC_HP_I2C_NUM=2
 CONFIG_SOC_I2C_FIFO_LEN=32
 CONFIG_SOC_I2C_CMD_REG_NUM=8
 CONFIG_SOC_I2C_SUPPORT_SLAVE=y
@@ -120,9 +136,9 @@ CONFIG_SOC_I2C_SUPPORT_XTAL=y
 CONFIG_SOC_I2C_SUPPORT_RTC=y
 CONFIG_SOC_I2C_SUPPORT_10BIT_ADDR=y
 CONFIG_SOC_I2C_SLAVE_SUPPORT_BROADCAST=y
-CONFIG_SOC_I2C_SLAVE_CAN_GET_STRETCH_CAUSE=y
 CONFIG_SOC_I2C_SLAVE_SUPPORT_I2CRAM_ACCESS=y
-CONFIG_SOC_I2S_NUM=1
+CONFIG_SOC_I2C_SLAVE_CAN_GET_STRETCH_CAUSE=y
+CONFIG_SOC_I2S_NUM=2
 CONFIG_SOC_I2S_HW_VERSION_2=y
 CONFIG_SOC_I2S_SUPPORTS_XTAL=y
 CONFIG_SOC_I2S_SUPPORTS_PLL_F160M=y
@@ -131,52 +147,74 @@ CONFIG_SOC_I2S_SUPPORTS_PDM=y
 CONFIG_SOC_I2S_SUPPORTS_PDM_TX=y
 CONFIG_SOC_I2S_SUPPORTS_PCM2PDM=y
 CONFIG_SOC_I2S_SUPPORTS_PDM_RX=y
+CONFIG_SOC_I2S_SUPPORTS_PDM2PCM=y
 CONFIG_SOC_I2S_PDM_MAX_TX_LINES=2
-CONFIG_SOC_I2S_PDM_MAX_RX_LINES=1
+CONFIG_SOC_I2S_PDM_MAX_RX_LINES=4
 CONFIG_SOC_I2S_SUPPORTS_TDM=y
 CONFIG_SOC_LEDC_SUPPORT_APB_CLOCK=y
 CONFIG_SOC_LEDC_SUPPORT_XTAL_CLOCK=y
 CONFIG_SOC_LEDC_TIMER_NUM=4
-CONFIG_SOC_LEDC_CHANNEL_NUM=6
+CONFIG_SOC_LEDC_CHANNEL_NUM=8
 CONFIG_SOC_LEDC_TIMER_BIT_WIDTH=14
 CONFIG_SOC_LEDC_SUPPORT_FADE_STOP=y
+CONFIG_SOC_MCPWM_GROUPS=2
+CONFIG_SOC_MCPWM_TIMERS_PER_GROUP=3
+CONFIG_SOC_MCPWM_OPERATORS_PER_GROUP=3
+CONFIG_SOC_MCPWM_COMPARATORS_PER_OPERATOR=2
+CONFIG_SOC_MCPWM_GENERATORS_PER_OPERATOR=2
+CONFIG_SOC_MCPWM_TRIGGERS_PER_OPERATOR=2
+CONFIG_SOC_MCPWM_GPIO_FAULTS_PER_GROUP=3
+CONFIG_SOC_MCPWM_CAPTURE_TIMERS_PER_GROUP=y
+CONFIG_SOC_MCPWM_CAPTURE_CHANNELS_PER_TIMER=3
+CONFIG_SOC_MCPWM_GPIO_SYNCHROS_PER_GROUP=3
+CONFIG_SOC_MCPWM_SWSYNC_CAN_PROPAGATE=y
 CONFIG_SOC_MMU_LINEAR_ADDRESS_REGION_NUM=1
 CONFIG_SOC_MMU_PERIPH_NUM=1
 CONFIG_SOC_MPU_MIN_REGION_SIZE=0x20000000
 CONFIG_SOC_MPU_REGIONS_MAX_NUM=8
+CONFIG_SOC_PCNT_GROUPS=1
+CONFIG_SOC_PCNT_UNITS_PER_GROUP=4
+CONFIG_SOC_PCNT_CHANNELS_PER_UNIT=2
+CONFIG_SOC_PCNT_THRES_POINT_PER_UNIT=2
 CONFIG_SOC_RMT_GROUPS=1
-CONFIG_SOC_RMT_TX_CANDIDATES_PER_GROUP=2
-CONFIG_SOC_RMT_RX_CANDIDATES_PER_GROUP=2
-CONFIG_SOC_RMT_CHANNELS_PER_GROUP=4
+CONFIG_SOC_RMT_TX_CANDIDATES_PER_GROUP=4
+CONFIG_SOC_RMT_RX_CANDIDATES_PER_GROUP=4
+CONFIG_SOC_RMT_CHANNELS_PER_GROUP=8
 CONFIG_SOC_RMT_MEM_WORDS_PER_CHANNEL=48
 CONFIG_SOC_RMT_SUPPORT_RX_PINGPONG=y
 CONFIG_SOC_RMT_SUPPORT_RX_DEMODULATION=y
 CONFIG_SOC_RMT_SUPPORT_TX_ASYNC_STOP=y
 CONFIG_SOC_RMT_SUPPORT_TX_LOOP_COUNT=y
+CONFIG_SOC_RMT_SUPPORT_TX_LOOP_AUTO_STOP=y
 CONFIG_SOC_RMT_SUPPORT_TX_SYNCHRO=y
 CONFIG_SOC_RMT_SUPPORT_TX_CARRIER_DATA_ONLY=y
 CONFIG_SOC_RMT_SUPPORT_XTAL=y
-CONFIG_SOC_RMT_SUPPORT_APB=y
 CONFIG_SOC_RMT_SUPPORT_RC_FAST=y
+CONFIG_SOC_RMT_SUPPORT_APB=y
+CONFIG_SOC_RMT_SUPPORT_DMA=y
+CONFIG_SOC_LCD_I80_SUPPORTED=y
+CONFIG_SOC_LCD_RGB_SUPPORTED=y
+CONFIG_SOC_LCD_I80_BUSES=1
+CONFIG_SOC_LCD_RGB_PANELS=1
+CONFIG_SOC_LCD_I80_BUS_WIDTH=16
+CONFIG_SOC_LCD_RGB_DATA_WIDTH=16
+CONFIG_SOC_LCD_SUPPORT_RGB_YUV_CONV=y
+CONFIG_SOC_LCDCAM_I80_NUM_BUSES=1
+CONFIG_SOC_LCDCAM_I80_BUS_WIDTH=16
+CONFIG_SOC_LCDCAM_RGB_NUM_PANELS=1
+CONFIG_SOC_LCDCAM_RGB_DATA_WIDTH=16
 CONFIG_SOC_RTC_CNTL_CPU_PD_DMA_BUS_WIDTH=128
-CONFIG_SOC_RTC_CNTL_CPU_PD_REG_FILE_NUM=108
-CONFIG_SOC_SLEEP_SYSTIMER_STALL_WORKAROUND=y
-CONFIG_SOC_SLEEP_TGWDT_STOP_WORKAROUND=y
-CONFIG_SOC_RTCIO_PIN_COUNT=0
-CONFIG_SOC_MPI_MEM_BLOCKS_NUM=4
-CONFIG_SOC_MPI_OPERATIONS_NUM=3
-CONFIG_SOC_RSA_MAX_BIT_LEN=3072
-CONFIG_SOC_SHA_DMA_MAX_BUFFER_SIZE=3968
-CONFIG_SOC_SHA_SUPPORT_DMA=y
-CONFIG_SOC_SHA_SUPPORT_RESUME=y
-CONFIG_SOC_SHA_GDMA=y
-CONFIG_SOC_SHA_SUPPORT_SHA1=y
-CONFIG_SOC_SHA_SUPPORT_SHA224=y
-CONFIG_SOC_SHA_SUPPORT_SHA256=y
-CONFIG_SOC_SDM_GROUPS=1
-CONFIG_SOC_SDM_CHANNELS_PER_GROUP=4
+CONFIG_SOC_RTC_CNTL_CPU_PD_REG_FILE_NUM=549
+CONFIG_SOC_RTC_CNTL_TAGMEM_PD_DMA_BUS_WIDTH=128
+CONFIG_SOC_RTCIO_PIN_COUNT=22
+CONFIG_SOC_RTCIO_INPUT_OUTPUT_SUPPORTED=y
+CONFIG_SOC_RTCIO_HOLD_SUPPORTED=y
+CONFIG_SOC_RTCIO_WAKE_SUPPORTED=y
+CONFIG_SOC_LP_IO_CLOCK_IS_INDEPENDENT=y
+CONFIG_SOC_SDM_GROUPS=y
+CONFIG_SOC_SDM_CHANNELS_PER_GROUP=8
 CONFIG_SOC_SDM_CLK_SUPPORT_APB=y
-CONFIG_SOC_SPI_PERIPH_NUM=2
+CONFIG_SOC_SPI_PERIPH_NUM=3
 CONFIG_SOC_SPI_MAX_CS_NUM=6
 CONFIG_SOC_SPI_MAXIMUM_BUFFER_SIZE=64
 CONFIG_SOC_SPI_SUPPORT_DDRCLK=y
@@ -187,24 +225,19 @@ CONFIG_SOC_SPI_SUPPORT_SLAVE_HD_VER2=y
 CONFIG_SOC_SPI_SUPPORT_CLK_APB=y
 CONFIG_SOC_SPI_SUPPORT_CLK_XTAL=y
 CONFIG_SOC_SPI_PERIPH_SUPPORT_CONTROL_DUMMY_OUT=y
+CONFIG_SOC_MEMSPI_IS_INDEPENDENT=y
+CONFIG_SOC_SPI_MAX_PRE_DIVIDER=16
+CONFIG_SOC_SPI_SUPPORT_OCT=y
 CONFIG_SOC_SPI_SCT_SUPPORTED=y
 CONFIG_SOC_SPI_SCT_REG_NUM=14
 CONFIG_SOC_SPI_SCT_BUFFER_NUM_MAX=y
 CONFIG_SOC_SPI_SCT_CONF_BITLEN_MAX=0x3FFFA
-CONFIG_SOC_MEMSPI_IS_INDEPENDENT=y
-CONFIG_SOC_SPI_MAX_PRE_DIVIDER=16
-CONFIG_SOC_SPI_MEM_SUPPORT_AUTO_WAIT_IDLE=y
-CONFIG_SOC_SPI_MEM_SUPPORT_AUTO_SUSPEND=y
-CONFIG_SOC_SPI_MEM_SUPPORT_AUTO_RESUME=y
-CONFIG_SOC_SPI_MEM_SUPPORT_IDLE_INTR=y
-CONFIG_SOC_SPI_MEM_SUPPORT_SW_SUSPEND=y
-CONFIG_SOC_SPI_MEM_SUPPORT_CHECK_SUS=y
-CONFIG_SOC_SPI_MEM_SUPPORT_CONFIG_GPIO_BY_EFUSE=y
-CONFIG_SOC_SPI_MEM_SUPPORT_WRAP=y
+CONFIG_SOC_MEMSPI_SRC_FREQ_120M_SUPPORTED=y
 CONFIG_SOC_MEMSPI_SRC_FREQ_80M_SUPPORTED=y
 CONFIG_SOC_MEMSPI_SRC_FREQ_40M_SUPPORTED=y
-CONFIG_SOC_MEMSPI_SRC_FREQ_26M_SUPPORTED=y
 CONFIG_SOC_MEMSPI_SRC_FREQ_20M_SUPPORTED=y
+CONFIG_SOC_SPIRAM_SUPPORTED=y
+CONFIG_SOC_SPIRAM_XIP_SUPPORTED=y
 CONFIG_SOC_SYSTIMER_COUNTER_NUM=2
 CONFIG_SOC_SYSTIMER_ALARM_NUM=3
 CONFIG_SOC_SYSTIMER_BIT_WIDTH_LO=32
@@ -213,57 +246,75 @@ CONFIG_SOC_SYSTIMER_FIXED_DIVIDER=y
 CONFIG_SOC_SYSTIMER_INT_LEVEL=y
 CONFIG_SOC_SYSTIMER_ALARM_MISS_COMPENSATE=y
 CONFIG_SOC_TIMER_GROUPS=2
-CONFIG_SOC_TIMER_GROUP_TIMERS_PER_GROUP=1
+CONFIG_SOC_TIMER_GROUP_TIMERS_PER_GROUP=2
 CONFIG_SOC_TIMER_GROUP_COUNTER_BIT_WIDTH=54
 CONFIG_SOC_TIMER_GROUP_SUPPORT_XTAL=y
 CONFIG_SOC_TIMER_GROUP_SUPPORT_APB=y
-CONFIG_SOC_TIMER_GROUP_TOTAL_TIMERS=2
+CONFIG_SOC_TIMER_GROUP_TOTAL_TIMERS=4
 CONFIG_SOC_LP_TIMER_BIT_WIDTH_LO=32
 CONFIG_SOC_LP_TIMER_BIT_WIDTH_HI=16
-CONFIG_SOC_MWDT_SUPPORT_XTAL=y
+CONFIG_SOC_TOUCH_SENSOR_VERSION=2
+CONFIG_SOC_TOUCH_SENSOR_NUM=15
+CONFIG_SOC_TOUCH_MIN_CHAN_ID=y
+CONFIG_SOC_TOUCH_MAX_CHAN_ID=14
+CONFIG_SOC_TOUCH_SUPPORT_BENCHMARK=y
+CONFIG_SOC_TOUCH_SUPPORT_SLEEP_WAKEUP=y
+CONFIG_SOC_TOUCH_SUPPORT_WATERPROOF=y
+CONFIG_SOC_TOUCH_SUPPORT_PROX_SENSING=y
+CONFIG_SOC_TOUCH_SUPPORT_DENOISE_CHAN=y
+CONFIG_SOC_TOUCH_PROXIMITY_CHANNEL_NUM=3
+CONFIG_SOC_TOUCH_PROXIMITY_MEAS_DONE_SUPPORTED=y
+CONFIG_SOC_TOUCH_SAMPLE_CFG_NUM=1
 CONFIG_SOC_TWAI_CONTROLLER_NUM=1
 CONFIG_SOC_TWAI_CLK_SUPPORT_APB=y
 CONFIG_SOC_TWAI_BRP_MIN=2
 CONFIG_SOC_TWAI_BRP_MAX=16384
 CONFIG_SOC_TWAI_SUPPORTS_RX_STATUS=y
-CONFIG_SOC_EFUSE_DIS_DOWNLOAD_ICACHE=y
-CONFIG_SOC_EFUSE_DIS_PAD_JTAG=y
-CONFIG_SOC_EFUSE_DIS_USB_JTAG=y
-CONFIG_SOC_EFUSE_DIS_DIRECT_BOOT=y
-CONFIG_SOC_EFUSE_SOFT_DIS_JTAG=y
-CONFIG_SOC_EFUSE_DIS_ICACHE=y
-CONFIG_SOC_EFUSE_BLOCK9_KEY_PURPOSE_QUIRK=y
-CONFIG_SOC_SECURE_BOOT_V2_RSA=y
-CONFIG_SOC_EFUSE_SECURE_BOOT_KEY_DIGESTS=3
-CONFIG_SOC_EFUSE_REVOKE_BOOT_KEY_DIGESTS=y
-CONFIG_SOC_SUPPORT_SECURE_BOOT_REVOKE_KEY=y
-CONFIG_SOC_FLASH_ENCRYPTED_XTS_AES_BLOCK_MAX=32
-CONFIG_SOC_FLASH_ENCRYPTION_XTS_AES=y
-CONFIG_SOC_FLASH_ENCRYPTION_XTS_AES_128=y
-CONFIG_SOC_MEMPROT_CPU_PREFETCH_PAD_SIZE=16
-CONFIG_SOC_MEMPROT_MEM_ALIGN_SIZE=512
-CONFIG_SOC_UART_NUM=2
-CONFIG_SOC_UART_HP_NUM=2
+CONFIG_SOC_UART_NUM=3
+CONFIG_SOC_UART_HP_NUM=3
 CONFIG_SOC_UART_FIFO_LEN=128
 CONFIG_SOC_UART_BITRATE_MAX=5000000
+CONFIG_SOC_UART_SUPPORT_FSM_TX_WAIT_SEND=y
+CONFIG_SOC_UART_SUPPORT_WAKEUP_INT=y
 CONFIG_SOC_UART_SUPPORT_APB_CLK=y
 CONFIG_SOC_UART_SUPPORT_RTC_CLK=y
 CONFIG_SOC_UART_SUPPORT_XTAL_CLK=y
-CONFIG_SOC_UART_SUPPORT_WAKEUP_INT=y
-CONFIG_SOC_UART_SUPPORT_FSM_TX_WAIT_SEND=y
 CONFIG_SOC_UART_WAKEUP_SUPPORT_ACTIVE_THRESH_MODE=y
-CONFIG_SOC_COEX_HW_PTI=y
-CONFIG_SOC_PHY_DIG_REGS_MEM_SIZE=21
-CONFIG_SOC_MAC_BB_PD_MEM_SIZE=192
-CONFIG_SOC_WIFI_LIGHT_SLEEP_CLK_WIDTH=12
+CONFIG_SOC_USB_OTG_PERIPH_NUM=1
+CONFIG_SOC_SHA_DMA_MAX_BUFFER_SIZE=3968
+CONFIG_SOC_SHA_SUPPORT_DMA=y
+CONFIG_SOC_SHA_SUPPORT_RESUME=y
+CONFIG_SOC_SHA_GDMA=y
+CONFIG_SOC_SHA_SUPPORT_SHA1=y
+CONFIG_SOC_SHA_SUPPORT_SHA224=y
+CONFIG_SOC_SHA_SUPPORT_SHA256=y
+CONFIG_SOC_SHA_SUPPORT_SHA384=y
+CONFIG_SOC_SHA_SUPPORT_SHA512=y
+CONFIG_SOC_SHA_SUPPORT_SHA512_224=y
+CONFIG_SOC_SHA_SUPPORT_SHA512_256=y
+CONFIG_SOC_SHA_SUPPORT_SHA512_T=y
+CONFIG_SOC_MPI_MEM_BLOCKS_NUM=4
+CONFIG_SOC_MPI_OPERATIONS_NUM=3
+CONFIG_SOC_RSA_MAX_BIT_LEN=4096
+CONFIG_SOC_AES_SUPPORT_DMA=y
+CONFIG_SOC_AES_GDMA=y
+CONFIG_SOC_AES_SUPPORT_AES_128=y
+CONFIG_SOC_AES_SUPPORT_AES_256=y
+CONFIG_SOC_PM_SUPPORT_EXT0_WAKEUP=y
+CONFIG_SOC_PM_SUPPORT_EXT1_WAKEUP=y
+CONFIG_SOC_PM_SUPPORT_EXT_WAKEUP=y
 CONFIG_SOC_PM_SUPPORT_WIFI_WAKEUP=y
 CONFIG_SOC_PM_SUPPORT_BT_WAKEUP=y
+CONFIG_SOC_PM_SUPPORT_TOUCH_SENSOR_WAKEUP=y
 CONFIG_SOC_PM_SUPPORT_CPU_PD=y
-CONFIG_SOC_PM_SUPPORT_WIFI_PD=y
-CONFIG_SOC_PM_SUPPORT_BT_PD=y
+CONFIG_SOC_PM_SUPPORT_TAGMEM_PD=y
+CONFIG_SOC_PM_SUPPORT_RTC_PERIPH_PD=y
 CONFIG_SOC_PM_SUPPORT_RC_FAST_PD=y
 CONFIG_SOC_PM_SUPPORT_VDDSDIO_PD=y
 CONFIG_SOC_PM_SUPPORT_MAC_BB_PD=y
+CONFIG_SOC_PM_SUPPORT_MODEM_PD=y
+CONFIG_SOC_CONFIGURABLE_VDDSDIO_SUPPORTED=y
+CONFIG_SOC_PM_SUPPORT_DEEPSLEEP_CHECK_STUB_ONLY=y
 CONFIG_SOC_PM_CPU_RETENTION_BY_RTCCNTL=y
 CONFIG_SOC_PM_MODEM_RETENTION_BY_BACKUPDMA=y
 CONFIG_SOC_PM_MODEM_PD_BY_SW=y
@@ -272,8 +323,46 @@ CONFIG_SOC_RTC_SLOW_CLK_SUPPORT_RC_FAST_D256=y
 CONFIG_SOC_CLK_RC_FAST_SUPPORT_CALIBRATION=y
 CONFIG_SOC_CLK_XTAL32K_SUPPORTED=y
 CONFIG_SOC_CLK_LP_FAST_SUPPORT_XTAL_D2=y
+CONFIG_SOC_EFUSE_DIS_DOWNLOAD_ICACHE=y
+CONFIG_SOC_EFUSE_DIS_DOWNLOAD_DCACHE=y
+CONFIG_SOC_EFUSE_HARD_DIS_JTAG=y
+CONFIG_SOC_EFUSE_DIS_USB_JTAG=y
+CONFIG_SOC_EFUSE_SOFT_DIS_JTAG=y
+CONFIG_SOC_EFUSE_DIS_DIRECT_BOOT=y
+CONFIG_SOC_EFUSE_DIS_ICACHE=y
+CONFIG_SOC_EFUSE_BLOCK9_KEY_PURPOSE_QUIRK=y
+CONFIG_SOC_SECURE_BOOT_V2_RSA=y
+CONFIG_SOC_EFUSE_SECURE_BOOT_KEY_DIGESTS=3
+CONFIG_SOC_EFUSE_REVOKE_BOOT_KEY_DIGESTS=y
+CONFIG_SOC_SUPPORT_SECURE_BOOT_REVOKE_KEY=y
+CONFIG_SOC_FLASH_ENCRYPTED_XTS_AES_BLOCK_MAX=64
+CONFIG_SOC_FLASH_ENCRYPTION_XTS_AES=y
+CONFIG_SOC_FLASH_ENCRYPTION_XTS_AES_OPTIONS=y
+CONFIG_SOC_FLASH_ENCRYPTION_XTS_AES_128=y
+CONFIG_SOC_FLASH_ENCRYPTION_XTS_AES_256=y
+CONFIG_SOC_MEMPROT_CPU_PREFETCH_PAD_SIZE=16
+CONFIG_SOC_MEMPROT_MEM_ALIGN_SIZE=256
+CONFIG_SOC_PHY_DIG_REGS_MEM_SIZE=21
+CONFIG_SOC_MAC_BB_PD_MEM_SIZE=192
+CONFIG_SOC_WIFI_LIGHT_SLEEP_CLK_WIDTH=12
+CONFIG_SOC_SPI_MEM_SUPPORT_AUTO_WAIT_IDLE=y
+CONFIG_SOC_SPI_MEM_SUPPORT_AUTO_SUSPEND=y
+CONFIG_SOC_SPI_MEM_SUPPORT_AUTO_RESUME=y
+CONFIG_SOC_SPI_MEM_SUPPORT_SW_SUSPEND=y
+CONFIG_SOC_SPI_MEM_SUPPORT_OPI_MODE=y
+CONFIG_SOC_SPI_MEM_SUPPORT_TIMING_TUNING=y
+CONFIG_SOC_SPI_MEM_SUPPORT_CONFIG_GPIO_BY_EFUSE=y
+CONFIG_SOC_SPI_MEM_SUPPORT_WRAP=y
+CONFIG_SOC_MEMSPI_TIMING_TUNING_BY_MSPI_DELAY=y
+CONFIG_SOC_MEMSPI_CORE_CLK_SHARED_WITH_PSRAM=y
+CONFIG_SOC_SPI_MEM_SUPPORT_CACHE_32BIT_ADDR_MAP=y
+CONFIG_SOC_COEX_HW_PTI=y
+CONFIG_SOC_EXTERNAL_COEX_LEADER_TX_LINE=y
+CONFIG_SOC_SDMMC_USE_GPIO_MATRIX=y
+CONFIG_SOC_SDMMC_NUM_SLOTS=2
+CONFIG_SOC_SDMMC_SUPPORT_XTAL_CLOCK=y
+CONFIG_SOC_SDMMC_DELAY_PHASE_NUM=4
 CONFIG_SOC_TEMPERATURE_SENSOR_SUPPORT_FAST_RC=y
-CONFIG_SOC_TEMPERATURE_SENSOR_SUPPORT_XTAL=y
 CONFIG_SOC_WIFI_HW_TSF=y
 CONFIG_SOC_WIFI_FTM_SUPPORT=y
 CONFIG_SOC_WIFI_GCMP_SUPPORT=y
@@ -287,16 +376,17 @@ CONFIG_SOC_BLE_MESH_SUPPORTED=y
 CONFIG_SOC_BLE_50_SUPPORTED=y
 CONFIG_SOC_BLE_DEVICE_PRIVACY_SUPPORTED=y
 CONFIG_SOC_BLUFI_SUPPORTED=y
+CONFIG_SOC_ULP_HAS_ADC=y
 CONFIG_SOC_PHY_COMBO_MODULE=y
 CONFIG_IDF_CMAKE=y
 CONFIG_IDF_TOOLCHAIN="gcc"
 CONFIG_IDF_TOOLCHAIN_GCC=y
-CONFIG_IDF_TARGET_ARCH_RISCV=y
-CONFIG_IDF_TARGET_ARCH="riscv"
-CONFIG_IDF_TARGET="esp32c3"
+CONFIG_IDF_TARGET_ARCH_XTENSA=y
+CONFIG_IDF_TARGET_ARCH="xtensa"
+CONFIG_IDF_TARGET="esp32s3"
 CONFIG_IDF_INIT_VERSION="5.5.0"
-CONFIG_IDF_TARGET_ESP32C3=y
-CONFIG_IDF_FIRMWARE_CHIP_ID=0x0005
+CONFIG_IDF_TARGET_ESP32S3=y
+CONFIG_IDF_FIRMWARE_CHIP_ID=0x0009
 
 #
 # Build type
@@ -366,6 +456,7 @@ CONFIG_BOOTLOADER_LOG_TIMESTAMP_SOURCE_CPU_TICKS=y
 CONFIG_BOOTLOADER_FLASH_XMC_SUPPORT=y
 # end of Serial Flash Configurations
 
+CONFIG_BOOTLOADER_VDDSDIO_BOOST_1_9V=y
 # CONFIG_BOOTLOADER_FACTORY_RESET is not set
 # CONFIG_BOOTLOADER_APP_TEST is not set
 CONFIG_BOOTLOADER_REGION_PROTECTION_ENABLE=y
@@ -405,11 +496,13 @@ CONFIG_ESP_ROM_HAS_CRC_BE=y
 CONFIG_ESP_ROM_HAS_MZ_CRC32=y
 CONFIG_ESP_ROM_HAS_JPEG_DECODE=y
 CONFIG_ESP_ROM_UART_CLK_IS_XTAL=y
-CONFIG_ESP_ROM_USB_SERIAL_DEVICE_NUM=3
 CONFIG_ESP_ROM_HAS_RETARGETABLE_LOCKING=y
+CONFIG_ESP_ROM_USB_OTG_NUM=3
+CONFIG_ESP_ROM_USB_SERIAL_DEVICE_NUM=4
 CONFIG_ESP_ROM_HAS_ERASE_0_REGION_BUG=y
 CONFIG_ESP_ROM_HAS_ENCRYPTED_WRITES_USING_LEGACY_DRV=y
 CONFIG_ESP_ROM_GET_CLK_FREQ=y
+CONFIG_ESP_ROM_HAS_HAL_WDT=y
 CONFIG_ESP_ROM_NEEDS_SWSETUP_WORKAROUND=y
 CONFIG_ESP_ROM_HAS_LAYOUT_TABLE=y
 CONFIG_ESP_ROM_HAS_SPI_FLASH=y
@@ -419,10 +512,13 @@ CONFIG_ESP_ROM_HAS_NEWLIB_NANO_FORMAT=y
 CONFIG_ESP_ROM_HAS_NEWLIB_32BIT_TIME=y
 CONFIG_ESP_ROM_NEEDS_SET_CACHE_MMU_SIZE=y
 CONFIG_ESP_ROM_RAM_APP_NEEDS_MMU_INIT=y
+CONFIG_ESP_ROM_HAS_FLASH_COUNT_PAGES_BUG=y
+CONFIG_ESP_ROM_HAS_CACHE_SUSPEND_WAITI_BUG=y
+CONFIG_ESP_ROM_HAS_CACHE_WRITEBACK_BUG=y
 CONFIG_ESP_ROM_HAS_SW_FLOAT=y
-CONFIG_ESP_ROM_USB_OTG_NUM=-1
 CONFIG_ESP_ROM_HAS_VERSION=y
 CONFIG_ESP_ROM_SUPPORT_DEEP_SLEEP_WAKEUP_STUB=y
+CONFIG_ESP_ROM_HAS_OUTPUT_PUTC_FUNC=y
 CONFIG_ESP_ROM_CONSOLE_OUTPUT_SECONDARY=y
 
 #
@@ -438,26 +534,28 @@ CONFIG_BOOT_ROM_LOG_ALWAYS_ON=y
 # Serial flasher config
 #
 # CONFIG_ESPTOOLPY_NO_STUB is not set
+# CONFIG_ESPTOOLPY_OCT_FLASH is not set
+CONFIG_ESPTOOLPY_FLASH_MODE_AUTO_DETECT=y
 # CONFIG_ESPTOOLPY_FLASHMODE_QIO is not set
 # CONFIG_ESPTOOLPY_FLASHMODE_QOUT is not set
 CONFIG_ESPTOOLPY_FLASHMODE_DIO=y
 # CONFIG_ESPTOOLPY_FLASHMODE_DOUT is not set
 CONFIG_ESPTOOLPY_FLASH_SAMPLE_MODE_STR=y
 CONFIG_ESPTOOLPY_FLASHMODE="dio"
+# CONFIG_ESPTOOLPY_FLASHFREQ_120M is not set
 CONFIG_ESPTOOLPY_FLASHFREQ_80M=y
 # CONFIG_ESPTOOLPY_FLASHFREQ_40M is not set
-# CONFIG_ESPTOOLPY_FLASHFREQ_26M is not set
 # CONFIG_ESPTOOLPY_FLASHFREQ_20M is not set
 CONFIG_ESPTOOLPY_FLASHFREQ="80m"
 # CONFIG_ESPTOOLPY_FLASHSIZE_1MB is not set
-# CONFIG_ESPTOOLPY_FLASHSIZE_2MB is not set
-CONFIG_ESPTOOLPY_FLASHSIZE_4MB=y
+CONFIG_ESPTOOLPY_FLASHSIZE_2MB=y
+# CONFIG_ESPTOOLPY_FLASHSIZE_4MB is not set
 # CONFIG_ESPTOOLPY_FLASHSIZE_8MB is not set
 # CONFIG_ESPTOOLPY_FLASHSIZE_16MB is not set
 # CONFIG_ESPTOOLPY_FLASHSIZE_32MB is not set
 # CONFIG_ESPTOOLPY_FLASHSIZE_64MB is not set
 # CONFIG_ESPTOOLPY_FLASHSIZE_128MB is not set
-CONFIG_ESPTOOLPY_FLASHSIZE="4MB"
+CONFIG_ESPTOOLPY_FLASHSIZE="2MB"
 # CONFIG_ESPTOOLPY_HEADER_FLASHSIZE_UPDATE is not set
 CONFIG_ESPTOOLPY_BEFORE_RESET=y
 # CONFIG_ESPTOOLPY_BEFORE_NORESET is not set
@@ -505,7 +603,6 @@ CONFIG_COMPILER_STACK_CHECK_MODE_NONE=y
 # CONFIG_COMPILER_STACK_CHECK_MODE_ALL is not set
 # CONFIG_COMPILER_NO_MERGE_CONSTANTS is not set
 # CONFIG_COMPILER_WARN_WRITE_STRINGS is not set
-# CONFIG_COMPILER_SAVE_RESTORE_LIBCALLS is not set
 CONFIG_COMPILER_DISABLE_DEFAULT_ERRORS=y
 # CONFIG_COMPILER_DISABLE_GCC12_WARNINGS is not set
 # CONFIG_COMPILER_DISABLE_GCC13_WARNINGS is not set
@@ -528,6 +625,7 @@ CONFIG_COMPILER_ORPHAN_SECTIONS_WARNING=y
 # CONFIG_APPTRACE_DEST_JTAG is not set
 CONFIG_APPTRACE_DEST_NONE=y
 # CONFIG_APPTRACE_DEST_UART1 is not set
+# CONFIG_APPTRACE_DEST_UART2 is not set
 # CONFIG_APPTRACE_DEST_USB_CDC is not set
 CONFIG_APPTRACE_DEST_UART_NONE=y
 CONFIG_APPTRACE_UART_TASK_PRIO=1
@@ -576,6 +674,13 @@ CONFIG_TWAI_ERRATA_FIX_LISTEN_ONLY_DOM=y
 # end of Legacy ADC Calibration Configuration
 # end of Legacy ADC Driver Configuration
 
+#
+# Legacy MCPWM Driver Configurations
+#
+# CONFIG_MCPWM_SUPPRESS_DEPRECATE_WARN is not set
+# CONFIG_MCPWM_SKIP_LEGACY_CONFLICT_CHECK is not set
+# end of Legacy MCPWM Driver Configurations
+
 #
 # Legacy Timer Group Driver Configurations
 #
@@ -603,6 +708,13 @@ CONFIG_TWAI_ERRATA_FIX_LISTEN_ONLY_DOM=y
 # CONFIG_I2C_SKIP_LEGACY_CONFLICT_CHECK is not set
 # end of Legacy I2C Driver Configurations
 
+#
+# Legacy PCNT Driver Configurations
+#
+# CONFIG_PCNT_SUPPRESS_DEPRECATE_WARN is not set
+# CONFIG_PCNT_SKIP_LEGACY_CONFLICT_CHECK is not set
+# end of Legacy PCNT Driver Configurations
+
 #
 # Legacy SDM Driver Configurations
 #
@@ -616,6 +728,13 @@ CONFIG_TWAI_ERRATA_FIX_LISTEN_ONLY_DOM=y
 # CONFIG_TEMP_SENSOR_SUPPRESS_DEPRECATE_WARN is not set
 # CONFIG_TEMP_SENSOR_SKIP_LEGACY_CONFLICT_CHECK is not set
 # end of Legacy Temperature Sensor Driver Configurations
+
+#
+# Legacy Touch Sensor Driver Configurations
+#
+# CONFIG_TOUCH_SUPPRESS_DEPRECATE_WARN is not set
+# CONFIG_TOUCH_SKIP_LEGACY_CONFLICT_CHECK is not set
+# end of Legacy Touch Sensor Driver Configurations
 # end of Driver Configurations
 
 #
@@ -646,7 +765,6 @@ CONFIG_ESP_TLS_USE_DS_PERIPHERAL=y
 # CONFIG_ADC_ONESHOT_CTRL_FUNC_IN_IRAM is not set
 # CONFIG_ADC_CONTINUOUS_ISR_IRAM_SAFE is not set
 # CONFIG_ADC_CONTINUOUS_FORCE_USE_ADC2_ON_C3_S3 is not set
-# CONFIG_ADC_ONESHOT_FORCE_USE_ADC2_ON_C3 is not set
 # CONFIG_ADC_ENABLE_DEBUG_LOG is not set
 # end of ADC and ADC Calibration
 
@@ -702,6 +820,22 @@ CONFIG_I2C_MASTER_ISR_HANDLER_IN_IRAM=y
 # CONFIG_LEDC_CTRL_FUNC_IN_IRAM is not set
 # end of ESP-Driver:LEDC Configurations
 
+#
+# ESP-Driver:MCPWM Configurations
+#
+# CONFIG_MCPWM_ISR_IRAM_SAFE is not set
+# CONFIG_MCPWM_CTRL_FUNC_IN_IRAM is not set
+# CONFIG_MCPWM_ENABLE_DEBUG_LOG is not set
+# end of ESP-Driver:MCPWM Configurations
+
+#
+# ESP-Driver:PCNT Configurations
+#
+# CONFIG_PCNT_CTRL_FUNC_IN_IRAM is not set
+# CONFIG_PCNT_ISR_IRAM_SAFE is not set
+# CONFIG_PCNT_ENABLE_DEBUG_LOG is not set
+# end of ESP-Driver:PCNT Configurations
+
 #
 # ESP-Driver:RMT Configurations
 #
@@ -728,6 +862,15 @@ CONFIG_SPI_MASTER_ISR_IN_IRAM=y
 CONFIG_SPI_SLAVE_ISR_IN_IRAM=y
 # end of ESP-Driver:SPI Configurations
 
+#
+# ESP-Driver:Touch Sensor Configurations
+#
+# CONFIG_TOUCH_CTRL_FUNC_IN_IRAM is not set
+# CONFIG_TOUCH_ISR_IRAM_SAFE is not set
+# CONFIG_TOUCH_ENABLE_DEBUG_LOG is not set
+# CONFIG_TOUCH_SKIP_FSM_CHECK is not set
+# end of ESP-Driver:Touch Sensor Configurations
+
 #
 # ESP-Driver:Temperature Sensor Configurations
 #
@@ -828,25 +971,22 @@ CONFIG_ESP_HTTPS_SERVER_EVENT_POST_TIMEOUT=2000
 #
 # Chip revision
 #
-# CONFIG_ESP32C3_REV_MIN_0 is not set
-# CONFIG_ESP32C3_REV_MIN_1 is not set
-# CONFIG_ESP32C3_REV_MIN_2 is not set
-CONFIG_ESP32C3_REV_MIN_3=y
-# CONFIG_ESP32C3_REV_MIN_4 is not set
-# CONFIG_ESP32C3_REV_MIN_101 is not set
-CONFIG_ESP32C3_REV_MIN_FULL=3
-CONFIG_ESP_REV_MIN_FULL=3
+CONFIG_ESP32S3_REV_MIN_0=y
+# CONFIG_ESP32S3_REV_MIN_1 is not set
+# CONFIG_ESP32S3_REV_MIN_2 is not set
+CONFIG_ESP32S3_REV_MIN_FULL=0
+CONFIG_ESP_REV_MIN_FULL=0
 
 #
-# Maximum Supported ESP32-C3 Revision (Rev v1.99)
+# Maximum Supported ESP32-S3 Revision (Rev v0.99)
 #
-CONFIG_ESP32C3_REV_MAX_FULL=199
-CONFIG_ESP_REV_MAX_FULL=199
+CONFIG_ESP32S3_REV_MAX_FULL=99
+CONFIG_ESP_REV_MAX_FULL=99
 CONFIG_ESP_EFUSE_BLOCK_REV_MIN_FULL=0
 CONFIG_ESP_EFUSE_BLOCK_REV_MAX_FULL=199
 
 #
-# Maximum Supported ESP32-C3 eFuse Block Revision (eFuse Block Rev v1.99)
+# Maximum Supported ESP32-S3 eFuse Block Revision (eFuse Block Rev v1.99)
 #
 # end of Chip revision
 
@@ -859,9 +999,9 @@ CONFIG_ESP_MAC_ADDR_UNIVERSE_BT=y
 CONFIG_ESP_MAC_ADDR_UNIVERSE_ETH=y
 CONFIG_ESP_MAC_UNIVERSAL_MAC_ADDRESSES_FOUR=y
 CONFIG_ESP_MAC_UNIVERSAL_MAC_ADDRESSES=4
-# CONFIG_ESP32C3_UNIVERSAL_MAC_ADDRESSES_TWO is not set
-CONFIG_ESP32C3_UNIVERSAL_MAC_ADDRESSES_FOUR=y
-CONFIG_ESP32C3_UNIVERSAL_MAC_ADDRESSES=4
+# CONFIG_ESP32S3_UNIVERSAL_MAC_ADDRESSES_TWO is not set
+CONFIG_ESP32S3_UNIVERSAL_MAC_ADDRESSES_FOUR=y
+CONFIG_ESP32S3_UNIVERSAL_MAC_ADDRESSES=4
 # CONFIG_ESP_MAC_USE_CUSTOM_MAC_AS_BASE_MAC is not set
 # end of MAC Config
 
@@ -870,9 +1010,10 @@ CONFIG_ESP32C3_UNIVERSAL_MAC_ADDRESSES=4
 #
 # CONFIG_ESP_SLEEP_POWER_DOWN_FLASH is not set
 CONFIG_ESP_SLEEP_FLASH_LEAKAGE_WORKAROUND=y
-# CONFIG_ESP_SLEEP_MSPI_NEED_ALL_IO_PU is not set
+CONFIG_ESP_SLEEP_MSPI_NEED_ALL_IO_PU=y
+CONFIG_ESP_SLEEP_RTC_BUS_ISO_WORKAROUND=y
 CONFIG_ESP_SLEEP_GPIO_RESET_WORKAROUND=y
-CONFIG_ESP_SLEEP_WAIT_FLASH_READY_EXTRA_DELAY=0
+CONFIG_ESP_SLEEP_WAIT_FLASH_READY_EXTRA_DELAY=2000
 # CONFIG_ESP_SLEEP_CACHE_SAFE_ASSERTION is not set
 # CONFIG_ESP_SLEEP_DEBUG is not set
 CONFIG_ESP_SLEEP_GPIO_ENABLE_INTERNAL_RESISTORS=y
@@ -924,6 +1065,7 @@ CONFIG_ESP_BROWNOUT_DET_LVL_SEL_7=y
 # CONFIG_ESP_BROWNOUT_DET_LVL_SEL_4 is not set
 # CONFIG_ESP_BROWNOUT_DET_LVL_SEL_3 is not set
 # CONFIG_ESP_BROWNOUT_DET_LVL_SEL_2 is not set
+# CONFIG_ESP_BROWNOUT_DET_LVL_SEL_1 is not set
 CONFIG_ESP_BROWNOUT_DET_LVL=7
 CONFIG_ESP_BROWNOUT_USE_INTR=y
 # end of Brownout Detector
@@ -936,11 +1078,14 @@ CONFIG_ESP_SPI_BUS_LOCK_ISR_FUNCS_IN_IRAM=y
 # ESP-Driver:LCD Controller Configurations
 #
 # CONFIG_LCD_ENABLE_DEBUG_LOG is not set
+# CONFIG_LCD_RGB_ISR_IRAM_SAFE is not set
+# CONFIG_LCD_RGB_RESTART_IN_VSYNC is not set
 # end of ESP-Driver:LCD Controller Configurations
 
 #
 # ESP-MM: Memory Management Configurations
 #
+# CONFIG_ESP_MM_CACHE_MSYNC_C2M_CHUNKED_OPS is not set
 # end of ESP-MM: Memory Management Configurations
 
 #
@@ -988,11 +1133,14 @@ CONFIG_ESP_PHY_CALIBRATION_MODE=0
 # CONFIG_PM_ENABLE is not set
 # CONFIG_PM_SLP_IRAM_OPT is not set
 CONFIG_PM_POWER_DOWN_CPU_IN_LIGHT_SLEEP=y
+CONFIG_PM_RESTORE_CACHE_TAGMEM_AFTER_LIGHT_SLEEP=y
 # end of Power Management
 
 #
 # ESP PSRAM
 #
+# CONFIG_SPIRAM is not set
+# end of ESP PSRAM
 
 #
 # ESP Ringbuf
@@ -1010,18 +1158,55 @@ CONFIG_PM_POWER_DOWN_CPU_IN_LIGHT_SLEEP=y
 #
 # CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ_80 is not set
 CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ_160=y
+# CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ_240 is not set
 CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ=160
+
+#
+# Cache config
+#
+CONFIG_ESP32S3_INSTRUCTION_CACHE_16KB=y
+# CONFIG_ESP32S3_INSTRUCTION_CACHE_32KB is not set
+CONFIG_ESP32S3_INSTRUCTION_CACHE_SIZE=0x4000
+# CONFIG_ESP32S3_INSTRUCTION_CACHE_4WAYS is not set
+CONFIG_ESP32S3_INSTRUCTION_CACHE_8WAYS=y
+CONFIG_ESP32S3_ICACHE_ASSOCIATED_WAYS=8
+# CONFIG_ESP32S3_INSTRUCTION_CACHE_LINE_16B is not set
+CONFIG_ESP32S3_INSTRUCTION_CACHE_LINE_32B=y
+CONFIG_ESP32S3_INSTRUCTION_CACHE_LINE_SIZE=32
+# CONFIG_ESP32S3_DATA_CACHE_16KB is not set
+CONFIG_ESP32S3_DATA_CACHE_32KB=y
+# CONFIG_ESP32S3_DATA_CACHE_64KB is not set
+CONFIG_ESP32S3_DATA_CACHE_SIZE=0x8000
+# CONFIG_ESP32S3_DATA_CACHE_4WAYS is not set
+CONFIG_ESP32S3_DATA_CACHE_8WAYS=y
+CONFIG_ESP32S3_DCACHE_ASSOCIATED_WAYS=8
+# CONFIG_ESP32S3_DATA_CACHE_LINE_16B is not set
+CONFIG_ESP32S3_DATA_CACHE_LINE_32B=y
+# CONFIG_ESP32S3_DATA_CACHE_LINE_64B is not set
+CONFIG_ESP32S3_DATA_CACHE_LINE_SIZE=32
+# end of Cache config
+
+#
+# Memory
+#
+# CONFIG_ESP32S3_RTCDATA_IN_FAST_MEM is not set
+# CONFIG_ESP32S3_USE_FIXED_STATIC_RAM_SIZE is not set
+# end of Memory
+
+#
+# Trace memory
+#
+# CONFIG_ESP32S3_TRAX is not set
+CONFIG_ESP32S3_TRACEMEM_RESERVE_DRAM=0x0
+# end of Trace memory
+
 # CONFIG_ESP_SYSTEM_PANIC_PRINT_HALT is not set
 CONFIG_ESP_SYSTEM_PANIC_PRINT_REBOOT=y
 # CONFIG_ESP_SYSTEM_PANIC_SILENT_REBOOT is not set
 # CONFIG_ESP_SYSTEM_PANIC_GDBSTUB is not set
 CONFIG_ESP_SYSTEM_PANIC_REBOOT_DELAY_SECONDS=0
-CONFIG_ESP_SYSTEM_SINGLE_CORE_MODE=y
 CONFIG_ESP_SYSTEM_RTC_FAST_MEM_AS_HEAP_DEPCHECK=y
 CONFIG_ESP_SYSTEM_ALLOW_RTC_FAST_MEM_AS_HEAP=y
-CONFIG_ESP_SYSTEM_NO_BACKTRACE=y
-# CONFIG_ESP_SYSTEM_USE_EH_FRAME is not set
-# CONFIG_ESP_SYSTEM_USE_FRAME_POINTER is not set
 
 #
 # Memory protection
@@ -1034,10 +1219,12 @@ CONFIG_ESP_SYSTEM_EVENT_QUEUE_SIZE=32
 CONFIG_ESP_SYSTEM_EVENT_TASK_STACK_SIZE=2304
 CONFIG_ESP_MAIN_TASK_STACK_SIZE=3584
 CONFIG_ESP_MAIN_TASK_AFFINITY_CPU0=y
+# CONFIG_ESP_MAIN_TASK_AFFINITY_CPU1 is not set
 # CONFIG_ESP_MAIN_TASK_AFFINITY_NO_AFFINITY is not set
 CONFIG_ESP_MAIN_TASK_AFFINITY=0x0
 CONFIG_ESP_MINIMAL_SHARED_STACK_SIZE=2048
 CONFIG_ESP_CONSOLE_UART_DEFAULT=y
+# CONFIG_ESP_CONSOLE_USB_CDC is not set
 # CONFIG_ESP_CONSOLE_USB_SERIAL_JTAG is not set
 # CONFIG_ESP_CONSOLE_UART_CUSTOM is not set
 # CONFIG_ESP_CONSOLE_NONE is not set
@@ -1050,23 +1237,26 @@ CONFIG_ESP_CONSOLE_ROM_SERIAL_PORT_NUM=0
 CONFIG_ESP_CONSOLE_UART_BAUDRATE=115200
 CONFIG_ESP_INT_WDT=y
 CONFIG_ESP_INT_WDT_TIMEOUT_MS=300
+CONFIG_ESP_INT_WDT_CHECK_CPU1=y
 CONFIG_ESP_TASK_WDT_EN=y
 CONFIG_ESP_TASK_WDT_INIT=y
 # CONFIG_ESP_TASK_WDT_PANIC is not set
 CONFIG_ESP_TASK_WDT_TIMEOUT_S=5
 CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU0=y
+CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU1=y
 # CONFIG_ESP_PANIC_HANDLER_IRAM is not set
 # CONFIG_ESP_DEBUG_STUBS_ENABLE is not set
 CONFIG_ESP_DEBUG_OCDAWARE=y
 CONFIG_ESP_SYSTEM_CHECK_INT_LEVEL_4=y
-CONFIG_ESP_SYSTEM_HW_STACK_GUARD=y
-CONFIG_ESP_SYSTEM_HW_PC_RECORD=y
+CONFIG_ESP_SYSTEM_BBPLL_RECALIB=y
 # end of ESP System Settings
 
 #
 # IPC (Inter-Processor Call)
 #
-CONFIG_ESP_IPC_TASK_STACK_SIZE=1024
+CONFIG_ESP_IPC_TASK_STACK_SIZE=1280
+CONFIG_ESP_IPC_USES_CALLERS_PRIORITY=y
+CONFIG_ESP_IPC_ISR_ENABLE=y
 # end of IPC (Inter-Processor Call)
 
 #
@@ -1105,6 +1295,8 @@ CONFIG_ESP_WIFI_TX_BA_WIN=6
 CONFIG_ESP_WIFI_AMPDU_RX_ENABLED=y
 CONFIG_ESP_WIFI_RX_BA_WIN=6
 CONFIG_ESP_WIFI_NVS_ENABLED=y
+CONFIG_ESP_WIFI_TASK_PINNED_TO_CORE_0=y
+# CONFIG_ESP_WIFI_TASK_PINNED_TO_CORE_1 is not set
 CONFIG_ESP_WIFI_SOFTAP_BEACON_MAX_LEN=752
 CONFIG_ESP_WIFI_MGMT_SBUF_NUM=32
 CONFIG_ESP_WIFI_IRAM_OPT=y
@@ -1209,9 +1401,8 @@ CONFIG_FATFS_LINK_LOCK=y
 # Kernel
 #
 # CONFIG_FREERTOS_SMP is not set
-CONFIG_FREERTOS_UNICORE=y
+# CONFIG_FREERTOS_UNICORE is not set
 CONFIG_FREERTOS_HZ=100
-CONFIG_FREERTOS_OPTIMIZED_SCHEDULER=y
 # CONFIG_FREERTOS_CHECK_STACKOVERFLOW_NONE is not set
 # CONFIG_FREERTOS_CHECK_STACKOVERFLOW_PTRVAL is not set
 CONFIG_FREERTOS_CHECK_STACKOVERFLOW_CANARY=y
@@ -1224,6 +1415,7 @@ CONFIG_FREERTOS_MAX_TASK_NAME_LEN=16
 CONFIG_FREERTOS_USE_TIMERS=y
 CONFIG_FREERTOS_TIMER_SERVICE_TASK_NAME="Tmr Svc"
 # CONFIG_FREERTOS_TIMER_TASK_AFFINITY_CPU0 is not set
+# CONFIG_FREERTOS_TIMER_TASK_AFFINITY_CPU1 is not set
 CONFIG_FREERTOS_TIMER_TASK_NO_AFFINITY=y
 CONFIG_FREERTOS_TIMER_SERVICE_TASK_CORE_AFFINITY=0x7FFFFFFF
 CONFIG_FREERTOS_TIMER_TASK_PRIORITY=1
@@ -1248,6 +1440,7 @@ CONFIG_FREERTOS_TLSP_DELETION_CALLBACKS=y
 CONFIG_FREERTOS_CHECK_MUTEX_GIVEN_BY_OWNER=y
 CONFIG_FREERTOS_ISR_STACKSIZE=1536
 CONFIG_FREERTOS_INTERRUPT_BACKTRACE=y
+# CONFIG_FREERTOS_FPU_IN_ISR is not set
 CONFIG_FREERTOS_TICK_SUPPORT_SYSTIMER=y
 CONFIG_FREERTOS_CORETIMER_SYSTIMER_LVL1=y
 # CONFIG_FREERTOS_CORETIMER_SYSTIMER_LVL3 is not set
@@ -1267,7 +1460,7 @@ CONFIG_FREERTOS_SUPPORT_STATIC_ALLOCATION=y
 CONFIG_FREERTOS_DEBUG_OCDAWARE=y
 CONFIG_FREERTOS_ENABLE_TASK_SNAPSHOT=y
 CONFIG_FREERTOS_PLACE_SNAPSHOT_FUNS_INTO_FLASH=y
-CONFIG_FREERTOS_NUMBER_OF_CORES=1
+CONFIG_FREERTOS_NUMBER_OF_CORES=2
 # end of FreeRTOS
 
 #
@@ -1278,6 +1471,7 @@ CONFIG_HAL_ASSERTION_EQUALS_SYSTEM=y
 # CONFIG_HAL_ASSERTION_SILENT is not set
 # CONFIG_HAL_ASSERTION_ENABLE is not set
 CONFIG_HAL_DEFAULT_ASSERTION_LEVEL=2
+CONFIG_HAL_WDT_USE_ROM_IMPL=y
 # end of Hardware Abstraction Layer (HAL) and Low Level (LL)
 
 #
@@ -1449,6 +1643,7 @@ CONFIG_LWIP_CHECKSUM_CHECK_ICMP=y
 CONFIG_LWIP_TCPIP_TASK_STACK_SIZE=3072
 CONFIG_LWIP_TCPIP_TASK_AFFINITY_NO_AFFINITY=y
 # CONFIG_LWIP_TCPIP_TASK_AFFINITY_CPU0 is not set
+# CONFIG_LWIP_TCPIP_TASK_AFFINITY_CPU1 is not set
 CONFIG_LWIP_TCPIP_TASK_AFFINITY=0x7FFFFFFF
 CONFIG_LWIP_IPV6_MEMP_NUM_ND6_QUEUE=3
 CONFIG_LWIP_IPV6_ND6_NUM_NEIGHBORS=5
@@ -1565,7 +1760,7 @@ CONFIG_MBEDTLS_AES_USE_INTERRUPT=y
 CONFIG_MBEDTLS_AES_INTERRUPT_LEVEL=0
 CONFIG_MBEDTLS_GCM_SUPPORT_NON_AES_CIPHER=y
 CONFIG_MBEDTLS_HARDWARE_MPI=y
-CONFIG_MBEDTLS_LARGE_KEY_SOFTWARE_MPI=y
+# CONFIG_MBEDTLS_LARGE_KEY_SOFTWARE_MPI is not set
 CONFIG_MBEDTLS_MPI_USE_INTERRUPT=y
 CONFIG_MBEDTLS_MPI_INTERRUPT_LEVEL=0
 CONFIG_MBEDTLS_HARDWARE_SHA=y
@@ -1728,6 +1923,9 @@ CONFIG_ESP_PROTOCOMM_SUPPORT_SECURITY_PATCH_VERSION=y
 CONFIG_PTHREAD_TASK_PRIO_DEFAULT=5
 CONFIG_PTHREAD_TASK_STACK_SIZE_DEFAULT=3072
 CONFIG_PTHREAD_STACK_MIN=768
+CONFIG_PTHREAD_DEFAULT_CORE_NO_AFFINITY=y
+# CONFIG_PTHREAD_DEFAULT_CORE_0 is not set
+# CONFIG_PTHREAD_DEFAULT_CORE_1 is not set
 CONFIG_PTHREAD_TASK_CORE_DEFAULT=-1
 CONFIG_PTHREAD_TASK_NAME_DEFAULT="pthread"
 # end of PThreads
@@ -1758,6 +1956,12 @@ CONFIG_SPI_FLASH_BROWNOUT_RESET=y
 #
 # Features here require specific hardware (READ DOCS FIRST!)
 #
+# CONFIG_SPI_FLASH_HPM_ENA is not set
+CONFIG_SPI_FLASH_HPM_AUTO=y
+# CONFIG_SPI_FLASH_HPM_DIS is not set
+CONFIG_SPI_FLASH_HPM_ON=y
+CONFIG_SPI_FLASH_HPM_DC_AUTO=y
+# CONFIG_SPI_FLASH_HPM_DC_DISABLE is not set
 # CONFIG_SPI_FLASH_AUTO_SUSPEND is not set
 CONFIG_SPI_FLASH_SUSPEND_TSUS_VAL_US=50
 # CONFIG_SPI_FLASH_FORCE_ENABLE_XMC_C_SUSPEND is not set
@@ -1801,6 +2005,7 @@ CONFIG_SPI_FLASH_SUPPORT_GD_CHIP=y
 CONFIG_SPI_FLASH_SUPPORT_WINBOND_CHIP=y
 CONFIG_SPI_FLASH_SUPPORT_BOYA_CHIP=y
 CONFIG_SPI_FLASH_SUPPORT_TH_CHIP=y
+CONFIG_SPI_FLASH_SUPPORT_MXIC_OPI_CHIP=y
 # end of Auto-detect flash chips
 
 CONFIG_SPI_FLASH_ENABLE_ENCRYPTED_READ_WRITE=y
@@ -1855,6 +2060,17 @@ CONFIG_WS_BUFFER_SIZE=1024
 # end of Websocket
 # end of TCP Transport
 
+#
+# Ultra Low Power (ULP) Co-processor
+#
+# CONFIG_ULP_COPROC_ENABLED is not set
+
+#
+# ULP Debugging Options
+#
+# end of ULP Debugging Options
+# end of Ultra Low Power (ULP) Co-processor
+
 #
 # Unity unit testing library
 #
@@ -1867,6 +2083,34 @@ CONFIG_UNITY_ENABLE_IDF_TEST_RUNNER=y
 # CONFIG_UNITY_ENABLE_BACKTRACE_ON_FAIL is not set
 # end of Unity unit testing library
 
+#
+# USB-OTG
+#
+CONFIG_USB_HOST_CONTROL_TRANSFER_MAX_SIZE=256
+CONFIG_USB_HOST_HW_BUFFER_BIAS_BALANCED=y
+# CONFIG_USB_HOST_HW_BUFFER_BIAS_IN is not set
+# CONFIG_USB_HOST_HW_BUFFER_BIAS_PERIODIC_OUT is not set
+
+#
+# Hub Driver Configuration
+#
+
+#
+# Root Port configuration
+#
+CONFIG_USB_HOST_DEBOUNCE_DELAY_MS=250
+CONFIG_USB_HOST_RESET_HOLD_MS=30
+CONFIG_USB_HOST_RESET_RECOVERY_MS=30
+CONFIG_USB_HOST_SET_ADDR_RECOVERY_MS=10
+# end of Root Port configuration
+
+# CONFIG_USB_HOST_HUBS_SUPPORTED is not set
+# end of Hub Driver Configuration
+
+# CONFIG_USB_HOST_ENABLE_ENUM_FILTER_CALLBACK is not set
+CONFIG_USB_OTG_SUPPORTED=y
+# end of USB-OTG
+
 #
 # Virtual file system
 #

tools/main.py

@@ -1,111 +0,0 @@
-import serial
-import time
-from parser import UartMessageParser, ParserError
-from message_builder import MessageBuilder, MessageBuilderError, PayloadTooLargeError, BufferOverflowError
-import payload_parser
-
-SERIAL_PORT = "/dev/ttyUSB0"
-BAUDRATE = 115200
-WRITE_TIMEOUT = 0.5
-READ_TIMEOUT = 1.0
-
-payload_parser = payload_parser.PayloadParser()
-
-
-def on_message_received_from_uart(message_id: int, payload: bytes, payload_length: int):
-    """
-    Callback-Funktion, die aufgerufen wird, wenn der Parser eine vollständige,
-    gültige Nachricht empfangen hat.
-    """
-    print(f"\n[MAIN] Nachricht erfolgreich empfangen! ID: 0x{
-          message_id:02X}")
-    print(f"[MAIN]    Payload ({payload_length} Bytes): {
-          payload[:payload_length].hex().upper()}")
-
-    parsed_object = payload_parser.parse_payload(
-        message_id, payload[:payload_length])
-
-    print(parsed_object)
-
-
-def on_message_fail_from_uart(message_id: int, current_message_buffer: bytes,
-                              current_index: int, error_type: ParserError):
-    """
-    Callback-Funktion, die aufgerufen wird, wenn der Parser einen Fehler
-    beim Empfang einer Nachricht feststellt.
-    """
-    print(f"\n[MAIN] Fehler beim Parsen der Nachricht! ID: 0x{
-          message_id:02X}")
-    print(f"[MAIN]    Fehler: {error_type.name}")
-    print(f"[MAIN]    Bisheriger Puffer ({current_index} Bytes): {
-          current_message_buffer[:current_index].hex().upper()}")
-
-
-def run_uart_test():
-    """
-    Führt den UART-Test durch: Sendet eine Nachricht und liest alle Antworten.
-    """
-    ser = None
-
-    parser = UartMessageParser(
-        on_message_received_callback=on_message_received_from_uart,
-        on_message_fail_callback=on_message_fail_from_uart
-    )
-    message_builder = MessageBuilder()
-
-    try:
-        ser = serial.Serial(
-            port=SERIAL_PORT,
-            baudrate=BAUDRATE,
-            timeout=READ_TIMEOUT,
-            write_timeout=WRITE_TIMEOUT
-        )
-        print(f"Serielle Schnittstelle {
-              SERIAL_PORT} mit Baudrate {BAUDRATE} geöffnet.")
-
-        try:
-            # Baue die Nachricht
-            message_to_send = message_builder.build_message(
-                0x3,
-                b'',
-                255
-            )
-            print(f"\n[MAIN] Gebaute Nachricht zum Senden: {
-                  message_to_send.hex().upper()}")
-            bytes_written = ser.write(message_to_send)
-            print(f"[MAIN] {bytes_written} Bytes gesendet.")
-        except (PayloadTooLargeError, BufferOverflowError) as e:
-            print(f"[MAIN]  Fehler beim Bauen der Nachricht: {e}")
-            return  # Beende die Funktion, wenn die Nachricht nicht gebaut werden kann
-        except Exception as e:
-            print(
-                f"[MAIN]  Ein unerwarteter Fehler beim Bauen der Nachricht ist aufgetreten: {e}")
-            return
-
-        time.sleep(0.1)
-
-        received_data = ser.read_all()
-
-        if received_data:
-            print(f"Empfangene Daten ({len(received_data)} Bytes): {
-                  received_data.hex().upper()}")
-            for byte_val in received_data:
-                parser.parse_byte(byte_val)
-        else:
-            print("Keine Daten empfangen.")
-
-    except serial.SerialException as e:
-        print(f"Fehler beim Zugriff auf die serielle Schnittstelle: {e}")
-        print(f"Stelle sicher, dass '{
-              SERIAL_PORT}' der korrekte Port ist und nicht von einer anderen Anwendung verwendet wird.")
-    except Exception as e:
-        print(f"Ein unerwarteter Fehler ist aufgetreten: {e}")
-    finally:
-        if ser and ser.is_open:
-            ser.close()
-            print("Serielle Schnittstelle geschlossen.")
-
-
-# Führe den Test aus
-if __name__ == "__main__":
-    run_uart_test()

tools/message_builder.py

@@ -1,115 +0,0 @@
-import enum
-
-START_BYTE = 0xAA
-ESCAPE_BYTE = 0xBB
-END_BYTE = 0xCC
-
-
-class MessageBuilderError(Exception):
-    """Basisklasse für Fehler des Message Builders."""
-    pass
-
-
-class PayloadTooLargeError(MessageBuilderError):
-    """Ausnahme, wenn der Payload zu groß für den Puffer ist."""
-
-    def __init__(self, required_size, buffer_size):
-        super().__init__(f"Payload ({
-            required_size} bytes) ist größer als der verfügbare Puffer ({buffer_size} bytes).")
-        self.required_size = required_size
-        self.buffer_size = buffer_size
-
-
-class BufferOverflowError(MessageBuilderError):
-    """Ausnahme, wenn der Puffer während des Bauens überläuft."""
-
-    def __init__(self, current_size, max_size, byte_to_add=None):
-        msg = f"Pufferüberlauf: Aktuelle Größe {
-            current_size}, Max. Größe {max_size}."
-        if byte_to_add is not None:
-            msg += f" Versuch, Byte 0x{byte_to_add:02X} hinzuzufügen."
-        super().__init__(msg)
-        self.current_size = current_size
-        self.max_size = max_size
-        self.byte_to_add = byte_to_add
-
-
-class MessageBuilder:
-    """
-    Klasse zum Aufbau von UART-Nachrichten gemäß dem definierten Protokoll,
-    inklusive Stuffing und Checksummenberechnung.
-    """
-
-    def __init__(self):
-        pass
-
-    def _needs_stuffing_byte(self, byte: int) -> bool:
-        """
-        Prüft, ob ein Byte ein Stuffing-Byte benötigt (d.h. ob es ein Steuerbyte ist).
-        """
-        return (byte == START_BYTE or byte == ESCAPE_BYTE or byte == END_BYTE)
-
-    def _add_byte_with_length_check(self, byte: int, buffer: bytearray, max_length: int):
-        """
-        Fügt ein Byte zum Puffer hinzu und prüft auf Pufferüberlauf.
-        Löst BufferOverflowError aus, wenn der Puffer voll ist.
-        """
-        if len(buffer) >= max_length:
-            raise BufferOverflowError(len(buffer), max_length, byte)
-        buffer.append(byte)
-
-    def build_message(self, msgid: int, payload: bytes, msg_buffer_size: int) -> bytes:
-        """
-        Baut eine vollständige UART-Nachricht.
-
-        Args:
-            msgid (int): Die Message ID (0-255).
-            payload (bytes): Die Nutzdaten der Nachricht als Byte-Objekt.
-            msg_buffer_size (int): Die maximale Größe des Ausgabepuffers.
-                                   Dies ist die maximale Länge der *fertigen* Nachricht.
-
-        Returns:
-            bytes: Die fertig aufgebaute Nachricht als Byte-Objekt.
-
-        Raises:
-            PayloadTooLargeError: Wenn der Payload (mit Overhead) den Puffer überschreiten würde.
-            BufferOverflowError: Wenn während des Bauens ein Pufferüberlauf auftritt.
-        """
-
-        if len(payload) + 4 > msg_buffer_size:
-            raise PayloadTooLargeError(len(payload) + 4, msg_buffer_size)
-
-        checksum = 0
-        msg_buffer = bytearray()
-
-        # 1. StartByte hinzufügen
-        self._add_byte_with_length_check(
-            START_BYTE, msg_buffer, msg_buffer_size)
-
-        # 2. Message ID hinzufügen (mit Stuffing)
-        if self._needs_stuffing_byte(msgid):
-            self._add_byte_with_length_check(
-                ESCAPE_BYTE, msg_buffer, msg_buffer_size)
-        self._add_byte_with_length_check(msgid, msg_buffer, msg_buffer_size)
-        checksum ^= msgid
-
-        # 3. Payload-Bytes hinzufügen (mit Stuffing)
-        for byte_val in payload:
-            if self._needs_stuffing_byte(byte_val):
-                self._add_byte_with_length_check(
-                    ESCAPE_BYTE, msg_buffer, msg_buffer_size)
-            self._add_byte_with_length_check(
-                byte_val, msg_buffer, msg_buffer_size)
-            checksum ^= byte_val
-
-        # 4. Checksumme hinzufügen (mit Stuffing)
-        if self._needs_stuffing_byte(checksum):
-            self._add_byte_with_length_check(
-                ESCAPE_BYTE, msg_buffer, msg_buffer_size)
-        self._add_byte_with_length_check(checksum, msg_buffer, msg_buffer_size)
-
-        # 5. EndByte hinzufügen
-        self._add_byte_with_length_check(END_BYTE, msg_buffer, msg_buffer_size)
-
-        # Konvertiere bytearray zu unveränderlichem bytes-Objekt
-        return bytes(msg_buffer)

tools/parser.py

@@ -1,170 +0,0 @@
-import enum
-
-# --- Konstanten für das UART-Protokoll ---
-# Diese Werte müssen mit denen auf deinem Embedded-System übereinstimmen
-START_BYTE = 0xAA
-END_BYTE = 0xCC
-ESCAPE_BYTE = 0x7D # Beispielwert, bitte an dein Protokoll anpassen
-
-MAX_PAYLOAD_LENGTH = 255 # Maximale Länge des Nachrichten-Payloads (ohne Message ID und Checksumme)
-# MAX_TOTAL_CONTENT_LENGTH in C beinhaltet Message ID, Payload und Checksumme.
-# Hier definieren wir MAX_PAYLOAD_LENGTH, da der Parser den Payload sammelt.
-# Die Gesamtgröße des empfangenen Puffers (message + checksum) darf MAX_PAYLOAD_LENGTH + 1 nicht überschreiten,
-# da die Checksumme als letztes Byte des Payloads behandelt wird.
-
-# --- Enumerationen für Parser-Zustände und Fehler ---
-class ParserState(enum.Enum):
-    WAITING_FOR_START_BYTE = 0
-    GET_MESSAGE_TYPE = 1
-    ESCAPED_MESSAGE_TYPE = 2
-    IN_PAYLOAD = 3
-    ESCAPE_PAYLOAD_BYTE = 4
-
-class ParserError(enum.Enum):
-    NO_ERROR = 0
-    UNEXPECTED_COMMAND_BYTE = 1
-    WRONG_CHECKSUM = 2
-    MESSAGE_TOO_LONG = 3
-
-class UartMessageParser:
-    """
-    Ein State-Machine-Parser für UART-Nachrichten basierend auf der bereitgestellten C-Logik.
-
-    Nachrichtenformat (angenommen):
-    [START_BYTE] [MESSAGE_ID] [PAYLOAD_BYTES...] [CHECKSUM_BYTE] [END_BYTE]
-
-    Escape-Sequenzen:
-    Wenn START_BYTE, END_BYTE oder ESCAPE_BYTE im MESSAGE_ID oder PAYLOAD vorkommen,
-    werden sie durch ESCAPE_BYTE gefolgt vom ursprünglichen Byte (nicht XORed) ersetzt.
-    Die Checksumme wird über die unescaped Bytes berechnet.
-    """
-
-    def __init__(self, on_message_received_callback=None, on_message_fail_callback=None):
-        """
-        Initialisiert den UART-Nachrichten-Parser.
-
-        Args:
-            on_message_received_callback (callable, optional): Eine Funktion, die aufgerufen wird,
-                wenn eine gültige Nachricht empfangen wurde.
-                Signatur: on_message_received(message_id: int, payload: bytes, payload_length: int)
-            on_message_fail_callback (callable, optional): Eine Funktion, die aufgerufen wird,
-                wenn ein Nachrichtenfehler auftritt.
-                Signatur: on_message_fail(message_id: int, current_message_buffer: bytes,
-                                          current_index: int, error_type: ParserError)
-        """
-        self.state = ParserState.WAITING_FOR_START_BYTE
-        self.index = 0
-        self.checksum = 0
-        self.message_id = 0
-        self.message_buffer = bytearray(MAX_PAYLOAD_LENGTH + 1) # +1 für Checksummen-Byte
-        self.error = ParserError.NO_ERROR
-
-        # Callbacks für die Anwendung. Standardmäßig None oder einfache Print-Funktionen.
-        self.on_message_received = on_message_received_callback if on_message_received_callback else self._default_on_message_received
-        self.on_message_fail = on_message_fail_callback if on_message_fail_callback else self._default_on_message_fail
-
-    def _default_on_message_received(self, message_id, payload, payload_length):
-        """Standard-Callback für empfangene Nachrichten, falls keiner angegeben ist."""
-        print(f"Parser: Nachricht empfangen! ID: 0x{message_id:02X}, "
-              f"Payload ({payload_length} Bytes): {payload[:payload_length].hex().upper()}")
-
-    def _default_on_message_fail(self, message_id, current_message_buffer, current_index, error_type):
-        """Standard-Callback für Nachrichtenfehler, falls keiner angegeben ist."""
-        print(f"Parser: Fehler bei Nachricht! ID: 0x{message_id:02X}, "
-              f"Fehler: {error_type.name}, "
-              f"Bisheriger Puffer ({current_index} Bytes): {current_message_buffer[:current_index].hex().upper()}")
-
-    def parse_byte(self, pbyte: int):
-        """
-        Verarbeitet ein einzelnes empfangenes Byte.
-
-        Args:
-            pbyte (int): Das empfangene Byte (0-255).
-        """
-        # Sicherstellen, dass pbyte ein Integer im Bereich 0-255 ist
-        if not isinstance(pbyte, int) or not (0 <= pbyte <= 255):
-            print(f"Parser: Ungültiges Byte empfangen: {pbyte}. Muss ein Integer von 0-255 sein.")
-            return
-
-        current_state = self.state # Für bessere Lesbarkeit
-
-        if current_state == ParserState.WAITING_FOR_START_BYTE:
-            if pbyte == START_BYTE:
-                self.index = 0
-                self.checksum = 0
-                self.message_id = 0 # Reset message_id
-                self.error = ParserError.NO_ERROR # Reset error
-                self.state = ParserState.GET_MESSAGE_TYPE
-            # Andernfalls ignorieren wir Bytes, bis ein Start-Byte gefunden wird
-
-        elif current_state == ParserState.ESCAPED_MESSAGE_TYPE:
-            self.message_id = pbyte
-            self.checksum ^= pbyte
-            self.state = ParserState.IN_PAYLOAD
-
-        elif current_state == ParserState.GET_MESSAGE_TYPE:
-            if pbyte == ESCAPE_BYTE:
-                self.state = ParserState.ESCAPED_MESSAGE_TYPE
-                return # Dieses Byte wurde als Escape-Sequenz verarbeitet, nicht zum Payload hinzufügen
-            if pbyte == START_BYTE or pbyte == END_BYTE:
-                self.state = ParserState.WAITING_FOR_START_BYTE
-                self.error = ParserError.UNEXPECTED_COMMAND_BYTE
-                self.on_message_fail(self.message_id, self.message_buffer, self.index, self.error)
-                return
-            self.message_id = pbyte
-            self.checksum ^= pbyte
-            self.state = ParserState.IN_PAYLOAD
-
-        elif current_state == ParserState.ESCAPE_PAYLOAD_BYTE:
-            # Das escapte Byte ist Teil des Payloads
-            if self.index < MAX_PAYLOAD_LENGTH + 1: # +1 für Checksummen-Byte
-                self.message_buffer[self.index] = pbyte
-                self.index += 1
-                self.checksum ^= pbyte
-                self.state = ParserState.IN_PAYLOAD
-            else:
-                self.state = ParserState.WAITING_FOR_START_BYTE
-                self.error = ParserError.MESSAGE_TOO_LONG
-                self.on_message_fail(self.message_id, self.message_buffer, self.index, self.error)
-                return
-
-        elif current_state == ParserState.IN_PAYLOAD:
-            if pbyte == ESCAPE_BYTE:
-                self.state = ParserState.ESCAPE_PAYLOAD_BYTE
-                return # Dieses Byte wurde als Escape-Sequenz verarbeitet
-            if pbyte == START_BYTE:
-                self.state = ParserState.WAITING_FOR_START_BYTE
-                self.error = ParserError.UNEXPECTED_COMMAND_BYTE
-                self.on_message_fail(self.message_id, self.message_buffer, self.index, self.error)
-                return
-            if pbyte == END_BYTE:
-                if self.checksum != 0x00:
-                    # Checksummenfehler: Die Checksumme wurde bis zum End-Byte XORed.
-                    # Wenn die empfangene Checksumme korrekt war, sollte das Ergebnis 0 sein.
-                    self.state = ParserState.WAITING_FOR_START_BYTE
-                    self.error = ParserError.WRONG_CHECKSUM
-                    self.on_message_fail(self.message_id, self.message_buffer, self.index, self.error)
-                    return
-                
-                # Erfolgreich empfangen! Die Checksumme ist das letzte Byte im Puffer.
-                # Die Länge des Payloads ist index - 1 (da das letzte Byte die Checksumme war).
-                payload_length = self.index - 1
-                if payload_length < 0: # Falls nur Message ID und Checksumme, aber kein Payload
-                    payload_length = 0
-
-                self.on_message_received(self.message_id, self.message_buffer, payload_length)
-                self.state = ParserState.WAITING_FOR_START_BYTE
-                return # EndByte wurde verarbeitet, nicht zum Payload hinzufügen
-
-            # Normales Payload-Byte
-            if self.index < MAX_PAYLOAD_LENGTH + 1: # +1 für Checksummen-Byte
-                self.message_buffer[self.index] = pbyte
-                self.index += 1
-                self.checksum ^= pbyte
-            else:
-                # Nachricht zu lang
-                self.state = ParserState.WAITING_FOR_START_BYTE
-                self.error = ParserError.MESSAGE_TOO_LONG
-                self.on_message_fail(self.message_id, self.message_buffer, self.index, self.error)
-                return
-

tools/payload_parser.py

@@ -1,192 +0,0 @@
-import dataclasses
-import struct
-from typing import Optional, Union, List
-
-
-@dataclasses.dataclass
-class StatusMessage:
-    """
-    Repräsentiert eine Status-Nachricht (z.B. Message ID 0x01).
-    Payload-Format: [status_code: uint8], [battery_level: uint8], [uptime_seconds: uint16]
-    """
-    status_code: int
-    battery_level: int  # 0-100%
-    uptime_seconds: int
-
-
-@dataclasses.dataclass
-class SensorDataMessage:
-    """
-    Repräsentiert eine Sensor-Daten-Nachricht (z.B. Message ID 0x02).
-    Payload-Format: [temperature_celsius: int16], [humidity_percent: uint16]
-    """
-    temperature_celsius: int  # signed short
-    humidity_percent: int    # unsigned short
-
-
-@dataclasses.dataclass
-class ClientEntry:
-    """
-    Repräsentiert die Informationen für einen einzelnen Client innerhalb der ClientInfoMessage.
-    Payload-Format:
-    [client_id: uint8]
-    [is_available: uint8] (0=false, >0=true)
-    [is_slot_used: uint8] (0=false, >0=true)
-    [mac_address: bytes (6)]
-    [unoccupied_value_1: uint32]
-    [unoccupied_value_2: uint32]
-    Gesamt: 1 + 1 + 1 + 6 + 4 + 4 = 17 Bytes pro Eintrag.
-    """
-    client_id: int
-    is_available: bool
-    is_slot_used: bool
-    mac_address: bytes  # 6 Bytes MAC-Adresse
-    last_ping: int  # 4 Bytes, unbelegt
-    last_successfull_ping: int  # 4 Bytes, unbelegt
-
-
-@dataclasses.dataclass
-class ClientInfoMessage:
-    """
-    Repräsentiert eine Nachricht mit Client-Informationen (Message ID 0x03).
-    Payload-Format:
-    [num_clients: uint8]
-    [client_entry_1: ClientEntry]
-    [client_entry_2: ClientEntry]
-    ...
-    """
-    num_clients: int
-    clients: List[ClientEntry]
-
-
-@dataclasses.dataclass
-class UnknownMessage:
-    """
-    Repräsentiert eine Nachricht mit unbekannter ID oder fehlerhaftem Payload.
-    """
-    message_id: int
-    raw_payload: bytes
-    error_message: str
-
-# --- Payload Parser Klasse ---
-
-
-class PayloadParser:
-    """
-    Interpretiert den Payload einer UART-Nachricht basierend auf ihrer Message ID
-    und wandelt ihn in ein strukturiertes Python-Objekt (dataclass) um.
-    """
-
-    def __init__(self):
-        # Ein Dictionary, das Message IDs auf ihre entsprechenden Parsing-Funktionen abbildet.
-        self._parser_map = {
-            0x01: self._parse_status_message,
-            0x02: self._parse_sensor_data_message,
-            # Aktualisiert für die neue 0x03 Struktur
-            0x03: self._parse_client_info_message,
-            0x04: self._parse_client_info_message,
-            # Füge hier weitere Message IDs und ihre Parsing-Funktionen hinzu
-        }
-
-    def _parse_status_message(self, payload: bytes) -> Union[StatusMessage, UnknownMessage]:
-        """Parsen des Payloads für Message ID 0x01 (StatusMessage)."""
-        # Erwartetes Format: 1 Byte Status, 1 Byte Battery, 2 Bytes Uptime (Little-Endian)
-        if len(payload) != 4:
-            return UnknownMessage(0x01, payload, f"Falsche Payload-Länge für StatusMessage: Erwartet 4, Got {len(payload)}")
-        try:
-            # '<BBH' bedeutet: Little-Endian, Byte (unsigned char), Byte (unsigned char), Half-word (unsigned short)
-            status_code, battery_level, uptime_seconds = struct.unpack(
-                '<BBH', payload)
-            return StatusMessage(status_code, battery_level, uptime_seconds)
-        except struct.error as e:
-            return UnknownMessage(0x01, payload, f"Fehler beim Entpacken der StatusMessage: {e}")
-
-    def _parse_sensor_data_message(self, payload: bytes) -> Union[SensorDataMessage, UnknownMessage]:
-        """Parsen des Payloads für Message ID 0x02 (SensorDataMessage)."""
-        # Erwartetes Format: 2 Bytes Temperatur (signed short), 2 Bytes Feuchtigkeit (unsigned short) (Little-Endian)
-        if len(payload) != 4:
-            return UnknownMessage(0x02, payload, f"Falsche Payload-Länge für SensorDataMessage: Erwartet 4, Got {len(payload)}")
-        try:
-            # '<hH' bedeutet: Little-Endian, short (signed), unsigned short
-            temperature_celsius, humidity_percent = struct.unpack(
-                '<hH', payload)
-            return SensorDataMessage(temperature_celsius, humidity_percent)
-        except struct.error as e:
-            return UnknownMessage(0x02, payload, f"Fehler beim Entpacken der SensorDataMessage: {e}")
-
-    def _parse_client_info_message(self, payload: bytes) -> Union[ClientInfoMessage, UnknownMessage]:
-        """Parsen des Payloads für Message ID 0x03 (ClientInfoMessage)."""
-        if not payload:
-            # Wenn der Payload leer ist, aber num_clients erwartet wird, ist das ein Fehler
-            return UnknownMessage(0x03, payload, "Payload für ClientInfoMessage ist leer, aber num_clients erwartet.")
-
-        try:
-            # Das erste Byte ist die Anzahl der Clients
-            num_clients = payload[0]
-            # Die restlichen Bytes sind die Client-Einträge
-            client_data_bytes = payload[1:]
-
-            # 1 (ID) + 1 (Avail) + 1 (Used) + 6 (MAC) + 4 (Val1) + 4 (Val2)
-            EXPECTED_CLIENT_ENTRY_SIZE = 17
-
-            if len(client_data_bytes) != num_clients * EXPECTED_CLIENT_ENTRY_SIZE:
-                return UnknownMessage(0x03, payload,
-                                      f"Falsche Payload-Länge für Client-Einträge: Erwartet {
-                                          num_clients * EXPECTED_CLIENT_ENTRY_SIZE}, "
-                                      f"Got {len(client_data_bytes)} nach num_clients.")
-
-            clients_list: List[ClientEntry] = []
-            # Formatstring für einen Client-Eintrag:
-            # < : Little-Endian
-            # B : uint8 (client_id, is_available, is_slot_used)
-            # 6s: 6 Bytes (mac_address)
-            # I : uint32 (unoccupied_value_1, unoccupied_value_2)
-            CLIENT_ENTRY_FORMAT = '<BBB6sII'
-
-            for i in range(num_clients):
-                start_index = i * EXPECTED_CLIENT_ENTRY_SIZE
-                end_index = start_index + EXPECTED_CLIENT_ENTRY_SIZE
-                entry_bytes = client_data_bytes[start_index:end_index]
-
-                # Entpacke die Daten für einen Client-Eintrag
-                client_id, is_available_byte, is_slot_used_byte, mac_address, val1, val2 = \
-                    struct.unpack(CLIENT_ENTRY_FORMAT, entry_bytes)
-
-                # Konvertiere 0/1 Bytes zu boolschen Werten
-                is_available = bool(is_available_byte)
-                is_slot_used = bool(is_slot_used_byte)
-
-                clients_list.append(ClientEntry(
-                    client_id=client_id,
-                    is_available=is_available,
-                    is_slot_used=is_slot_used,
-                    mac_address=mac_address,
-                    last_ping=val1,
-                    last_successfull_ping=val2
-                ))
-
-            return ClientInfoMessage(num_clients=num_clients, clients=clients_list)
-
-        except struct.error as e:
-            return UnknownMessage(0x03, payload, f"Fehler beim Entpacken der ClientInfoMessage-Einträge: {e}")
-        except Exception as e:
-            return UnknownMessage(0x03, payload, f"Unerwarteter Fehler beim Parsen der ClientInfoMessage: {e}")
-
-    def parse_payload(self, message_id: int, payload: bytes) -> Union[StatusMessage, SensorDataMessage, ClientInfoMessage, UnknownMessage]:
-        """
-        Interpretiert den gegebenen Payload basierend auf der Message ID.
-
-        Args:
-            message_id (int): Die ID der Nachricht.
-            payload (bytes): Die rohen Nutzdaten der Nachricht.
-
-        Returns:
-            Union[StatusMessage, SensorDataMessage, ClientInfoMessage, UnknownMessage]:
-            Ein dataclass-Objekt, das die dekodierten Daten repräsentiert,
-            oder ein UnknownMessage-Objekt bei unbekannter ID oder Parsing-Fehler.
-        """
-        parser_func = self._parser_map.get(message_id)
-        if parser_func:
-            return parser_func(payload)
-        else:
-            return UnknownMessage(message_id, payload, "Unbekannte Message ID.")