Compare commits
12
Commits
b45823c479
...
c
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
ac6a900ded | ||
|
|
d4ffb1561d | ||
|
|
05c4bb87f9 | ||
|
|
47f4a6663b | ||
|
|
bf0429c505 | ||
|
|
b3e9fc9663 | ||
|
|
b783d97f13 | ||
|
|
47c17dba36 | ||
|
|
e75723e2e7 | ||
|
|
52a5f0f8c4 | ||
|
|
646b988cdd | ||
|
|
615431d6c5 |
No files matched your search
+3
-1
@@ -1 +1,3 @@
|
||||
settings.json
|
||||
settings.json
|
||||
__pycache__/
|
||||
c/build/
|
||||
@@ -0,0 +1,15 @@
|
||||
[[source]]
|
||||
url = "https://pypi.org/simple"
|
||||
verify_ssl = true
|
||||
name = "pypi"
|
||||
|
||||
[packages]
|
||||
esptool = "*"
|
||||
mpremote = "*"
|
||||
pyserial = "*"
|
||||
requests = "*"
|
||||
|
||||
[dev-packages]
|
||||
|
||||
[requires]
|
||||
python_version = "3.13"
|
||||
Generated
+617
@@ -0,0 +1,617 @@
|
||||
{
|
||||
"_meta": {
|
||||
"hash": {
|
||||
"sha256": "eb62a51e8d40130b1e758dc972ead3111fe880e1638e2b7e6037a44b4831dbeb"
|
||||
},
|
||||
"pipfile-spec": 6,
|
||||
"requires": {
|
||||
"python_version": "3.13"
|
||||
},
|
||||
"sources": [
|
||||
{
|
||||
"name": "pypi",
|
||||
"url": "https://pypi.org/simple",
|
||||
"verify_ssl": true
|
||||
}
|
||||
]
|
||||
},
|
||||
"default": {
|
||||
"bitarray": {
|
||||
"hashes": [
|
||||
"sha256:004d518fa410e6da43386d20e07b576a41eb417ac67abf9f30fa75e125697199",
|
||||
"sha256:014df8a9430276862392ac5d471697de042367996c49f32d0008585d2c60755a",
|
||||
"sha256:01c5f0dc080b0ebb432f7a68ee1e88a76bd34f6d89c9568fcec65fb16ed71f0e",
|
||||
"sha256:025d133bf4ca8cf75f904eeb8ea946228d7c043231866143f31946a6f4dd0bf3",
|
||||
"sha256:0ca70ccf789446a6dfde40b482ec21d28067172cd1f8efd50d5548159fccad9e",
|
||||
"sha256:0df69d26f21a9d2f1b20266f6737fa43f08aa5015c99900fb69f255fbe4dabb4",
|
||||
"sha256:0f8069a807a3e6e3c361ce302ece4bf1c3b49962c1726d1d56587e8f48682861",
|
||||
"sha256:15a2eff91f54d2b1f573cca8ca6fb58763ce8fea80e7899ab028f3987ef71cd5",
|
||||
"sha256:15e8d0597cc6e8496de6f4dea2a6880c57e1251502a7072f5631108a1aa28521",
|
||||
"sha256:165052a0e61c880f7093808a0c524ce1b3555bfa114c0dfb5c809cd07918a60d",
|
||||
"sha256:178c5a4c7fdfb5cd79e372ae7f675390e670f3732e5bc68d327e01a5b3ff8d55",
|
||||
"sha256:18214bac86341f1cc413772e66447d6cca10981e2880b70ecaf4e826c04f95e9",
|
||||
"sha256:1a54d7e7999735faacdcbe8128e30207abc2caf9f9fd7102d180b32f1b78bfce",
|
||||
"sha256:1a926fa554870642607fd10e66ee25b75fdd9a7ca4bbffa93d424e4ae2bf734a",
|
||||
"sha256:1c8f2a5d8006db5a555e06f9437e76bf52537d3dfd130cb8ae2b30866aca32c9",
|
||||
"sha256:21ca6a47bf20db9e7ad74ca04b3d479e4d76109b68333eb23535553d2705339e",
|
||||
"sha256:22c540ed20167d3dbb1e2d868ca935180247d620c40eace90efa774504a40e3b",
|
||||
"sha256:239578587b9c29469ab61149dda40a2fe714a6a4eca0f8ff9ea9439ec4b7bc30",
|
||||
"sha256:25b9cff6c9856bc396232e2f609ea0c5ec1a8a24c500cee4cca96ba8a3cd50b6",
|
||||
"sha256:26714898eb0d847aac8af94c4441c9cb50387847d0fe6b9fc4217c086cd68b80",
|
||||
"sha256:28a85b056c0eb7f5d864c0ceef07034117e8ebfca756f50648c71950a568ba11",
|
||||
"sha256:2a3d1b05ffdd3e95687942ae7b13c63689f85d3f15c39b33329e3cb9ce6c015f",
|
||||
"sha256:2c3bb96b6026643ce24677650889b09073f60b9860a71765f843c99f9ab38b25",
|
||||
"sha256:2fa23fdb3beab313950bbb49674e8a161e61449332d3997089fe3944953f1b77",
|
||||
"sha256:2fe8c54b15a9cd4f93bc2aaceab354ec65af93370aa1496ba2f9c537a4855ee0",
|
||||
"sha256:30989a2451b693c3f9359d91098a744992b5431a0be4858f1fdf0ec76b457125",
|
||||
"sha256:31a4ad2b730128e273f1c22300da3e3631f125703e4fee0ac44d385abfb15671",
|
||||
"sha256:337c8cd46a4c6568d367ed676cbf2d7de16f890bb31dbb54c44c1d6bb6d4a1de",
|
||||
"sha256:33af25c4ff7723363cb8404dfc2eefeab4110b654f6c98d26aba8a08c745d860",
|
||||
"sha256:3ea52df96566457735314794422274bd1962066bfb609e7eea9113d70cf04ffe",
|
||||
"sha256:3eae38daffd77c9621ae80c16932eea3fb3a4af141fb7cc724d4ad93eff9210d",
|
||||
"sha256:41b53711f89008ba2de62e4c2d2260a8b357072fd4f18e1351b28955db2719dc",
|
||||
"sha256:451f9958850ea98440d542278368c8d1e1ea821e2494b204570ba34a340759df",
|
||||
"sha256:46cf239856b87fe1c86dfbb3d459d840a8b1649e7922b1e0bfb6b6464692644a",
|
||||
"sha256:4779f356083c62e29b4198d290b7b17a39a69702d150678b7efff0fdddf494a8",
|
||||
"sha256:4902f4ecd5fcb6a5f482d7b0ae1c16c21f26fc5279b3b6127363d13ad8e7a9d9",
|
||||
"sha256:4d73d4948dcc5591d880db8933004e01f1dd2296df9de815354d53469beb26fe",
|
||||
"sha256:4d9984017314da772f5f7460add7a0301a4ffc06c72c2998bb16c300a6253607",
|
||||
"sha256:4f298daaaea58d45e245a132d6d2bdfb6f856da50dc03d75ebb761439fb626cf",
|
||||
"sha256:50ddbe3a7b4b6ab96812f5a4d570f401a2cdb95642fd04c062f98939610bbeee",
|
||||
"sha256:5338a313f998e1be7267191b7caaae82563b4a2b42b393561055412a34042caa",
|
||||
"sha256:5591daf81313096909d973fb2612fccd87528fdfdd39f6478bdce54543178954",
|
||||
"sha256:56896ceeffe25946c4010320629e2d858ca763cd8ded273c81672a5edbcb1e0a",
|
||||
"sha256:58a01ea34057463f7a98a4d6ff40160f65f945e924fec08a5b39e327e372875d",
|
||||
"sha256:5bfac7f236ba1a4d402644bdce47fb9db02a7cf3214a1f637d3a88390f9e5428",
|
||||
"sha256:5c5a8a83df95e51f7a7c2b083eaea134cbed39fc42c6aeb2e764ddb7ccccd43e",
|
||||
"sha256:5f2fb10518f6b365f5b720e43a529c3b2324ca02932f609631a44edb347d8d54",
|
||||
"sha256:64af877116edf051375b45f0bda648143176a017b13803ec7b3a3111dc05f4c5",
|
||||
"sha256:6d70fa9c6d2e955bde8cd327ffc11f2cc34bc21944e5571a46ca501e7eadef24",
|
||||
"sha256:6d79f659965290af60d6acc8e2716341865fe74609a7ede2a33c2f86ad893b8f",
|
||||
"sha256:720963fee259291a88348ae9735d9deb5d334e84a016244f61c89f5a49aa400a",
|
||||
"sha256:75a3b6e9c695a6570ea488db75b84bb592ff70a944957efa1c655867c575018b",
|
||||
"sha256:792462abfeeca6cc8c6c1e6d27e14319682f0182f6b0ba37befe911af794db70",
|
||||
"sha256:79ec4498a545733ecace48d780d22407411b07403a2e08b9a4d7596c0b97ebd7",
|
||||
"sha256:7f14d6b303e55bd7d19b28309ef8014370e84a3806c5e452e078e7df7344d97a",
|
||||
"sha256:7f65bd5d4cdb396295b6aa07f84ca659ac65c5c68b53956a6d95219e304b0ada",
|
||||
"sha256:81c6b4a6c1af800d52a6fa32389ef8f4281583f4f99dc1a40f2bb47667281541",
|
||||
"sha256:82a07de83dce09b4fa1bccbdc8bde8f188b131666af0dc9048ba0a0e448d8a3b",
|
||||
"sha256:847c7f61964225fc489fe1d49eda7e0e0d253e98862c012cecf845f9ad45cdf4",
|
||||
"sha256:84b52b2cf77bb7f703d16c4007b021078dbbe6cf8ffb57abe81a7bacfc175ef2",
|
||||
"sha256:86685fa04067f7175f9718489ae755f6acde03593a1a9ca89305554af40e14fd",
|
||||
"sha256:8a9c962c64a4c08def58b9799333e33af94ec53038cf151d36edacdb41f81646",
|
||||
"sha256:8cbd4bfc933b33b85c43ef4c1f4d5e3e9d91975ea6368acf5fbac02bac06ea89",
|
||||
"sha256:8ffe660e963ae711cb9e2b8d8461c9b1ad6167823837fc17d59d5e539fb898fa",
|
||||
"sha256:94652da1a4ca7cfb69c15dd6986b205e0bd9c63a05029c3b48b4201085f527bd",
|
||||
"sha256:969fd67de8c42affdb47b38b80f1eaa79ac0ef17d65407cdd931db1675315af1",
|
||||
"sha256:9858dcbc23ba7eaadcd319786b982278a1a2b2020720b19db43e309579ff76fb",
|
||||
"sha256:99d25aff3745c54e61ab340b98400c52ebec04290a62078155e0d7eb30380220",
|
||||
"sha256:99f55e14e7c56f4fafe1343480c32b110ef03836c21ff7c48bae7add6818f77c",
|
||||
"sha256:9d35d8f8a1c9ed4e2b08187b513f8a3c71958600129db3aa26d85ea3abfd1310",
|
||||
"sha256:a2ba92f59e30ce915e9e79af37649432e3a212ddddf416d4d686b1b4825bcdb2",
|
||||
"sha256:a2cb35a6efaa0e3623d8272471371a12c7e07b51a33e5efce9b58f655d864b4e",
|
||||
"sha256:a358277122456666a8b2a0b9aa04f1b89d34e8aa41d08a6557d693e6abb6667c",
|
||||
"sha256:a60da2f9efbed355edb35a1fb6829148676786c829fad708bb6bb47211b3593a",
|
||||
"sha256:aa7dec53c25f1949513457ef8b0ea1fb40e76c672cc4d2daa8ad3c8d6b73491a",
|
||||
"sha256:b1572ee0eb1967e71787af636bb7d1eb9c6735d5337762c450650e7f51844594",
|
||||
"sha256:b4f10d3f304be7183fac79bf2cd997f82e16aa9a9f37343d76c026c6e435a8a8",
|
||||
"sha256:bbbbfbb7d039b20d289ce56b1beb46138d65769d04af50c199c6ac4cb6054d52",
|
||||
"sha256:c394a3f055b49f92626f83c1a0b6d6cd2c628f1ccd72481c3e3c6aa4695f3b20",
|
||||
"sha256:c396358023b876cff547ce87f4e8ff8a2280598873a137e8cc69e115262260b8",
|
||||
"sha256:c5ba07e58fd98c9782201e79eb8dd4225733d212a5a3700f9a84d329bd0463a6",
|
||||
"sha256:c764fb167411d5afaef88138542a4bfa28bd5e5ded5e8e42df87cef965efd6e9",
|
||||
"sha256:cbba763d99de0255a3e4938f25a8579930ac8aa089233cb2fb2ed7d04d4aff02",
|
||||
"sha256:cbd1660fb48827381ce3a621a4fdc237959e1cd4e98b098952a8f624a0726425",
|
||||
"sha256:cd761d158f67e288fd0ebe00c3b158095ce80a4bc7c32b60c7121224003ba70d",
|
||||
"sha256:cdfbb27f2c46bb5bbdcee147530cbc5ca8ab858d7693924e88e30ada21b2c5e2",
|
||||
"sha256:d2dbe8a3baf2d842e342e8acb06ae3844765d38df67687c144cdeb71f1bcb5d7",
|
||||
"sha256:d5c931ec1c03111718cabf85f6012bb2815fa0ce578175567fa8d6f2cc15d3b4",
|
||||
"sha256:df6d7bf3e15b7e6e202a16ff4948a51759354016026deb04ab9b5acbbe35e096",
|
||||
"sha256:dfbe2aa45b273f49e715c5345d94874cb65a28482bf231af408891c260601b8d",
|
||||
"sha256:e12769d3adcc419e65860de946df8d2ed274932177ac1cdb05186e498aaa9149",
|
||||
"sha256:e5aed4754895942ae15ffa48c52d181e1c1463236fda68d2dba29c03aa61786b",
|
||||
"sha256:e645b4c365d6f1f9e0799380ad6395268f3c3b898244a650aaeb8d9d27b74c35",
|
||||
"sha256:ed3493a369fe849cce98542d7405c88030b355e4d2e113887cb7ecc86c205773",
|
||||
"sha256:f08342dc8d19214faa7ef99574dea6c37a2790d6d04a9793ef8fa76c188dc08d",
|
||||
"sha256:f0a55cf02d2cdd739b40ce10c09bbdd520e141217696add7a48b56e67bdfdfe6",
|
||||
"sha256:f0ce9d9e07c75da8027c62b4c9f45771d1d8aae7dc9ad7fb606c6a5aedbe9741",
|
||||
"sha256:f1f723e260c35e1c7c57a09d3a6ebe681bd56c83e1208ae3ce1869b7c0d10d4f",
|
||||
"sha256:f2fcbe9b3a5996b417e030aa33a562e7e20dfc86271e53d7e841fc5df16268b8",
|
||||
"sha256:f3fd8df63c41ff6a676d031956aebf68ebbc687b47c507da25501eb22eec341f",
|
||||
"sha256:f8d3417db5e14a6789073b21ae44439a755289477901901bae378a57b905e148",
|
||||
"sha256:fbf05678c2ae0064fb1b8de7e9e8f0fc30621b73c8477786dd0fb3868044a8c8",
|
||||
"sha256:fc98ff43abad61f00515ad9a06213b7716699146e46eabd256cdfe7cb522bd97",
|
||||
"sha256:ff1863f037dad765ef5963efc2e37d399ac023e192a6f2bb394e2377d023cefe"
|
||||
],
|
||||
"version": "==3.8.0"
|
||||
},
|
||||
"bitstring": {
|
||||
"hashes": [
|
||||
"sha256:69d1587f0ac18dc7d93fc7e80d5f447161a33e57027e726dc18a0a8bacf1711a",
|
||||
"sha256:a08bc09d3857216d4c0f412a1611056f1cc2b64fd254fb1e8a0afba7cfa1a95a"
|
||||
],
|
||||
"markers": "python_version >= '3.8'",
|
||||
"version": "==4.3.1"
|
||||
},
|
||||
"certifi": {
|
||||
"hashes": [
|
||||
"sha256:9943707519e4add1115f44c2bc244f782c0249876bf51b6599fee1ffbedd685c",
|
||||
"sha256:ac726dd470482006e014ad384921ed6438c457018f4b3d204aea4281258b2120"
|
||||
],
|
||||
"markers": "python_version >= '3.7'",
|
||||
"version": "==2026.1.4"
|
||||
},
|
||||
"cffi": {
|
||||
"hashes": [
|
||||
"sha256:00bdf7acc5f795150faa6957054fbbca2439db2f775ce831222b66f192f03beb",
|
||||
"sha256:07b271772c100085dd28b74fa0cd81c8fb1a3ba18b21e03d7c27f3436a10606b",
|
||||
"sha256:087067fa8953339c723661eda6b54bc98c5625757ea62e95eb4898ad5e776e9f",
|
||||
"sha256:0a1527a803f0a659de1af2e1fd700213caba79377e27e4693648c2923da066f9",
|
||||
"sha256:0cf2d91ecc3fcc0625c2c530fe004f82c110405f101548512cce44322fa8ac44",
|
||||
"sha256:0f6084a0ea23d05d20c3edcda20c3d006f9b6f3fefeac38f59262e10cef47ee2",
|
||||
"sha256:12873ca6cb9b0f0d3a0da705d6086fe911591737a59f28b7936bdfed27c0d47c",
|
||||
"sha256:19f705ada2530c1167abacb171925dd886168931e0a7b78f5bffcae5c6b5be75",
|
||||
"sha256:1cd13c99ce269b3ed80b417dcd591415d3372bcac067009b6e0f59c7d4015e65",
|
||||
"sha256:1e3a615586f05fc4065a8b22b8152f0c1b00cdbc60596d187c2a74f9e3036e4e",
|
||||
"sha256:1f72fb8906754ac8a2cc3f9f5aaa298070652a0ffae577e0ea9bd480dc3c931a",
|
||||
"sha256:1fc9ea04857caf665289b7a75923f2c6ed559b8298a1b8c49e59f7dd95c8481e",
|
||||
"sha256:203a48d1fb583fc7d78a4c6655692963b860a417c0528492a6bc21f1aaefab25",
|
||||
"sha256:2081580ebb843f759b9f617314a24ed5738c51d2aee65d31e02f6f7a2b97707a",
|
||||
"sha256:21d1152871b019407d8ac3985f6775c079416c282e431a4da6afe7aefd2bccbe",
|
||||
"sha256:24b6f81f1983e6df8db3adc38562c83f7d4a0c36162885ec7f7b77c7dcbec97b",
|
||||
"sha256:256f80b80ca3853f90c21b23ee78cd008713787b1b1e93eae9f3d6a7134abd91",
|
||||
"sha256:28a3a209b96630bca57cce802da70c266eb08c6e97e5afd61a75611ee6c64592",
|
||||
"sha256:2c8f814d84194c9ea681642fd164267891702542f028a15fc97d4674b6206187",
|
||||
"sha256:2de9a304e27f7596cd03d16f1b7c72219bd944e99cc52b84d0145aefb07cbd3c",
|
||||
"sha256:38100abb9d1b1435bc4cc340bb4489635dc2f0da7456590877030c9b3d40b0c1",
|
||||
"sha256:3925dd22fa2b7699ed2617149842d2e6adde22b262fcbfada50e3d195e4b3a94",
|
||||
"sha256:3e17ed538242334bf70832644a32a7aae3d83b57567f9fd60a26257e992b79ba",
|
||||
"sha256:3e837e369566884707ddaf85fc1744b47575005c0a229de3327f8f9a20f4efeb",
|
||||
"sha256:3f4d46d8b35698056ec29bca21546e1551a205058ae1a181d871e278b0b28165",
|
||||
"sha256:44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529",
|
||||
"sha256:45d5e886156860dc35862657e1494b9bae8dfa63bf56796f2fb56e1679fc0bca",
|
||||
"sha256:4647afc2f90d1ddd33441e5b0e85b16b12ddec4fca55f0d9671fef036ecca27c",
|
||||
"sha256:4671d9dd5ec934cb9a73e7ee9676f9362aba54f7f34910956b84d727b0d73fb6",
|
||||
"sha256:53f77cbe57044e88bbd5ed26ac1d0514d2acf0591dd6bb02a3ae37f76811b80c",
|
||||
"sha256:5eda85d6d1879e692d546a078b44251cdd08dd1cfb98dfb77b670c97cee49ea0",
|
||||
"sha256:5fed36fccc0612a53f1d4d9a816b50a36702c28a2aa880cb8a122b3466638743",
|
||||
"sha256:61d028e90346df14fedc3d1e5441df818d095f3b87d286825dfcbd6459b7ef63",
|
||||
"sha256:66f011380d0e49ed280c789fbd08ff0d40968ee7b665575489afa95c98196ab5",
|
||||
"sha256:6824f87845e3396029f3820c206e459ccc91760e8fa24422f8b0c3d1731cbec5",
|
||||
"sha256:6c6c373cfc5c83a975506110d17457138c8c63016b563cc9ed6e056a82f13ce4",
|
||||
"sha256:6d02d6655b0e54f54c4ef0b94eb6be0607b70853c45ce98bd278dc7de718be5d",
|
||||
"sha256:6d50360be4546678fc1b79ffe7a66265e28667840010348dd69a314145807a1b",
|
||||
"sha256:730cacb21e1bdff3ce90babf007d0a0917cc3e6492f336c2f0134101e0944f93",
|
||||
"sha256:737fe7d37e1a1bffe70bd5754ea763a62a066dc5913ca57e957824b72a85e205",
|
||||
"sha256:74a03b9698e198d47562765773b4a8309919089150a0bb17d829ad7b44b60d27",
|
||||
"sha256:7553fb2090d71822f02c629afe6042c299edf91ba1bf94951165613553984512",
|
||||
"sha256:7a66c7204d8869299919db4d5069a82f1561581af12b11b3c9f48c584eb8743d",
|
||||
"sha256:7cc09976e8b56f8cebd752f7113ad07752461f48a58cbba644139015ac24954c",
|
||||
"sha256:81afed14892743bbe14dacb9e36d9e0e504cd204e0b165062c488942b9718037",
|
||||
"sha256:8941aaadaf67246224cee8c3803777eed332a19d909b47e29c9842ef1e79ac26",
|
||||
"sha256:89472c9762729b5ae1ad974b777416bfda4ac5642423fa93bd57a09204712322",
|
||||
"sha256:8ea985900c5c95ce9db1745f7933eeef5d314f0565b27625d9a10ec9881e1bfb",
|
||||
"sha256:8eca2a813c1cb7ad4fb74d368c2ffbbb4789d377ee5bb8df98373c2cc0dee76c",
|
||||
"sha256:92b68146a71df78564e4ef48af17551a5ddd142e5190cdf2c5624d0c3ff5b2e8",
|
||||
"sha256:9332088d75dc3241c702d852d4671613136d90fa6881da7d770a483fd05248b4",
|
||||
"sha256:94698a9c5f91f9d138526b48fe26a199609544591f859c870d477351dc7b2414",
|
||||
"sha256:9a67fc9e8eb39039280526379fb3a70023d77caec1852002b4da7e8b270c4dd9",
|
||||
"sha256:9de40a7b0323d889cf8d23d1ef214f565ab154443c42737dfe52ff82cf857664",
|
||||
"sha256:a05d0c237b3349096d3981b727493e22147f934b20f6f125a3eba8f994bec4a9",
|
||||
"sha256:afb8db5439b81cf9c9d0c80404b60c3cc9c3add93e114dcae767f1477cb53775",
|
||||
"sha256:b18a3ed7d5b3bd8d9ef7a8cb226502c6bf8308df1525e1cc676c3680e7176739",
|
||||
"sha256:b1e74d11748e7e98e2f426ab176d4ed720a64412b6a15054378afdb71e0f37dc",
|
||||
"sha256:b21e08af67b8a103c71a250401c78d5e0893beff75e28c53c98f4de42f774062",
|
||||
"sha256:b4c854ef3adc177950a8dfc81a86f5115d2abd545751a304c5bcf2c2c7283cfe",
|
||||
"sha256:b882b3df248017dba09d6b16defe9b5c407fe32fc7c65a9c69798e6175601be9",
|
||||
"sha256:baf5215e0ab74c16e2dd324e8ec067ef59e41125d3eade2b863d294fd5035c92",
|
||||
"sha256:c649e3a33450ec82378822b3dad03cc228b8f5963c0c12fc3b1e0ab940f768a5",
|
||||
"sha256:c654de545946e0db659b3400168c9ad31b5d29593291482c43e3564effbcee13",
|
||||
"sha256:c6638687455baf640e37344fe26d37c404db8b80d037c3d29f58fe8d1c3b194d",
|
||||
"sha256:c8d3b5532fc71b7a77c09192b4a5a200ea992702734a2e9279a37f2478236f26",
|
||||
"sha256:cb527a79772e5ef98fb1d700678fe031e353e765d1ca2d409c92263c6d43e09f",
|
||||
"sha256:cf364028c016c03078a23b503f02058f1814320a56ad535686f90565636a9495",
|
||||
"sha256:d48a880098c96020b02d5a1f7d9251308510ce8858940e6fa99ece33f610838b",
|
||||
"sha256:d68b6cef7827e8641e8ef16f4494edda8b36104d79773a334beaa1e3521430f6",
|
||||
"sha256:d9b29c1f0ae438d5ee9acb31cadee00a58c46cc9c0b2f9038c6b0b3470877a8c",
|
||||
"sha256:d9b97165e8aed9272a6bb17c01e3cc5871a594a446ebedc996e2397a1c1ea8ef",
|
||||
"sha256:da68248800ad6320861f129cd9c1bf96ca849a2771a59e0344e88681905916f5",
|
||||
"sha256:da902562c3e9c550df360bfa53c035b2f241fed6d9aef119048073680ace4a18",
|
||||
"sha256:dbd5c7a25a7cb98f5ca55d258b103a2054f859a46ae11aaf23134f9cc0d356ad",
|
||||
"sha256:dd4f05f54a52fb558f1ba9f528228066954fee3ebe629fc1660d874d040ae5a3",
|
||||
"sha256:de8dad4425a6ca6e4e5e297b27b5c824ecc7581910bf9aee86cb6835e6812aa7",
|
||||
"sha256:e11e82b744887154b182fd3e7e8512418446501191994dbf9c9fc1f32cc8efd5",
|
||||
"sha256:e6e73b9e02893c764e7e8d5bb5ce277f1a009cd5243f8228f75f842bf937c534",
|
||||
"sha256:f73b96c41e3b2adedc34a7356e64c8eb96e03a3782b535e043a986276ce12a49",
|
||||
"sha256:f93fd8e5c8c0a4aa1f424d6173f14a892044054871c771f8566e4008eaa359d2",
|
||||
"sha256:fc33c5141b55ed366cfaad382df24fe7dcbc686de5be719b207bb248e3053dc5",
|
||||
"sha256:fc7de24befaeae77ba923797c7c87834c73648a05a4bde34b3b7e5588973a453",
|
||||
"sha256:fe562eb1a64e67dd297ccc4f5addea2501664954f2692b69a76449ec7913ecbf"
|
||||
],
|
||||
"markers": "python_full_version >= '3.9' and platform_python_implementation != 'PyPy'",
|
||||
"version": "==2.0.0"
|
||||
},
|
||||
"charset-normalizer": {
|
||||
"hashes": [
|
||||
"sha256:027f6de494925c0ab2a55eab46ae5129951638a49a34d87f4c3eda90f696b4ad",
|
||||
"sha256:077fbb858e903c73f6c9db43374fd213b0b6a778106bc7032446a8e8b5b38b93",
|
||||
"sha256:0a98e6759f854bd25a58a73fa88833fba3b7c491169f86ce1180c948ab3fd394",
|
||||
"sha256:0d3d8f15c07f86e9ff82319b3d9ef6f4bf907608f53fe9d92b28ea9ae3d1fd89",
|
||||
"sha256:0f04b14ffe5fdc8c4933862d8306109a2c51e0704acfa35d51598eb45a1e89fc",
|
||||
"sha256:11d694519d7f29d6cd09f6ac70028dba10f92f6cdd059096db198c283794ac86",
|
||||
"sha256:194f08cbb32dc406d6e1aea671a68be0823673db2832b38405deba2fb0d88f63",
|
||||
"sha256:1bee1e43c28aa63cb16e5c14e582580546b08e535299b8b6158a7c9c768a1f3d",
|
||||
"sha256:21d142cc6c0ec30d2efee5068ca36c128a30b0f2c53c1c07bd78cb6bc1d3be5f",
|
||||
"sha256:2437418e20515acec67d86e12bf70056a33abdacb5cb1655042f6538d6b085a8",
|
||||
"sha256:244bfb999c71b35de57821b8ea746b24e863398194a4014e4c76adc2bbdfeff0",
|
||||
"sha256:2677acec1a2f8ef614c6888b5b4ae4060cc184174a938ed4e8ef690e15d3e505",
|
||||
"sha256:277e970e750505ed74c832b4bf75dac7476262ee2a013f5574dd49075879e161",
|
||||
"sha256:2aaba3b0819274cc41757a1da876f810a3e4d7b6eb25699253a4effef9e8e4af",
|
||||
"sha256:2b7d8f6c26245217bd2ad053761201e9f9680f8ce52f0fcd8d0755aeae5b2152",
|
||||
"sha256:2c9d3c380143a1fedbff95a312aa798578371eb29da42106a29019368a475318",
|
||||
"sha256:3162d5d8ce1bb98dd51af660f2121c55d0fa541b46dff7bb9b9f86ea1d87de72",
|
||||
"sha256:31fd66405eaf47bb62e8cd575dc621c56c668f27d46a61d975a249930dd5e2a4",
|
||||
"sha256:362d61fd13843997c1c446760ef36f240cf81d3ebf74ac62652aebaf7838561e",
|
||||
"sha256:376bec83a63b8021bb5c8ea75e21c4ccb86e7e45ca4eb81146091b56599b80c3",
|
||||
"sha256:44c2a8734b333e0578090c4cd6b16f275e07aa6614ca8715e6c038e865e70576",
|
||||
"sha256:47cc91b2f4dd2833fddaedd2893006b0106129d4b94fdb6af1f4ce5a9965577c",
|
||||
"sha256:4902828217069c3c5c71094537a8e623f5d097858ac6ca8252f7b4d10b7560f1",
|
||||
"sha256:4bd5d4137d500351a30687c2d3971758aac9a19208fc110ccb9d7188fbe709e8",
|
||||
"sha256:4fe7859a4e3e8457458e2ff592f15ccb02f3da787fcd31e0183879c3ad4692a1",
|
||||
"sha256:542d2cee80be6f80247095cc36c418f7bddd14f4a6de45af91dfad36d817bba2",
|
||||
"sha256:554af85e960429cf30784dd47447d5125aaa3b99a6f0683589dbd27e2f45da44",
|
||||
"sha256:5833d2c39d8896e4e19b689ffc198f08ea58116bee26dea51e362ecc7cd3ed26",
|
||||
"sha256:5947809c8a2417be3267efc979c47d76a079758166f7d43ef5ae8e9f92751f88",
|
||||
"sha256:5ae497466c7901d54b639cf42d5b8c1b6a4fead55215500d2f486d34db48d016",
|
||||
"sha256:5bd2293095d766545ec1a8f612559f6b40abc0eb18bb2f5d1171872d34036ede",
|
||||
"sha256:5bfbb1b9acf3334612667b61bd3002196fe2a1eb4dd74d247e0f2a4d50ec9bbf",
|
||||
"sha256:5cb4d72eea50c8868f5288b7f7f33ed276118325c1dfd3957089f6b519e1382a",
|
||||
"sha256:5dbe56a36425d26d6cfb40ce79c314a2e4dd6211d51d6d2191c00bed34f354cc",
|
||||
"sha256:5f819d5fe9234f9f82d75bdfa9aef3a3d72c4d24a6e57aeaebba32a704553aa0",
|
||||
"sha256:64b55f9dce520635f018f907ff1b0df1fdc31f2795a922fb49dd14fbcdf48c84",
|
||||
"sha256:6515f3182dbe4ea06ced2d9e8666d97b46ef4c75e326b79bb624110f122551db",
|
||||
"sha256:65e2befcd84bc6f37095f5961e68a6f077bf44946771354a28ad434c2cce0ae1",
|
||||
"sha256:6aee717dcfead04c6eb1ce3bd29ac1e22663cdea57f943c87d1eab9a025438d7",
|
||||
"sha256:6b39f987ae8ccdf0d2642338faf2abb1862340facc796048b604ef14919e55ed",
|
||||
"sha256:6e1fcf0720908f200cd21aa4e6750a48ff6ce4afe7ff5a79a90d5ed8a08296f8",
|
||||
"sha256:74018750915ee7ad843a774364e13a3db91682f26142baddf775342c3f5b1133",
|
||||
"sha256:74664978bb272435107de04e36db5a9735e78232b85b77d45cfb38f758efd33e",
|
||||
"sha256:74bb723680f9f7a6234dcf67aea57e708ec1fbdf5699fb91dfd6f511b0a320ef",
|
||||
"sha256:752944c7ffbfdd10c074dc58ec2d5a8a4cd9493b314d367c14d24c17684ddd14",
|
||||
"sha256:778d2e08eda00f4256d7f672ca9fef386071c9202f5e4607920b86d7803387f2",
|
||||
"sha256:780236ac706e66881f3b7f2f32dfe90507a09e67d1d454c762cf642e6e1586e0",
|
||||
"sha256:798d75d81754988d2565bff1b97ba5a44411867c0cf32b77a7e8f8d84796b10d",
|
||||
"sha256:799a7a5e4fb2d5898c60b640fd4981d6a25f1c11790935a44ce38c54e985f828",
|
||||
"sha256:7a32c560861a02ff789ad905a2fe94e3f840803362c84fecf1851cb4cf3dc37f",
|
||||
"sha256:7c308f7e26e4363d79df40ca5b2be1c6ba9f02bdbccfed5abddb7859a6ce72cf",
|
||||
"sha256:7fa17817dc5625de8a027cb8b26d9fefa3ea28c8253929b8d6649e705d2835b6",
|
||||
"sha256:81d5eb2a312700f4ecaa977a8235b634ce853200e828fbadf3a9c50bab278328",
|
||||
"sha256:82004af6c302b5d3ab2cfc4cc5f29db16123b1a8417f2e25f9066f91d4411090",
|
||||
"sha256:837c2ce8c5a65a2035be9b3569c684358dfbf109fd3b6969630a87535495ceaa",
|
||||
"sha256:840c25fb618a231545cbab0564a799f101b63b9901f2569faecd6b222ac72381",
|
||||
"sha256:8a6562c3700cce886c5be75ade4a5db4214fda19fede41d9792d100288d8f94c",
|
||||
"sha256:8af65f14dc14a79b924524b1e7fffe304517b2bff5a58bf64f30b98bbc5079eb",
|
||||
"sha256:8ef3c867360f88ac904fd3f5e1f902f13307af9052646963ee08ff4f131adafc",
|
||||
"sha256:94537985111c35f28720e43603b8e7b43a6ecfb2ce1d3058bbe955b73404e21a",
|
||||
"sha256:99ae2cffebb06e6c22bdc25801d7b30f503cc87dbd283479e7b606f70aff57ec",
|
||||
"sha256:9a26f18905b8dd5d685d6d07b0cdf98a79f3c7a918906af7cc143ea2e164c8bc",
|
||||
"sha256:9b35f4c90079ff2e2edc5b26c0c77925e5d2d255c42c74fdb70fb49b172726ac",
|
||||
"sha256:9cd98cdc06614a2f768d2b7286d66805f94c48cde050acdbbb7db2600ab3197e",
|
||||
"sha256:9d1bb833febdff5c8927f922386db610b49db6e0d4f4ee29601d71e7c2694313",
|
||||
"sha256:9f7fcd74d410a36883701fafa2482a6af2ff5ba96b9a620e9e0721e28ead5569",
|
||||
"sha256:a59cb51917aa591b1c4e6a43c132f0cdc3c76dbad6155df4e28ee626cc77a0a3",
|
||||
"sha256:a61900df84c667873b292c3de315a786dd8dac506704dea57bc957bd31e22c7d",
|
||||
"sha256:a79cfe37875f822425b89a82333404539ae63dbdddf97f84dcbc3d339aae9525",
|
||||
"sha256:a8a8b89589086a25749f471e6a900d3f662d1d3b6e2e59dcecf787b1cc3a1894",
|
||||
"sha256:a8bf8d0f749c5757af2142fe7903a9df1d2e8aa3841559b2bad34b08d0e2bcf3",
|
||||
"sha256:a9768c477b9d7bd54bc0c86dbaebdec6f03306675526c9927c0e8a04e8f94af9",
|
||||
"sha256:ac1c4a689edcc530fc9d9aa11f5774b9e2f33f9a0c6a57864e90908f5208d30a",
|
||||
"sha256:af2d8c67d8e573d6de5bc30cdb27e9b95e49115cd9baad5ddbd1a6207aaa82a9",
|
||||
"sha256:b435cba5f4f750aa6c0a0d92c541fb79f69a387c91e61f1795227e4ed9cece14",
|
||||
"sha256:b5b290ccc2a263e8d185130284f8501e3e36c5e02750fc6b6bdeb2e9e96f1e25",
|
||||
"sha256:b5d84d37db046c5ca74ee7bb47dd6cbc13f80665fdde3e8040bdd3fb015ecb50",
|
||||
"sha256:b7cf1017d601aa35e6bb650b6ad28652c9cd78ee6caff19f3c28d03e1c80acbf",
|
||||
"sha256:bc7637e2f80d8530ee4a78e878bce464f70087ce73cf7c1caf142416923b98f1",
|
||||
"sha256:c0463276121fdee9c49b98908b3a89c39be45d86d1dbaa22957e38f6321d4ce3",
|
||||
"sha256:c4ef880e27901b6cc782f1b95f82da9313c0eb95c3af699103088fa0ac3ce9ac",
|
||||
"sha256:c8ae8a0f02f57a6e61203a31428fa1d677cbe50c93622b4149d5c0f319c1d19e",
|
||||
"sha256:ca5862d5b3928c4940729dacc329aa9102900382fea192fc5e52eb69d6093815",
|
||||
"sha256:cb01158d8b88ee68f15949894ccc6712278243d95f344770fa7593fa2d94410c",
|
||||
"sha256:cb6254dc36b47a990e59e1068afacdcd02958bdcce30bb50cc1700a8b9d624a6",
|
||||
"sha256:cc00f04ed596e9dc0da42ed17ac5e596c6ccba999ba6bd92b0e0aef2f170f2d6",
|
||||
"sha256:cd09d08005f958f370f539f186d10aec3377d55b9eeb0d796025d4886119d76e",
|
||||
"sha256:cd4b7ca9984e5e7985c12bc60a6f173f3c958eae74f3ef6624bb6b26e2abbae4",
|
||||
"sha256:ce8a0633f41a967713a59c4139d29110c07e826d131a316b50ce11b1d79b4f84",
|
||||
"sha256:cead0978fc57397645f12578bfd2d5ea9138ea0fac82b2f63f7f7c6877986a69",
|
||||
"sha256:d055ec1e26e441f6187acf818b73564e6e6282709e9bcb5b63f5b23068356a15",
|
||||
"sha256:d1f13550535ad8cff21b8d757a3257963e951d96e20ec82ab44bc64aeb62a191",
|
||||
"sha256:d9c7f57c3d666a53421049053eaacdd14bbd0a528e2186fcb2e672effd053bb0",
|
||||
"sha256:d9e45d7faa48ee908174d8fe84854479ef838fc6a705c9315372eacbc2f02897",
|
||||
"sha256:da3326d9e65ef63a817ecbcc0df6e94463713b754fe293eaa03da99befb9a5bd",
|
||||
"sha256:de00632ca48df9daf77a2c65a484531649261ec9f25489917f09e455cb09ddb2",
|
||||
"sha256:e1f185f86a6f3403aa2420e815904c67b2f9ebc443f045edd0de921108345794",
|
||||
"sha256:e824f1492727fa856dd6eda4f7cee25f8518a12f3c4a56a74e8095695089cf6d",
|
||||
"sha256:e912091979546adf63357d7e2ccff9b44f026c075aeaf25a52d0e95ad2281074",
|
||||
"sha256:eaabd426fe94daf8fd157c32e571c85cb12e66692f15516a83a03264b08d06c3",
|
||||
"sha256:ebf3e58c7ec8a8bed6d66a75d7fb37b55e5015b03ceae72a8e7c74495551e224",
|
||||
"sha256:ecaae4149d99b1c9e7b88bb03e3221956f68fd6d50be2ef061b2381b61d20838",
|
||||
"sha256:eecbc200c7fd5ddb9a7f16c7decb07b566c29fa2161a16cf67b8d068bd21690a",
|
||||
"sha256:f155a433c2ec037d4e8df17d18922c3a0d9b3232a396690f17175d2946f0218d",
|
||||
"sha256:f1e34719c6ed0b92f418c7c780480b26b5d9c50349e9a9af7d76bf757530350d",
|
||||
"sha256:f34be2938726fc13801220747472850852fe6b1ea75869a048d6f896838c896f",
|
||||
"sha256:f820802628d2694cb7e56db99213f930856014862f3fd943d290ea8438d07ca8",
|
||||
"sha256:f8bf04158c6b607d747e93949aa60618b61312fe647a6369f88ce2ff16043490",
|
||||
"sha256:f8e160feb2aed042cd657a72acc0b481212ed28b1b9a95c0cee1621b524e1966",
|
||||
"sha256:f9d332f8c2a2fcbffe1378594431458ddbef721c1769d78e2cbc06280d8155f9",
|
||||
"sha256:fa09f53c465e532f4d3db095e0c55b615f010ad81803d383195b6b5ca6cbf5f3",
|
||||
"sha256:faa3a41b2b66b6e50f84ae4a68c64fcd0c44355741c6374813a800cd6695db9e",
|
||||
"sha256:fd44c878ea55ba351104cb93cc85e74916eb8fa440ca7903e57575e97394f608"
|
||||
],
|
||||
"markers": "python_version >= '3.7'",
|
||||
"version": "==3.4.4"
|
||||
},
|
||||
"click": {
|
||||
"hashes": [
|
||||
"sha256:12ff4785d337a1bb490bb7e9c2b1ee5da3112e94a8622f26a6c77f5d2fc6842a",
|
||||
"sha256:981153a64e25f12d547d3426c367a4857371575ee7ad18df2a6183ab0545b2a6"
|
||||
],
|
||||
"markers": "python_version >= '3.10'",
|
||||
"version": "==8.3.1"
|
||||
},
|
||||
"cryptography": {
|
||||
"hashes": [
|
||||
"sha256:02f547fce831f5096c9a567fd41bc12ca8f11df260959ecc7c3202555cc47a72",
|
||||
"sha256:039917b0dc418bb9f6edce8a906572d69e74bd330b0b3fea4f79dab7f8ddd235",
|
||||
"sha256:1abfdb89b41c3be0365328a410baa9df3ff8a9110fb75e7b52e66803ddabc9a9",
|
||||
"sha256:2ae6971afd6246710480e3f15824ed3029a60fc16991db250034efd0b9fb4356",
|
||||
"sha256:2b7a67c9cd56372f3249b39699f2ad479f6991e62ea15800973b956f4b73e257",
|
||||
"sha256:351695ada9ea9618b3500b490ad54c739860883df6c1f555e088eaf25b1bbaad",
|
||||
"sha256:38946c54b16c885c72c4f59846be9743d699eee2b69b6988e0a00a01f46a61a4",
|
||||
"sha256:3b4995dc971c9fb83c25aa44cf45f02ba86f71ee600d81091c2f0cbae116b06c",
|
||||
"sha256:3ce58ba46e1bc2aac4f7d9290223cead56743fa6ab94a5d53292ffaac6a91614",
|
||||
"sha256:3ee190460e2fbe447175cda91b88b84ae8322a104fc27766ad09428754a618ed",
|
||||
"sha256:4108d4c09fbbf2789d0c926eb4152ae1760d5a2d97612b92d508d96c861e4d31",
|
||||
"sha256:420d0e909050490d04359e7fdb5ed7e667ca5c3c402b809ae2563d7e66a92229",
|
||||
"sha256:47fb8a66058b80e509c47118ef8a75d14c455e81ac369050f20ba0d23e77fee0",
|
||||
"sha256:4c3341037c136030cb46e4b1e17b7418ea4cbd9dd207e4a6f3b2b24e0d4ac731",
|
||||
"sha256:4d7e3d356b8cd4ea5aff04f129d5f66ebdc7b6f8eae802b93739ed520c47c79b",
|
||||
"sha256:4d8ae8659ab18c65ced284993c2265910f6c9e650189d4e3f68445ef82a810e4",
|
||||
"sha256:4e817a8920bfbcff8940ecfd60f23d01836408242b30f1a708d93198393a80b4",
|
||||
"sha256:50bfb6925eff619c9c023b967d5b77a54e04256c4281b0e21336a130cd7fc263",
|
||||
"sha256:556e106ee01aa13484ce9b0239bca667be5004efb0aabbed28d353df86445595",
|
||||
"sha256:582f5fcd2afa31622f317f80426a027f30dc792e9c80ffee87b993200ea115f1",
|
||||
"sha256:5be7bf2fb40769e05739dd0046e7b26f9d4670badc7b032d6ce4db64dddc0678",
|
||||
"sha256:60ee7e19e95104d4c03871d7d7dfb3d22ef8a9b9c6778c94e1c8fcc8365afd48",
|
||||
"sha256:61aa400dce22cb001a98014f647dc21cda08f7915ceb95df0c9eaf84b4b6af76",
|
||||
"sha256:68f68d13f2e1cb95163fa3b4db4bf9a159a418f5f6e7242564fc75fcae667fd0",
|
||||
"sha256:7d1f30a86d2757199cb2d56e48cce14deddf1f9c95f1ef1b64ee91ea43fe2e18",
|
||||
"sha256:7d731d4b107030987fd61a7f8ab512b25b53cef8f233a97379ede116f30eb67d",
|
||||
"sha256:803812e111e75d1aa73690d2facc295eaefd4439be1023fefc4995eaea2af90d",
|
||||
"sha256:80a8d7bfdf38f87ca30a5391c0c9ce4ed2926918e017c29ddf643d0ed2778ea1",
|
||||
"sha256:8293f3dea7fc929ef7240796ba231413afa7b68ce38fd21da2995549f5961981",
|
||||
"sha256:8456928655f856c6e1533ff59d5be76578a7157224dbd9ce6872f25055ab9ab7",
|
||||
"sha256:890bcb4abd5a2d3f852196437129eb3667d62630333aacc13dfd470fad3aaa82",
|
||||
"sha256:94a76daa32eb78d61339aff7952ea819b1734b46f73646a07decb40e5b3448e2",
|
||||
"sha256:9f16fbdf4da055efb21c22d81b89f155f02ba420558db21288b3d0035bafd5f4",
|
||||
"sha256:a3d1fae9863299076f05cb8a778c467578262fae09f9dc0ee9b12eb4268ce663",
|
||||
"sha256:a3d507bb6a513ca96ba84443226af944b0f7f47dcc9a399d110cd6146481d24c",
|
||||
"sha256:abace499247268e3757271b2f1e244b36b06f8515cf27c4d49468fc9eb16e93d",
|
||||
"sha256:ba2a27ff02f48193fc4daeadf8ad2590516fa3d0adeeb34336b96f7fa64c1e3a",
|
||||
"sha256:bc84e875994c3b445871ea7181d424588171efec3e185dced958dad9e001950a",
|
||||
"sha256:bfd56bb4b37ed4f330b82402f6f435845a5f5648edf1ad497da51a8452d5d62d",
|
||||
"sha256:c18ff11e86df2e28854939acde2d003f7984f721eba450b56a200ad90eeb0e6b",
|
||||
"sha256:c3bcce8521d785d510b2aad26ae2c966092b7daa8f45dd8f44734a104dc0bc1a",
|
||||
"sha256:c4143987a42a2397f2fc3b4d7e3a7d313fbe684f67ff443999e803dd75a76826",
|
||||
"sha256:c69fd885df7d089548a42d5ec05be26050ebcd2283d89b3d30676eb32ff87dee",
|
||||
"sha256:ced80795227d70549a411a4ab66e8ce307899fad2220ce5ab2f296e687eacde9",
|
||||
"sha256:d66e421495fdb797610a08f43b05269e0a5ea7f5e652a89bfd5a7d3c1dee3648",
|
||||
"sha256:d861ee9e76ace6cf36a6a89b959ec08e7bc2493ee39d07ffe5acb23ef46d27da",
|
||||
"sha256:e9251e3be159d1020c4030bd2e5f84d6a43fe54b6c19c12f51cde9542a2817b2",
|
||||
"sha256:f145bba11b878005c496e93e257c1e88f154d278d2638e6450d17e0f31e558d2",
|
||||
"sha256:fe346b143ff9685e40192a4960938545c699054ba11d4f9029f94751e3f71d87"
|
||||
],
|
||||
"markers": "python_version >= '3.8' and python_full_version not in '3.9.0, 3.9.1'",
|
||||
"version": "==46.0.5"
|
||||
},
|
||||
"esptool": {
|
||||
"hashes": [
|
||||
"sha256:2ea9bcd7eb263d380a4fe0170856a10e4c65e3f38c757ebdc73584c8dd8322da"
|
||||
],
|
||||
"index": "pypi",
|
||||
"markers": "python_version >= '3.10'",
|
||||
"version": "==5.1.0"
|
||||
},
|
||||
"idna": {
|
||||
"hashes": [
|
||||
"sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea",
|
||||
"sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902"
|
||||
],
|
||||
"markers": "python_version >= '3.8'",
|
||||
"version": "==3.11"
|
||||
},
|
||||
"intelhex": {
|
||||
"hashes": [
|
||||
"sha256:87cc5225657524ec6361354be928adfd56bcf2a3dcc646c40f8f094c39c07db4",
|
||||
"sha256:892b7361a719f4945237da8ccf754e9513db32f5628852785aea108dcd250093"
|
||||
],
|
||||
"version": "==2.3.0"
|
||||
},
|
||||
"markdown-it-py": {
|
||||
"hashes": [
|
||||
"sha256:87327c59b172c5011896038353a81343b6754500a08cd7a4973bb48c6d578147",
|
||||
"sha256:cb0a2b4aa34f932c007117b194e945bd74e0ec24133ceb5bac59009cda1cb9f3"
|
||||
],
|
||||
"markers": "python_version >= '3.10'",
|
||||
"version": "==4.0.0"
|
||||
},
|
||||
"mdurl": {
|
||||
"hashes": [
|
||||
"sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8",
|
||||
"sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba"
|
||||
],
|
||||
"markers": "python_version >= '3.7'",
|
||||
"version": "==0.1.2"
|
||||
},
|
||||
"mpremote": {
|
||||
"hashes": [
|
||||
"sha256:11d134c69b21b487dae3d03eed54c8ccbf84c916c8732a3e069a97cae47be3d4",
|
||||
"sha256:6bb75774648091dad6833af4f86c5bf6505f8d7aec211380f9e6996c01d23cb5"
|
||||
],
|
||||
"index": "pypi",
|
||||
"markers": "python_version >= '3.4'",
|
||||
"version": "==1.27.0"
|
||||
},
|
||||
"platformdirs": {
|
||||
"hashes": [
|
||||
"sha256:1ed8db354e344c5bb6039cd727f096af975194b508e37177719d562b2b540ee6",
|
||||
"sha256:fd1a5f8599c85d49b9ac7d6e450bc2f1aaf4a23f1fe86d09952fe20ad365cf36"
|
||||
],
|
||||
"markers": "python_version >= '3.10'",
|
||||
"version": "==4.7.0"
|
||||
},
|
||||
"pycparser": {
|
||||
"hashes": [
|
||||
"sha256:600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29",
|
||||
"sha256:b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992"
|
||||
],
|
||||
"markers": "implementation_name != 'PyPy'",
|
||||
"version": "==3.0"
|
||||
},
|
||||
"pygments": {
|
||||
"hashes": [
|
||||
"sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887",
|
||||
"sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b"
|
||||
],
|
||||
"markers": "python_version >= '3.8'",
|
||||
"version": "==2.19.2"
|
||||
},
|
||||
"pyserial": {
|
||||
"hashes": [
|
||||
"sha256:3c77e014170dfffbd816e6ffc205e9842efb10be9f58ec16d3e8675b4925cddb",
|
||||
"sha256:c4451db6ba391ca6ca299fb3ec7bae67a5c55dde170964c7a14ceefec02f2cf0"
|
||||
],
|
||||
"index": "pypi",
|
||||
"version": "==3.5"
|
||||
},
|
||||
"pyyaml": {
|
||||
"hashes": [
|
||||
"sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c",
|
||||
"sha256:0150219816b6a1fa26fb4699fb7daa9caf09eb1999f3b70fb6e786805e80375a",
|
||||
"sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3",
|
||||
"sha256:02ea2dfa234451bbb8772601d7b8e426c2bfa197136796224e50e35a78777956",
|
||||
"sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6",
|
||||
"sha256:10892704fc220243f5305762e276552a0395f7beb4dbf9b14ec8fd43b57f126c",
|
||||
"sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65",
|
||||
"sha256:1d37d57ad971609cf3c53ba6a7e365e40660e3be0e5175fa9f2365a379d6095a",
|
||||
"sha256:1ebe39cb5fc479422b83de611d14e2c0d3bb2a18bbcb01f229ab3cfbd8fee7a0",
|
||||
"sha256:214ed4befebe12df36bcc8bc2b64b396ca31be9304b8f59e25c11cf94a4c033b",
|
||||
"sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1",
|
||||
"sha256:22ba7cfcad58ef3ecddc7ed1db3409af68d023b7f940da23c6c2a1890976eda6",
|
||||
"sha256:27c0abcb4a5dac13684a37f76e701e054692a9b2d3064b70f5e4eb54810553d7",
|
||||
"sha256:28c8d926f98f432f88adc23edf2e6d4921ac26fb084b028c733d01868d19007e",
|
||||
"sha256:2e71d11abed7344e42a8849600193d15b6def118602c4c176f748e4583246007",
|
||||
"sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310",
|
||||
"sha256:37503bfbfc9d2c40b344d06b2199cf0e96e97957ab1c1b546fd4f87e53e5d3e4",
|
||||
"sha256:3c5677e12444c15717b902a5798264fa7909e41153cdf9ef7ad571b704a63dd9",
|
||||
"sha256:3ff07ec89bae51176c0549bc4c63aa6202991da2d9a6129d7aef7f1407d3f295",
|
||||
"sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea",
|
||||
"sha256:418cf3f2111bc80e0933b2cd8cd04f286338bb88bdc7bc8e6dd775ebde60b5e0",
|
||||
"sha256:44edc647873928551a01e7a563d7452ccdebee747728c1080d881d68af7b997e",
|
||||
"sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac",
|
||||
"sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9",
|
||||
"sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7",
|
||||
"sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35",
|
||||
"sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb",
|
||||
"sha256:5cf4e27da7e3fbed4d6c3d8e797387aaad68102272f8f9752883bc32d61cb87b",
|
||||
"sha256:5e0b74767e5f8c593e8c9b5912019159ed0533c70051e9cce3e8b6aa699fcd69",
|
||||
"sha256:5ed875a24292240029e4483f9d4a4b8a1ae08843b9c54f43fcc11e404532a8a5",
|
||||
"sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b",
|
||||
"sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c",
|
||||
"sha256:6344df0d5755a2c9a276d4473ae6b90647e216ab4757f8426893b5dd2ac3f369",
|
||||
"sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd",
|
||||
"sha256:652cb6edd41e718550aad172851962662ff2681490a8a711af6a4d288dd96824",
|
||||
"sha256:66291b10affd76d76f54fad28e22e51719ef9ba22b29e1d7d03d6777a9174198",
|
||||
"sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065",
|
||||
"sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c",
|
||||
"sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c",
|
||||
"sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764",
|
||||
"sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196",
|
||||
"sha256:8098f252adfa6c80ab48096053f512f2321f0b998f98150cea9bd23d83e1467b",
|
||||
"sha256:850774a7879607d3a6f50d36d04f00ee69e7fc816450e5f7e58d7f17f1ae5c00",
|
||||
"sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac",
|
||||
"sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8",
|
||||
"sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e",
|
||||
"sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28",
|
||||
"sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3",
|
||||
"sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5",
|
||||
"sha256:9c57bb8c96f6d1808c030b1687b9b5fb476abaa47f0db9c0101f5e9f394e97f4",
|
||||
"sha256:9c7708761fccb9397fe64bbc0395abcae8c4bf7b0eac081e12b809bf47700d0b",
|
||||
"sha256:9f3bfb4965eb874431221a3ff3fdcddc7e74e3b07799e0e84ca4a0f867d449bf",
|
||||
"sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5",
|
||||
"sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702",
|
||||
"sha256:b30236e45cf30d2b8e7b3e85881719e98507abed1011bf463a8fa23e9c3e98a8",
|
||||
"sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788",
|
||||
"sha256:b865addae83924361678b652338317d1bd7e79b1f4596f96b96c77a5a34b34da",
|
||||
"sha256:b8bb0864c5a28024fac8a632c443c87c5aa6f215c0b126c449ae1a150412f31d",
|
||||
"sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc",
|
||||
"sha256:bdb2c67c6c1390b63c6ff89f210c8fd09d9a1217a465701eac7316313c915e4c",
|
||||
"sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba",
|
||||
"sha256:c2514fceb77bc5e7a2f7adfaa1feb2fb311607c9cb518dbc378688ec73d8292f",
|
||||
"sha256:c3355370a2c156cffb25e876646f149d5d68f5e0a3ce86a5084dd0b64a994917",
|
||||
"sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5",
|
||||
"sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26",
|
||||
"sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f",
|
||||
"sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b",
|
||||
"sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be",
|
||||
"sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c",
|
||||
"sha256:efd7b85f94a6f21e4932043973a7ba2613b059c4a000551892ac9f1d11f5baf3",
|
||||
"sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6",
|
||||
"sha256:fa160448684b4e94d80416c0fa4aac48967a969efe22931448d853ada8baf926",
|
||||
"sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0"
|
||||
],
|
||||
"markers": "python_version >= '3.8'",
|
||||
"version": "==6.0.3"
|
||||
},
|
||||
"reedsolo": {
|
||||
"hashes": [
|
||||
"sha256:2b6a3e402a1ee3e1eea3f932f81e6c0b7bbc615588074dca1dbbcdeb055002bd",
|
||||
"sha256:c1359f02742751afe0f1c0de9f0772cc113835aa2855d2db420ea24393c87732"
|
||||
],
|
||||
"version": "==1.7.0"
|
||||
},
|
||||
"requests": {
|
||||
"hashes": [
|
||||
"sha256:2462f94637a34fd532264295e186976db0f5d453d1cdd31473c85a6a161affb6",
|
||||
"sha256:dbba0bac56e100853db0ea71b82b4dfd5fe2bf6d3754a8893c3af500cec7d7cf"
|
||||
],
|
||||
"index": "pypi",
|
||||
"markers": "python_version >= '3.9'",
|
||||
"version": "==2.32.5"
|
||||
},
|
||||
"rich": {
|
||||
"hashes": [
|
||||
"sha256:08e67c3e90884651da3239ea668222d19bea7b589149d8014a21c633420dbb69",
|
||||
"sha256:e712f11c1a562a11843306f5ed999475f09ac31ffb64281f73ab29ffdda8b3b8"
|
||||
],
|
||||
"markers": "python_full_version >= '3.8.0'",
|
||||
"version": "==14.3.2"
|
||||
},
|
||||
"rich-click": {
|
||||
"hashes": [
|
||||
"sha256:022997c1e30731995bdbc8ec2f82819340d42543237f033a003c7b1f843fc5dc",
|
||||
"sha256:2f99120fca78f536e07b114d3b60333bc4bb2a0969053b1250869bcdc1b5351b"
|
||||
],
|
||||
"markers": "python_version >= '3.8'",
|
||||
"version": "==1.9.7"
|
||||
},
|
||||
"urllib3": {
|
||||
"hashes": [
|
||||
"sha256:1b62b6884944a57dbe321509ab94fd4d3b307075e0c2eae991ac71ee15ad38ed",
|
||||
"sha256:bf272323e553dfb2e87d9bfd225ca7b0f467b919d7bbd355436d3fd37cb0acd4"
|
||||
],
|
||||
"markers": "python_version >= '3.9'",
|
||||
"version": "==2.6.3"
|
||||
}
|
||||
},
|
||||
"develop": {}
|
||||
}
|
||||
@@ -0,0 +1,99 @@
|
||||
cmake_minimum_required(VERSION 3.13)
|
||||
|
||||
set(PICO_BOARD pico2_w CACHE STRING "Board type")
|
||||
|
||||
include(pico_sdk_import.cmake)
|
||||
|
||||
project(led_hoop C CXX ASM)
|
||||
|
||||
pico_sdk_init()
|
||||
set(CMAKE_CXX_STANDARD 17)
|
||||
set(CMAKE_CXX_STANDARD_REQUIRED ON)
|
||||
|
||||
file(GLOB_RECURSE SRC_SOURCES CONFIGURE_DEPENDS
|
||||
"${CMAKE_CURRENT_LIST_DIR}/src/*.c"
|
||||
"${CMAKE_CURRENT_LIST_DIR}/src/*.cpp"
|
||||
)
|
||||
file(GLOB_RECURSE LIB_SOURCES CONFIGURE_DEPENDS
|
||||
"${CMAKE_CURRENT_LIST_DIR}/lib/*.c"
|
||||
"${CMAKE_CURRENT_LIST_DIR}/lib/*.cpp"
|
||||
"${CMAKE_CURRENT_LIST_DIR}/lib/**/*.c"
|
||||
"${CMAKE_CURRENT_LIST_DIR}/lib/**/*.cpp"
|
||||
)
|
||||
|
||||
# Embed web UI from normal files under web/ (headers generated into build/)
|
||||
set(WEB_GEN_DIR "${CMAKE_CURRENT_BINARY_DIR}/generated")
|
||||
set(EMBED_SCRIPT "${CMAKE_CURRENT_LIST_DIR}/scripts/embed_file.py")
|
||||
set(WEB_ASSETS
|
||||
"${WEB_GEN_DIR}/web_index_html.h"
|
||||
"${WEB_GEN_DIR}/web_main_js.h"
|
||||
"${WEB_GEN_DIR}/web_styles_css.h"
|
||||
)
|
||||
add_custom_command(
|
||||
OUTPUT "${WEB_GEN_DIR}/web_index_html.h"
|
||||
COMMAND ${CMAKE_COMMAND} -E make_directory "${WEB_GEN_DIR}"
|
||||
COMMAND python3 "${EMBED_SCRIPT}"
|
||||
"${CMAKE_CURRENT_LIST_DIR}/web/index.html" web_index_html
|
||||
"${WEB_GEN_DIR}/web_index_html.h"
|
||||
DEPENDS "${CMAKE_CURRENT_LIST_DIR}/web/index.html" "${EMBED_SCRIPT}"
|
||||
VERBATIM
|
||||
)
|
||||
add_custom_command(
|
||||
OUTPUT "${WEB_GEN_DIR}/web_main_js.h"
|
||||
COMMAND ${CMAKE_COMMAND} -E make_directory "${WEB_GEN_DIR}"
|
||||
COMMAND python3 "${EMBED_SCRIPT}"
|
||||
"${CMAKE_CURRENT_LIST_DIR}/web/static/main.js" web_main_js
|
||||
"${WEB_GEN_DIR}/web_main_js.h"
|
||||
DEPENDS "${CMAKE_CURRENT_LIST_DIR}/web/static/main.js" "${EMBED_SCRIPT}"
|
||||
VERBATIM
|
||||
)
|
||||
add_custom_command(
|
||||
OUTPUT "${WEB_GEN_DIR}/web_styles_css.h"
|
||||
COMMAND ${CMAKE_COMMAND} -E make_directory "${WEB_GEN_DIR}"
|
||||
COMMAND python3 "${EMBED_SCRIPT}"
|
||||
"${CMAKE_CURRENT_LIST_DIR}/web/static/styles.css" web_styles_css
|
||||
"${WEB_GEN_DIR}/web_styles_css.h"
|
||||
DEPENDS "${CMAKE_CURRENT_LIST_DIR}/web/static/styles.css" "${EMBED_SCRIPT}"
|
||||
VERBATIM
|
||||
)
|
||||
add_custom_target(web_assets DEPENDS ${WEB_ASSETS})
|
||||
|
||||
add_executable(led_hoop
|
||||
${SRC_SOURCES}
|
||||
${LIB_SOURCES}
|
||||
)
|
||||
add_dependencies(led_hoop web_assets)
|
||||
|
||||
target_include_directories(led_hoop PRIVATE
|
||||
${CMAKE_CURRENT_LIST_DIR}
|
||||
${CMAKE_CURRENT_LIST_DIR}/src
|
||||
${CMAKE_CURRENT_LIST_DIR}/lib
|
||||
${CMAKE_CURRENT_LIST_DIR}/lib/httpserver
|
||||
${WEB_GEN_DIR}
|
||||
)
|
||||
|
||||
target_link_libraries(led_hoop
|
||||
pico_stdlib
|
||||
pico_multicore
|
||||
hardware_pio
|
||||
hardware_dma
|
||||
hardware_clocks
|
||||
hardware_flash
|
||||
pico_cyw43_arch_lwip_threadsafe_background
|
||||
pico_bootsel_via_double_reset
|
||||
)
|
||||
|
||||
# Ensure picotool can force the running app into BOOTSEL (no button)
|
||||
target_compile_definitions(led_hoop PRIVATE
|
||||
PICO_ENABLE_USB_RESET_VIA_VENDOR_INTERFACE=1
|
||||
PICO_ENABLE_USB_RESET_VIA_BAUD_RATE=1
|
||||
)
|
||||
|
||||
pico_configure_ip4_address(led_hoop PRIVATE
|
||||
CYW43_DEFAULT_IP_AP_ADDRESS 192.168.4.1
|
||||
)
|
||||
|
||||
pico_enable_stdio_usb(led_hoop 1)
|
||||
pico_enable_stdio_uart(led_hoop 0)
|
||||
|
||||
pico_add_extra_outputs(led_hoop)
|
||||
+43
@@ -0,0 +1,43 @@
|
||||
# Pico 2 W firmware
|
||||
#
|
||||
# make build | flash | test | reset | monitor | clean
|
||||
# make monitor PORT=/dev/ttyACM0
|
||||
|
||||
PICO_SDK_PATH ?= $(HOME)/pico-sdk
|
||||
CMAKE_PREFIX_PATH ?= $(HOME)/.local
|
||||
BUILD_DIR ?= build
|
||||
TARGET ?= led_hoop
|
||||
PORT ?= /dev/ttyACM0
|
||||
BAUD ?= 115200
|
||||
FLASH_WAIT_S ?= 20
|
||||
|
||||
export PICO_SDK_PATH
|
||||
export PATH := $(HOME)/.local/bin:$(PATH)
|
||||
|
||||
UF2 := $(BUILD_DIR)/$(TARGET).uf2
|
||||
|
||||
.PHONY: all build flash test reset monitor clean
|
||||
|
||||
all: build
|
||||
|
||||
build:
|
||||
cmake -S . -B $(BUILD_DIR) -DCMAKE_PREFIX_PATH=$(CMAKE_PREFIX_PATH)
|
||||
cmake --build $(BUILD_DIR) -j$$(nproc)
|
||||
|
||||
flash: build
|
||||
picotool load -fx $(UF2)
|
||||
|
||||
test: build
|
||||
picotool info $(UF2)
|
||||
|
||||
reset:
|
||||
picotool reboot -af
|
||||
|
||||
monitor:
|
||||
@echo "Waiting for $(PORT)..."
|
||||
@until [ -e "$(PORT)" ]; do sleep 0.25; done
|
||||
@sleep 0.5
|
||||
picocom -b $(BAUD) $(PORT)
|
||||
|
||||
clean:
|
||||
rm -rf $(BUILD_DIR)
|
||||
@@ -0,0 +1,309 @@
|
||||
/*
|
||||
* This file is part of the MicroPython project, http://micropython.org/
|
||||
*
|
||||
* The MIT License (MIT)
|
||||
*
|
||||
* Copyright (c) 2018-2019 Damien P. George
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
* in the Software without restriction, including without limitation the rights
|
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
* copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
* THE SOFTWARE.
|
||||
*/
|
||||
|
||||
// For DHCP specs see:
|
||||
// https://www.ietf.org/rfc/rfc2131.txt
|
||||
// https://tools.ietf.org/html/rfc2132 -- DHCP Options and BOOTP Vendor Extensions
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <errno.h>
|
||||
|
||||
#include "cyw43_config.h"
|
||||
#include "dhcpserver.h"
|
||||
#include "lwip/udp.h"
|
||||
|
||||
#define DHCPDISCOVER (1)
|
||||
#define DHCPOFFER (2)
|
||||
#define DHCPREQUEST (3)
|
||||
#define DHCPDECLINE (4)
|
||||
#define DHCPACK (5)
|
||||
#define DHCPNACK (6)
|
||||
#define DHCPRELEASE (7)
|
||||
#define DHCPINFORM (8)
|
||||
|
||||
#define DHCP_OPT_PAD (0)
|
||||
#define DHCP_OPT_SUBNET_MASK (1)
|
||||
#define DHCP_OPT_ROUTER (3)
|
||||
#define DHCP_OPT_DNS (6)
|
||||
#define DHCP_OPT_HOST_NAME (12)
|
||||
#define DHCP_OPT_REQUESTED_IP (50)
|
||||
#define DHCP_OPT_IP_LEASE_TIME (51)
|
||||
#define DHCP_OPT_MSG_TYPE (53)
|
||||
#define DHCP_OPT_SERVER_ID (54)
|
||||
#define DHCP_OPT_PARAM_REQUEST_LIST (55)
|
||||
#define DHCP_OPT_MAX_MSG_SIZE (57)
|
||||
#define DHCP_OPT_VENDOR_CLASS_ID (60)
|
||||
#define DHCP_OPT_CLIENT_ID (61)
|
||||
#define DHCP_OPT_END (255)
|
||||
|
||||
#define PORT_DHCP_SERVER (67)
|
||||
#define PORT_DHCP_CLIENT (68)
|
||||
|
||||
#define DEFAULT_LEASE_TIME_S (24 * 60 * 60) // in seconds
|
||||
|
||||
#define MAC_LEN (6)
|
||||
#define MAKE_IP4(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d))
|
||||
|
||||
typedef struct {
|
||||
uint8_t op; // message opcode
|
||||
uint8_t htype; // hardware address type
|
||||
uint8_t hlen; // hardware address length
|
||||
uint8_t hops;
|
||||
uint32_t xid; // transaction id, chosen by client
|
||||
uint16_t secs; // client seconds elapsed
|
||||
uint16_t flags;
|
||||
uint8_t ciaddr[4]; // client IP address
|
||||
uint8_t yiaddr[4]; // your IP address
|
||||
uint8_t siaddr[4]; // next server IP address
|
||||
uint8_t giaddr[4]; // relay agent IP address
|
||||
uint8_t chaddr[16]; // client hardware address
|
||||
uint8_t sname[64]; // server host name
|
||||
uint8_t file[128]; // boot file name
|
||||
uint8_t options[312]; // optional parameters, variable, starts with magic
|
||||
} dhcp_msg_t;
|
||||
|
||||
static int dhcp_socket_new_dgram(struct udp_pcb **udp, void *cb_data, udp_recv_fn cb_udp_recv) {
|
||||
// family is AF_INET
|
||||
// type is SOCK_DGRAM
|
||||
|
||||
*udp = udp_new();
|
||||
if (*udp == NULL) {
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
// Register callback
|
||||
udp_recv(*udp, cb_udp_recv, (void *)cb_data);
|
||||
|
||||
return 0; // success
|
||||
}
|
||||
|
||||
static void dhcp_socket_free(struct udp_pcb **udp) {
|
||||
if (*udp != NULL) {
|
||||
udp_remove(*udp);
|
||||
*udp = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
static int dhcp_socket_bind(struct udp_pcb **udp, uint16_t port) {
|
||||
// TODO convert lwIP errors to errno
|
||||
return udp_bind(*udp, IP_ANY_TYPE, port);
|
||||
}
|
||||
|
||||
static int dhcp_socket_sendto(struct udp_pcb **udp, struct netif *nif, const void *buf, size_t len, uint32_t ip, uint16_t port) {
|
||||
if (len > 0xffff) {
|
||||
len = 0xffff;
|
||||
}
|
||||
|
||||
struct pbuf *p = pbuf_alloc(PBUF_TRANSPORT, len, PBUF_RAM);
|
||||
if (p == NULL) {
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
memcpy(p->payload, buf, len);
|
||||
|
||||
ip_addr_t dest;
|
||||
IP4_ADDR(ip_2_ip4(&dest), ip >> 24 & 0xff, ip >> 16 & 0xff, ip >> 8 & 0xff, ip & 0xff);
|
||||
err_t err;
|
||||
if (nif != NULL) {
|
||||
err = udp_sendto_if(*udp, p, &dest, port, nif);
|
||||
} else {
|
||||
err = udp_sendto(*udp, p, &dest, port);
|
||||
}
|
||||
|
||||
pbuf_free(p);
|
||||
|
||||
if (err != ERR_OK) {
|
||||
return err;
|
||||
}
|
||||
|
||||
return len;
|
||||
}
|
||||
|
||||
static uint8_t *opt_find(uint8_t *opt, uint8_t cmd) {
|
||||
for (int i = 0; i < 308 && opt[i] != DHCP_OPT_END;) {
|
||||
if (opt[i] == cmd) {
|
||||
return &opt[i];
|
||||
}
|
||||
i += 2 + opt[i + 1];
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static void opt_write_n(uint8_t **opt, uint8_t cmd, size_t n, const void *data) {
|
||||
uint8_t *o = *opt;
|
||||
*o++ = cmd;
|
||||
*o++ = n;
|
||||
memcpy(o, data, n);
|
||||
*opt = o + n;
|
||||
}
|
||||
|
||||
static void opt_write_u8(uint8_t **opt, uint8_t cmd, uint8_t val) {
|
||||
uint8_t *o = *opt;
|
||||
*o++ = cmd;
|
||||
*o++ = 1;
|
||||
*o++ = val;
|
||||
*opt = o;
|
||||
}
|
||||
|
||||
static void opt_write_u32(uint8_t **opt, uint8_t cmd, uint32_t val) {
|
||||
uint8_t *o = *opt;
|
||||
*o++ = cmd;
|
||||
*o++ = 4;
|
||||
*o++ = val >> 24;
|
||||
*o++ = val >> 16;
|
||||
*o++ = val >> 8;
|
||||
*o++ = val;
|
||||
*opt = o;
|
||||
}
|
||||
|
||||
static void dhcp_server_process(void *arg, struct udp_pcb *upcb, struct pbuf *p, const ip_addr_t *src_addr, u16_t src_port) {
|
||||
dhcp_server_t *d = arg;
|
||||
(void)upcb;
|
||||
(void)src_addr;
|
||||
(void)src_port;
|
||||
|
||||
// This is around 548 bytes
|
||||
dhcp_msg_t dhcp_msg;
|
||||
|
||||
#define DHCP_MIN_SIZE (240 + 3)
|
||||
if (p->tot_len < DHCP_MIN_SIZE) {
|
||||
goto ignore_request;
|
||||
}
|
||||
|
||||
size_t len = pbuf_copy_partial(p, &dhcp_msg, sizeof(dhcp_msg), 0);
|
||||
if (len < DHCP_MIN_SIZE) {
|
||||
goto ignore_request;
|
||||
}
|
||||
|
||||
dhcp_msg.op = DHCPOFFER;
|
||||
memcpy(&dhcp_msg.yiaddr, &ip4_addr_get_u32(ip_2_ip4(&d->ip)), 4);
|
||||
|
||||
uint8_t *opt = (uint8_t *)&dhcp_msg.options;
|
||||
opt += 4; // assume magic cookie: 99, 130, 83, 99
|
||||
|
||||
uint8_t *msgtype = opt_find(opt, DHCP_OPT_MSG_TYPE);
|
||||
if (msgtype == NULL) {
|
||||
// A DHCP package without MSG_TYPE?
|
||||
goto ignore_request;
|
||||
}
|
||||
|
||||
switch (msgtype[2]) {
|
||||
case DHCPDISCOVER: {
|
||||
int yi = DHCPS_MAX_IP;
|
||||
for (int i = 0; i < DHCPS_MAX_IP; ++i) {
|
||||
if (memcmp(d->lease[i].mac, dhcp_msg.chaddr, MAC_LEN) == 0) {
|
||||
// MAC match, use this IP address
|
||||
yi = i;
|
||||
break;
|
||||
}
|
||||
if (yi == DHCPS_MAX_IP) {
|
||||
// Look for a free IP address
|
||||
if (memcmp(d->lease[i].mac, "\x00\x00\x00\x00\x00\x00", MAC_LEN) == 0) {
|
||||
// IP available
|
||||
yi = i;
|
||||
}
|
||||
uint32_t expiry = d->lease[i].expiry << 16 | 0xffff;
|
||||
if ((int32_t)(expiry - cyw43_hal_ticks_ms()) < 0) {
|
||||
// IP expired, reuse it
|
||||
memset(d->lease[i].mac, 0, MAC_LEN);
|
||||
yi = i;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (yi == DHCPS_MAX_IP) {
|
||||
// No more IP addresses left
|
||||
goto ignore_request;
|
||||
}
|
||||
dhcp_msg.yiaddr[3] = DHCPS_BASE_IP + yi;
|
||||
opt_write_u8(&opt, DHCP_OPT_MSG_TYPE, DHCPOFFER);
|
||||
break;
|
||||
}
|
||||
|
||||
case DHCPREQUEST: {
|
||||
uint8_t *o = opt_find(opt, DHCP_OPT_REQUESTED_IP);
|
||||
if (o == NULL) {
|
||||
// Should be NACK
|
||||
goto ignore_request;
|
||||
}
|
||||
if (memcmp(o + 2, &ip4_addr_get_u32(ip_2_ip4(&d->ip)), 3) != 0) {
|
||||
// Should be NACK
|
||||
goto ignore_request;
|
||||
}
|
||||
uint8_t yi = o[5] - DHCPS_BASE_IP;
|
||||
if (yi >= DHCPS_MAX_IP) {
|
||||
// Should be NACK
|
||||
goto ignore_request;
|
||||
}
|
||||
if (memcmp(d->lease[yi].mac, dhcp_msg.chaddr, MAC_LEN) == 0) {
|
||||
// MAC match, ok to use this IP address
|
||||
} else if (memcmp(d->lease[yi].mac, "\x00\x00\x00\x00\x00\x00", MAC_LEN) == 0) {
|
||||
// IP unused, ok to use this IP address
|
||||
memcpy(d->lease[yi].mac, dhcp_msg.chaddr, MAC_LEN);
|
||||
} else {
|
||||
// IP already in use
|
||||
// Should be NACK
|
||||
goto ignore_request;
|
||||
}
|
||||
d->lease[yi].expiry = (cyw43_hal_ticks_ms() + DEFAULT_LEASE_TIME_S * 1000) >> 16;
|
||||
dhcp_msg.yiaddr[3] = DHCPS_BASE_IP + yi;
|
||||
opt_write_u8(&opt, DHCP_OPT_MSG_TYPE, DHCPACK);
|
||||
printf("DHCPS: client connected: MAC=%02x:%02x:%02x:%02x:%02x:%02x IP=%u.%u.%u.%u\n",
|
||||
dhcp_msg.chaddr[0], dhcp_msg.chaddr[1], dhcp_msg.chaddr[2], dhcp_msg.chaddr[3], dhcp_msg.chaddr[4], dhcp_msg.chaddr[5],
|
||||
dhcp_msg.yiaddr[0], dhcp_msg.yiaddr[1], dhcp_msg.yiaddr[2], dhcp_msg.yiaddr[3]);
|
||||
break;
|
||||
}
|
||||
|
||||
default:
|
||||
goto ignore_request;
|
||||
}
|
||||
|
||||
opt_write_n(&opt, DHCP_OPT_SERVER_ID, 4, &ip4_addr_get_u32(ip_2_ip4(&d->ip)));
|
||||
opt_write_n(&opt, DHCP_OPT_SUBNET_MASK, 4, &ip4_addr_get_u32(ip_2_ip4(&d->nm)));
|
||||
opt_write_n(&opt, DHCP_OPT_ROUTER, 4, &ip4_addr_get_u32(ip_2_ip4(&d->ip))); // aka gateway; can have multiple addresses
|
||||
opt_write_n(&opt, DHCP_OPT_DNS, 4, &ip4_addr_get_u32(ip_2_ip4(&d->ip))); // this server is the dns
|
||||
opt_write_u32(&opt, DHCP_OPT_IP_LEASE_TIME, DEFAULT_LEASE_TIME_S);
|
||||
*opt++ = DHCP_OPT_END;
|
||||
struct netif *nif = ip_current_input_netif();
|
||||
dhcp_socket_sendto(&d->udp, nif, &dhcp_msg, opt - (uint8_t *)&dhcp_msg, 0xffffffff, PORT_DHCP_CLIENT);
|
||||
|
||||
ignore_request:
|
||||
pbuf_free(p);
|
||||
}
|
||||
|
||||
void dhcp_server_init(dhcp_server_t *d, ip_addr_t *ip, ip_addr_t *nm) {
|
||||
ip_addr_copy(d->ip, *ip);
|
||||
ip_addr_copy(d->nm, *nm);
|
||||
memset(d->lease, 0, sizeof(d->lease));
|
||||
if (dhcp_socket_new_dgram(&d->udp, d, dhcp_server_process) != 0) {
|
||||
return;
|
||||
}
|
||||
dhcp_socket_bind(&d->udp, PORT_DHCP_SERVER);
|
||||
}
|
||||
|
||||
void dhcp_server_deinit(dhcp_server_t *d) {
|
||||
dhcp_socket_free(&d->udp);
|
||||
}
|
||||
@@ -0,0 +1,49 @@
|
||||
/*
|
||||
* This file is part of the MicroPython project, http://micropython.org/
|
||||
*
|
||||
* The MIT License (MIT)
|
||||
*
|
||||
* Copyright (c) 2018-2019 Damien P. George
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
* in the Software without restriction, including without limitation the rights
|
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
* copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
* THE SOFTWARE.
|
||||
*/
|
||||
#ifndef MICROPY_INCLUDED_LIB_NETUTILS_DHCPSERVER_H
|
||||
#define MICROPY_INCLUDED_LIB_NETUTILS_DHCPSERVER_H
|
||||
|
||||
#include "lwip/ip_addr.h"
|
||||
|
||||
#define DHCPS_BASE_IP (16)
|
||||
#define DHCPS_MAX_IP (8)
|
||||
|
||||
typedef struct _dhcp_server_lease_t {
|
||||
uint8_t mac[6];
|
||||
uint16_t expiry;
|
||||
} dhcp_server_lease_t;
|
||||
|
||||
typedef struct _dhcp_server_t {
|
||||
ip_addr_t ip;
|
||||
ip_addr_t nm;
|
||||
dhcp_server_lease_t lease[DHCPS_MAX_IP];
|
||||
struct udp_pcb *udp;
|
||||
} dhcp_server_t;
|
||||
|
||||
void dhcp_server_init(dhcp_server_t *d, ip_addr_t *ip, ip_addr_t *nm);
|
||||
void dhcp_server_deinit(dhcp_server_t *d);
|
||||
|
||||
#endif // MICROPY_INCLUDED_LIB_NETUTILS_DHCPSERVER_H
|
||||
@@ -0,0 +1,815 @@
|
||||
#include <ctype.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "pico/cyw43_arch.h"
|
||||
#include "lwip/pbuf.h"
|
||||
#include "lwip/tcp.h"
|
||||
|
||||
#include "httpserver.h"
|
||||
|
||||
#define HS_POLL_INTERVAL 20
|
||||
#define HS_MAX_CONNS 4
|
||||
#define HS_MAX_ROUTES 16
|
||||
#define HS_MAX_WS_ROUTES 4
|
||||
#define HS_REQ_BUF 8192
|
||||
#define HS_HDR_BUF 512
|
||||
#define HS_WS_PAYLOAD_MAX 2048
|
||||
#define HS_SEND_CHUNK 1400
|
||||
#define HS_WS_GUID "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
|
||||
|
||||
typedef enum {
|
||||
CONN_FREE = 0,
|
||||
CONN_HTTP,
|
||||
CONN_WS,
|
||||
} conn_mode_t;
|
||||
|
||||
typedef struct {
|
||||
const char *method;
|
||||
const char *path;
|
||||
httpserver_handler_t fn;
|
||||
} route_t;
|
||||
|
||||
typedef struct {
|
||||
const char *path;
|
||||
httpserver_ws_open_t on_open;
|
||||
httpserver_ws_msg_t on_msg;
|
||||
httpserver_ws_close_t on_close;
|
||||
} ws_route_t;
|
||||
|
||||
struct httpserver_conn {
|
||||
conn_mode_t mode;
|
||||
httpserver_t *server;
|
||||
struct tcp_pcb *pcb;
|
||||
const ws_route_t *ws_route;
|
||||
char buf[HS_REQ_BUF];
|
||||
int buf_len;
|
||||
int header_end; /* index of first body byte, or -1 */
|
||||
int content_length;
|
||||
bool headers_complete;
|
||||
bool dispatched;
|
||||
|
||||
/* streaming static response */
|
||||
const uint8_t *static_body;
|
||||
size_t static_len;
|
||||
size_t static_sent; /* bytes queued via tcp_write */
|
||||
size_t tx_acked; /* bytes ACKed (from tcp_sent) */
|
||||
size_t tx_total; /* hdr_len + static_len */
|
||||
bool write_done;
|
||||
char hdr[HS_HDR_BUF];
|
||||
int hdr_len;
|
||||
int hdr_sent;
|
||||
};
|
||||
|
||||
struct httpserver {
|
||||
struct tcp_pcb *server_pcb;
|
||||
route_t routes[HS_MAX_ROUTES];
|
||||
int route_count;
|
||||
ws_route_t ws_routes[HS_MAX_WS_ROUTES];
|
||||
int ws_route_count;
|
||||
httpserver_conn_t conns[HS_MAX_CONNS];
|
||||
};
|
||||
|
||||
static httpserver_t g_server;
|
||||
|
||||
/* ---- SHA-1 ---- */
|
||||
|
||||
typedef struct {
|
||||
uint32_t state[5];
|
||||
uint32_t count[2];
|
||||
uint8_t buffer[64];
|
||||
} sha1_ctx_t;
|
||||
|
||||
static uint32_t sha1_rol(uint32_t v, uint32_t bits) {
|
||||
return (v << bits) | (v >> (32 - bits));
|
||||
}
|
||||
|
||||
static void sha1_transform(uint32_t state[5], const uint8_t *block) {
|
||||
uint32_t w[80];
|
||||
for (int i = 0; i < 16; i++) {
|
||||
w[i] = ((uint32_t)block[i * 4] << 24) | ((uint32_t)block[i * 4 + 1] << 16) |
|
||||
((uint32_t)block[i * 4 + 2] << 8) | ((uint32_t)block[i * 4 + 3]);
|
||||
}
|
||||
for (int i = 16; i < 80; i++) {
|
||||
w[i] = sha1_rol(w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16], 1);
|
||||
}
|
||||
uint32_t a = state[0], b = state[1], c = state[2], d = state[3], e = state[4];
|
||||
for (int i = 0; i < 80; i++) {
|
||||
uint32_t f, k;
|
||||
if (i < 20) {
|
||||
f = (b & c) | ((~b) & d);
|
||||
k = 0x5A827999;
|
||||
} else if (i < 40) {
|
||||
f = b ^ c ^ d;
|
||||
k = 0x6ED9EBA1;
|
||||
} else if (i < 60) {
|
||||
f = (b & c) | (b & d) | (c & d);
|
||||
k = 0x8F1BBCDC;
|
||||
} else {
|
||||
f = b ^ c ^ d;
|
||||
k = 0xCA62C1D6;
|
||||
}
|
||||
uint32_t t = sha1_rol(a, 5) + f + e + k + w[i];
|
||||
e = d;
|
||||
d = c;
|
||||
c = sha1_rol(b, 30);
|
||||
b = a;
|
||||
a = t;
|
||||
}
|
||||
state[0] += a;
|
||||
state[1] += b;
|
||||
state[2] += c;
|
||||
state[3] += d;
|
||||
state[4] += e;
|
||||
}
|
||||
|
||||
static void sha1_init(sha1_ctx_t *ctx) {
|
||||
ctx->state[0] = 0x67452301;
|
||||
ctx->state[1] = 0xEFCDAB89;
|
||||
ctx->state[2] = 0x98BADCFE;
|
||||
ctx->state[3] = 0x10325476;
|
||||
ctx->state[4] = 0xC3D2E1F0;
|
||||
ctx->count[0] = ctx->count[1] = 0;
|
||||
}
|
||||
|
||||
static void sha1_update(sha1_ctx_t *ctx, const uint8_t *data, size_t len) {
|
||||
size_t i;
|
||||
size_t idx = (ctx->count[0] >> 3) & 63;
|
||||
ctx->count[0] += (uint32_t)(len << 3);
|
||||
if (ctx->count[0] < (len << 3)) {
|
||||
ctx->count[1]++;
|
||||
}
|
||||
ctx->count[1] += (uint32_t)(len >> 29);
|
||||
size_t part = 64 - idx;
|
||||
if (len >= part) {
|
||||
memcpy(&ctx->buffer[idx], data, part);
|
||||
sha1_transform(ctx->state, ctx->buffer);
|
||||
for (i = part; i + 63 < len; i += 64) {
|
||||
sha1_transform(ctx->state, &data[i]);
|
||||
}
|
||||
idx = 0;
|
||||
} else {
|
||||
i = 0;
|
||||
}
|
||||
memcpy(&ctx->buffer[idx], &data[i], len - i);
|
||||
}
|
||||
|
||||
static void sha1_final(sha1_ctx_t *ctx, uint8_t digest[20]) {
|
||||
uint8_t finalcount[8];
|
||||
for (int i = 0; i < 8; i++) {
|
||||
finalcount[i] = (uint8_t)((ctx->count[(i >= 4) ? 0 : 1] >> ((3 - (i & 3)) * 8)) & 255);
|
||||
}
|
||||
uint8_t c = 0x80;
|
||||
sha1_update(ctx, &c, 1);
|
||||
while ((ctx->count[0] & 504) != 448) {
|
||||
c = 0x00;
|
||||
sha1_update(ctx, &c, 1);
|
||||
}
|
||||
sha1_update(ctx, finalcount, 8);
|
||||
for (int i = 0; i < 20; i++) {
|
||||
digest[i] = (uint8_t)((ctx->state[i >> 2] >> ((3 - (i & 3)) * 8)) & 255);
|
||||
}
|
||||
}
|
||||
|
||||
static void base64_encode_20(const uint8_t in[20], char out[29]) {
|
||||
static const char tbl[] =
|
||||
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
||||
int o = 0;
|
||||
for (int i = 0; i < 18; i += 3) {
|
||||
uint32_t v = ((uint32_t)in[i] << 16) | ((uint32_t)in[i + 1] << 8) | in[i + 2];
|
||||
out[o++] = tbl[(v >> 18) & 63];
|
||||
out[o++] = tbl[(v >> 12) & 63];
|
||||
out[o++] = tbl[(v >> 6) & 63];
|
||||
out[o++] = tbl[v & 63];
|
||||
}
|
||||
uint32_t v = ((uint32_t)in[18] << 16) | ((uint32_t)in[19] << 8);
|
||||
out[o++] = tbl[(v >> 18) & 63];
|
||||
out[o++] = tbl[(v >> 12) & 63];
|
||||
out[o++] = tbl[(v >> 6) & 63];
|
||||
out[o++] = '=';
|
||||
out[o] = '\0';
|
||||
}
|
||||
|
||||
static void ws_accept_key(const char *client_key, char out[29]) {
|
||||
char material[80];
|
||||
snprintf(material, sizeof(material), "%s%s", client_key, HS_WS_GUID);
|
||||
sha1_ctx_t ctx;
|
||||
uint8_t digest[20];
|
||||
sha1_init(&ctx);
|
||||
sha1_update(&ctx, (const uint8_t *)material, strlen(material));
|
||||
sha1_final(&ctx, digest);
|
||||
base64_encode_20(digest, out);
|
||||
}
|
||||
|
||||
static httpserver_conn_t *conn_alloc(httpserver_t *s, struct tcp_pcb *pcb) {
|
||||
for (int i = 0; i < HS_MAX_CONNS; i++) {
|
||||
if (s->conns[i].mode == CONN_FREE) {
|
||||
memset(&s->conns[i], 0, sizeof(s->conns[i]));
|
||||
s->conns[i].mode = CONN_HTTP;
|
||||
s->conns[i].server = s;
|
||||
s->conns[i].pcb = pcb;
|
||||
s->conns[i].header_end = -1;
|
||||
s->conns[i].content_length = -1;
|
||||
return &s->conns[i];
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static void conn_free(httpserver_conn_t *conn) {
|
||||
if (conn) {
|
||||
memset(conn, 0, sizeof(*conn));
|
||||
}
|
||||
}
|
||||
|
||||
static err_t close_conn(httpserver_conn_t *conn, struct tcp_pcb *pcb, err_t err) {
|
||||
if (conn && conn->mode == CONN_WS && conn->ws_route && conn->ws_route->on_close) {
|
||||
conn->ws_route->on_close(conn);
|
||||
}
|
||||
if (!pcb) {
|
||||
conn_free(conn);
|
||||
return err;
|
||||
}
|
||||
tcp_arg(pcb, NULL);
|
||||
tcp_poll(pcb, NULL, 0);
|
||||
tcp_sent(pcb, NULL);
|
||||
tcp_recv(pcb, NULL);
|
||||
tcp_err(pcb, NULL);
|
||||
if (tcp_close(pcb) != ERR_OK) {
|
||||
tcp_abort(pcb);
|
||||
err = ERR_ABRT;
|
||||
}
|
||||
conn_free(conn);
|
||||
return err;
|
||||
}
|
||||
|
||||
static bool header_has(const char *req, const char *name) {
|
||||
const char *p = req;
|
||||
size_t nlen = strlen(name);
|
||||
while (*p) {
|
||||
const char *eol = strstr(p, "\r\n");
|
||||
if (!eol) {
|
||||
break;
|
||||
}
|
||||
if ((size_t)(eol - p) >= nlen) {
|
||||
bool match = true;
|
||||
for (size_t i = 0; i < nlen; i++) {
|
||||
if (tolower((unsigned char)p[i]) != tolower((unsigned char)name[i])) {
|
||||
match = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (match) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
p = eol + 2;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
static bool header_value(const char *req, const char *name, char *out, size_t out_len) {
|
||||
const char *p = req;
|
||||
size_t nlen = strlen(name);
|
||||
while (*p) {
|
||||
const char *eol = strstr(p, "\r\n");
|
||||
if (!eol) {
|
||||
break;
|
||||
}
|
||||
if ((size_t)(eol - p) > nlen + 1) {
|
||||
bool match = true;
|
||||
for (size_t i = 0; i < nlen; i++) {
|
||||
if (tolower((unsigned char)p[i]) != tolower((unsigned char)name[i])) {
|
||||
match = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (match && p[nlen] == ':') {
|
||||
const char *v = p + nlen + 1;
|
||||
while (v < eol && (*v == ' ' || *v == '\t')) {
|
||||
v++;
|
||||
}
|
||||
size_t len = (size_t)(eol - v);
|
||||
if (len >= out_len) {
|
||||
len = out_len - 1;
|
||||
}
|
||||
memcpy(out, v, len);
|
||||
out[len] = '\0';
|
||||
return true;
|
||||
}
|
||||
}
|
||||
p = eol + 2;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
static const char *status_text(int status) {
|
||||
switch (status) {
|
||||
case 200: return "OK";
|
||||
case 404: return "Not Found";
|
||||
case 405: return "Method Not Allowed";
|
||||
case 500: return "Internal Server Error";
|
||||
default: return "OK";
|
||||
}
|
||||
}
|
||||
|
||||
static const ws_route_t *find_ws_route(httpserver_t *s, const char *path) {
|
||||
for (int i = 0; i < s->ws_route_count; i++) {
|
||||
if (strcmp(s->ws_routes[i].path, path) == 0) {
|
||||
return &s->ws_routes[i];
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static const route_t *find_route(httpserver_t *s, const char *method, const char *path) {
|
||||
for (int i = 0; i < s->route_count; i++) {
|
||||
if (strcmp(s->routes[i].method, method) == 0 && strcmp(s->routes[i].path, path) == 0) {
|
||||
return &s->routes[i];
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static bool parse_request_line(const char *req, char *method, size_t method_len,
|
||||
char *path, size_t path_len, char *query, size_t query_len) {
|
||||
method[0] = path[0] = query[0] = '\0';
|
||||
const char *eol = strstr(req, "\r\n");
|
||||
if (!eol) {
|
||||
return false;
|
||||
}
|
||||
char line[160];
|
||||
size_t line_len = (size_t)(eol - req);
|
||||
if (line_len >= sizeof(line)) {
|
||||
line_len = sizeof(line) - 1;
|
||||
}
|
||||
memcpy(line, req, line_len);
|
||||
line[line_len] = '\0';
|
||||
char *sp1 = strchr(line, ' ');
|
||||
if (!sp1) {
|
||||
return false;
|
||||
}
|
||||
*sp1 = '\0';
|
||||
snprintf(method, method_len, "%s", line);
|
||||
char *uri = sp1 + 1;
|
||||
char *sp2 = strchr(uri, ' ');
|
||||
if (sp2) {
|
||||
*sp2 = '\0';
|
||||
}
|
||||
char *q = strchr(uri, '?');
|
||||
if (q) {
|
||||
*q = '\0';
|
||||
snprintf(query, query_len, "%s", q + 1);
|
||||
}
|
||||
snprintf(path, path_len, "%s", uri);
|
||||
return true;
|
||||
}
|
||||
|
||||
static err_t pump_static(httpserver_conn_t *conn) {
|
||||
if (!conn->pcb || !conn->static_body) {
|
||||
return ERR_OK;
|
||||
}
|
||||
|
||||
while (conn->hdr_sent < conn->hdr_len) {
|
||||
size_t left = (size_t)(conn->hdr_len - conn->hdr_sent);
|
||||
u16_t space = tcp_sndbuf(conn->pcb);
|
||||
if (space == 0) {
|
||||
tcp_output(conn->pcb);
|
||||
return ERR_OK;
|
||||
}
|
||||
u16_t n = left < space ? (u16_t)left : space;
|
||||
if (n > HS_SEND_CHUNK) {
|
||||
n = HS_SEND_CHUNK;
|
||||
}
|
||||
err_t err = tcp_write(conn->pcb, conn->hdr + conn->hdr_sent, n, TCP_WRITE_FLAG_COPY);
|
||||
if (err == ERR_MEM) {
|
||||
tcp_output(conn->pcb);
|
||||
return ERR_OK;
|
||||
}
|
||||
if (err != ERR_OK) {
|
||||
return close_conn(conn, conn->pcb, ERR_ABRT);
|
||||
}
|
||||
conn->hdr_sent += n;
|
||||
}
|
||||
|
||||
while (conn->static_sent < conn->static_len) {
|
||||
size_t left = conn->static_len - conn->static_sent;
|
||||
u16_t space = tcp_sndbuf(conn->pcb);
|
||||
if (space == 0) {
|
||||
tcp_output(conn->pcb);
|
||||
return ERR_OK;
|
||||
}
|
||||
u16_t n = left < space ? (u16_t)left : space;
|
||||
if (n > HS_SEND_CHUNK) {
|
||||
n = HS_SEND_CHUNK;
|
||||
}
|
||||
err_t err = tcp_write(conn->pcb, conn->static_body + conn->static_sent, n, TCP_WRITE_FLAG_COPY);
|
||||
if (err == ERR_MEM) {
|
||||
tcp_output(conn->pcb);
|
||||
return ERR_OK;
|
||||
}
|
||||
if (err != ERR_OK) {
|
||||
return close_conn(conn, conn->pcb, ERR_ABRT);
|
||||
}
|
||||
conn->static_sent += n;
|
||||
}
|
||||
|
||||
tcp_output(conn->pcb);
|
||||
conn->write_done = true;
|
||||
|
||||
/* Only close after peer has ACKed every queued byte — closing earlier
|
||||
* truncates the response and triggers ERR_CONTENT_LENGTH_MISMATCH. */
|
||||
if (conn->tx_acked >= conn->tx_total) {
|
||||
return close_conn(conn, conn->pcb, ERR_OK);
|
||||
}
|
||||
return ERR_OK;
|
||||
}
|
||||
|
||||
static err_t ws_send_frame(httpserver_conn_t *conn, uint8_t opcode, const void *payload, size_t len) {
|
||||
if (!conn || conn->mode != CONN_WS || !conn->pcb) {
|
||||
return ERR_VAL;
|
||||
}
|
||||
if (len > HS_WS_PAYLOAD_MAX) {
|
||||
return ERR_VAL;
|
||||
}
|
||||
uint8_t frame[4 + HS_WS_PAYLOAD_MAX];
|
||||
size_t hdr = 2;
|
||||
frame[0] = 0x80 | (opcode & 0x0f);
|
||||
if (len < 126) {
|
||||
frame[1] = (uint8_t)len;
|
||||
} else {
|
||||
frame[1] = 126;
|
||||
frame[2] = (uint8_t)((len >> 8) & 0xff);
|
||||
frame[3] = (uint8_t)(len & 0xff);
|
||||
hdr = 4;
|
||||
}
|
||||
if (len) {
|
||||
memcpy(frame + hdr, payload, len);
|
||||
}
|
||||
if (tcp_write(conn->pcb, frame, (u16_t)(hdr + len), TCP_WRITE_FLAG_COPY) != ERR_OK) {
|
||||
return ERR_MEM;
|
||||
}
|
||||
tcp_output(conn->pcb);
|
||||
return ERR_OK;
|
||||
}
|
||||
|
||||
static err_t ws_upgrade(httpserver_conn_t *conn, const char *req, const char *path) {
|
||||
const ws_route_t *ws = find_ws_route(conn->server, path);
|
||||
if (!ws) {
|
||||
httpserver_send(conn, 404, "text/plain", "Not Found", 9);
|
||||
return ERR_OK;
|
||||
}
|
||||
char key[64];
|
||||
char accept[29];
|
||||
if (!header_value(req, "Sec-WebSocket-Key", key, sizeof(key))) {
|
||||
return close_conn(conn, conn->pcb, ERR_VAL);
|
||||
}
|
||||
ws_accept_key(key, accept);
|
||||
char resp[180];
|
||||
int n = snprintf(resp, sizeof(resp),
|
||||
"HTTP/1.1 101 Switching Protocols\r\n"
|
||||
"Upgrade: websocket\r\n"
|
||||
"Connection: Upgrade\r\n"
|
||||
"Sec-WebSocket-Accept: %s\r\n"
|
||||
"\r\n",
|
||||
accept);
|
||||
if (tcp_write(conn->pcb, resp, n, TCP_WRITE_FLAG_COPY) != ERR_OK) {
|
||||
return close_conn(conn, conn->pcb, ERR_ABRT);
|
||||
}
|
||||
tcp_output(conn->pcb);
|
||||
conn->mode = CONN_WS;
|
||||
conn->ws_route = ws;
|
||||
conn->buf_len = 0;
|
||||
conn->headers_complete = false;
|
||||
if (ws->on_open) {
|
||||
ws->on_open(conn);
|
||||
}
|
||||
return ERR_OK;
|
||||
}
|
||||
|
||||
static err_t ws_handle_frames(httpserver_conn_t *conn) {
|
||||
while (conn->buf_len >= 2) {
|
||||
uint8_t b0 = (uint8_t)conn->buf[0];
|
||||
uint8_t b1 = (uint8_t)conn->buf[1];
|
||||
uint8_t opcode = b0 & 0x0f;
|
||||
bool masked = (b1 & 0x80) != 0;
|
||||
size_t payload_len = b1 & 0x7f;
|
||||
size_t header_len = 2;
|
||||
if (payload_len == 126) {
|
||||
if (conn->buf_len < 4) {
|
||||
break;
|
||||
}
|
||||
payload_len = ((size_t)(uint8_t)conn->buf[2] << 8) | (uint8_t)conn->buf[3];
|
||||
header_len = 4;
|
||||
} else if (payload_len == 127) {
|
||||
return close_conn(conn, conn->pcb, ERR_VAL);
|
||||
}
|
||||
if (masked) {
|
||||
header_len += 4;
|
||||
}
|
||||
if ((size_t)conn->buf_len < header_len + payload_len) {
|
||||
break;
|
||||
}
|
||||
if (payload_len > HS_WS_PAYLOAD_MAX) {
|
||||
return close_conn(conn, conn->pcb, ERR_VAL);
|
||||
}
|
||||
const uint8_t *mask = masked ? (const uint8_t *)&conn->buf[header_len - 4] : NULL;
|
||||
uint8_t payload[HS_WS_PAYLOAD_MAX + 1];
|
||||
memcpy(payload, &conn->buf[header_len], payload_len);
|
||||
if (masked) {
|
||||
for (size_t i = 0; i < payload_len; i++) {
|
||||
payload[i] ^= mask[i & 3];
|
||||
}
|
||||
}
|
||||
payload[payload_len] = '\0';
|
||||
size_t consumed = header_len + payload_len;
|
||||
memmove(conn->buf, conn->buf + consumed, conn->buf_len - consumed);
|
||||
conn->buf_len -= (int)consumed;
|
||||
if (opcode == 0x8) {
|
||||
ws_send_frame(conn, 0x8, NULL, 0);
|
||||
return close_conn(conn, conn->pcb, ERR_OK);
|
||||
}
|
||||
if (opcode == 0x9) {
|
||||
ws_send_frame(conn, 0xA, payload, payload_len);
|
||||
continue;
|
||||
}
|
||||
if (opcode == 0x1 || opcode == 0x2) {
|
||||
if (conn->ws_route && conn->ws_route->on_msg) {
|
||||
conn->ws_route->on_msg(conn, payload, payload_len, opcode == 0x1);
|
||||
}
|
||||
}
|
||||
}
|
||||
return ERR_OK;
|
||||
}
|
||||
|
||||
static err_t dispatch_http(httpserver_conn_t *conn) {
|
||||
char method[8];
|
||||
char path[64];
|
||||
char query[64];
|
||||
if (!parse_request_line(conn->buf, method, sizeof(method), path, sizeof(path), query, sizeof(query))) {
|
||||
return close_conn(conn, conn->pcb, ERR_VAL);
|
||||
}
|
||||
bool is_ws = header_has(conn->buf, "Upgrade:") && header_has(conn->buf, "Sec-WebSocket-Key:");
|
||||
if (is_ws && strcmp(method, "GET") == 0) {
|
||||
return ws_upgrade(conn, conn->buf, path);
|
||||
}
|
||||
const route_t *route = find_route(conn->server, method, path);
|
||||
if (!route) {
|
||||
httpserver_send(conn, 404, "text/plain", "Not Found", 9);
|
||||
return ERR_OK;
|
||||
}
|
||||
conn->dispatched = true;
|
||||
route->fn(conn, path, query);
|
||||
return ERR_OK;
|
||||
}
|
||||
|
||||
static err_t try_dispatch(httpserver_conn_t *conn) {
|
||||
if (conn->dispatched) {
|
||||
return ERR_OK;
|
||||
}
|
||||
if (!conn->headers_complete) {
|
||||
char *end = strstr(conn->buf, "\r\n\r\n");
|
||||
if (!end) {
|
||||
return ERR_OK;
|
||||
}
|
||||
conn->header_end = (int)(end - conn->buf) + 4;
|
||||
conn->headers_complete = true;
|
||||
char cl[16];
|
||||
if (header_value(conn->buf, "Content-Length", cl, sizeof(cl))) {
|
||||
conn->content_length = atoi(cl);
|
||||
} else {
|
||||
conn->content_length = 0;
|
||||
}
|
||||
}
|
||||
int body_have = conn->buf_len - conn->header_end;
|
||||
if (conn->content_length > 0 && body_have < conn->content_length) {
|
||||
return ERR_OK;
|
||||
}
|
||||
return dispatch_http(conn);
|
||||
}
|
||||
|
||||
static err_t on_sent(void *arg, struct tcp_pcb *pcb, u16_t len) {
|
||||
httpserver_conn_t *conn = arg;
|
||||
(void)pcb;
|
||||
if (conn->mode != CONN_HTTP) {
|
||||
return ERR_OK;
|
||||
}
|
||||
conn->tx_acked += len;
|
||||
if (conn->static_body) {
|
||||
return pump_static(conn);
|
||||
}
|
||||
return ERR_OK;
|
||||
}
|
||||
|
||||
static err_t on_recv(void *arg, struct tcp_pcb *pcb, struct pbuf *p, err_t err) {
|
||||
httpserver_conn_t *conn = arg;
|
||||
(void)err;
|
||||
if (!p) {
|
||||
return close_conn(conn, pcb, ERR_OK);
|
||||
}
|
||||
if (p->tot_len > 0) {
|
||||
u16_t space = (u16_t)(sizeof(conn->buf) - 1 - conn->buf_len);
|
||||
u16_t n = p->tot_len > space ? space : p->tot_len;
|
||||
pbuf_copy_partial(p, conn->buf + conn->buf_len, n, 0);
|
||||
conn->buf_len += n;
|
||||
conn->buf[conn->buf_len] = '\0';
|
||||
tcp_recved(pcb, p->tot_len);
|
||||
err_t r = ERR_OK;
|
||||
if (conn->mode == CONN_WS) {
|
||||
r = ws_handle_frames(conn);
|
||||
} else {
|
||||
r = try_dispatch(conn);
|
||||
}
|
||||
pbuf_free(p);
|
||||
return r;
|
||||
}
|
||||
pbuf_free(p);
|
||||
return ERR_OK;
|
||||
}
|
||||
|
||||
static err_t on_poll(void *arg, struct tcp_pcb *pcb) {
|
||||
httpserver_conn_t *conn = arg;
|
||||
if (conn->mode == CONN_WS) {
|
||||
return ERR_OK;
|
||||
}
|
||||
/* Keep pumping / waiting for ACK on static responses */
|
||||
if (conn->static_body) {
|
||||
return pump_static(conn);
|
||||
}
|
||||
if (conn->dispatched) {
|
||||
return close_conn(conn, pcb, ERR_OK);
|
||||
}
|
||||
return close_conn(conn, pcb, ERR_OK);
|
||||
}
|
||||
|
||||
static void on_err(void *arg, err_t err) {
|
||||
httpserver_conn_t *conn = arg;
|
||||
(void)err;
|
||||
if (conn && conn->mode == CONN_WS && conn->ws_route && conn->ws_route->on_close) {
|
||||
conn->ws_route->on_close(conn);
|
||||
}
|
||||
conn_free(conn);
|
||||
}
|
||||
|
||||
static err_t on_accept(void *arg, struct tcp_pcb *client_pcb, err_t err) {
|
||||
httpserver_t *s = arg;
|
||||
if (err != ERR_OK || !client_pcb) {
|
||||
return ERR_VAL;
|
||||
}
|
||||
httpserver_conn_t *conn = conn_alloc(s, client_pcb);
|
||||
if (!conn) {
|
||||
tcp_abort(client_pcb);
|
||||
return ERR_MEM;
|
||||
}
|
||||
tcp_arg(client_pcb, conn);
|
||||
tcp_sent(client_pcb, on_sent);
|
||||
tcp_recv(client_pcb, on_recv);
|
||||
tcp_poll(client_pcb, on_poll, HS_POLL_INTERVAL);
|
||||
tcp_err(client_pcb, on_err);
|
||||
tcp_nagle_disable(client_pcb);
|
||||
return ERR_OK;
|
||||
}
|
||||
|
||||
httpserver_t *httpserver_create(void) {
|
||||
memset(&g_server, 0, sizeof(g_server));
|
||||
return &g_server;
|
||||
}
|
||||
|
||||
void httpserver_route(httpserver_t *s, const char *method, const char *path, httpserver_handler_t fn) {
|
||||
if (!s || s->route_count >= HS_MAX_ROUTES || !method || !path || !fn) {
|
||||
return;
|
||||
}
|
||||
s->routes[s->route_count].method = method;
|
||||
s->routes[s->route_count].path = path;
|
||||
s->routes[s->route_count].fn = fn;
|
||||
s->route_count++;
|
||||
}
|
||||
|
||||
void httpserver_websocket(httpserver_t *s, const char *path,
|
||||
httpserver_ws_open_t on_open,
|
||||
httpserver_ws_msg_t on_msg,
|
||||
httpserver_ws_close_t on_close) {
|
||||
if (!s || s->ws_route_count >= HS_MAX_WS_ROUTES || !path) {
|
||||
return;
|
||||
}
|
||||
s->ws_routes[s->ws_route_count].path = path;
|
||||
s->ws_routes[s->ws_route_count].on_open = on_open;
|
||||
s->ws_routes[s->ws_route_count].on_msg = on_msg;
|
||||
s->ws_routes[s->ws_route_count].on_close = on_close;
|
||||
s->ws_route_count++;
|
||||
}
|
||||
|
||||
bool httpserver_listen(httpserver_t *s, uint16_t port) {
|
||||
if (!s) {
|
||||
return false;
|
||||
}
|
||||
cyw43_arch_lwip_begin();
|
||||
struct tcp_pcb *pcb = tcp_new_ip_type(IPADDR_TYPE_ANY);
|
||||
if (!pcb) {
|
||||
cyw43_arch_lwip_end();
|
||||
return false;
|
||||
}
|
||||
if (tcp_bind(pcb, IP_ANY_TYPE, port) != ERR_OK) {
|
||||
tcp_close(pcb);
|
||||
cyw43_arch_lwip_end();
|
||||
return false;
|
||||
}
|
||||
s->server_pcb = tcp_listen_with_backlog(pcb, HS_MAX_CONNS);
|
||||
if (!s->server_pcb) {
|
||||
tcp_close(pcb);
|
||||
cyw43_arch_lwip_end();
|
||||
return false;
|
||||
}
|
||||
tcp_arg(s->server_pcb, s);
|
||||
tcp_accept(s->server_pcb, on_accept);
|
||||
cyw43_arch_lwip_end();
|
||||
printf("httpserver: listening on port %u\n", port);
|
||||
return true;
|
||||
}
|
||||
|
||||
void httpserver_send_static(httpserver_conn_t *conn, int status, const char *content_type,
|
||||
const uint8_t *body, size_t body_len,
|
||||
const char *content_encoding) {
|
||||
if (!conn || conn->mode != CONN_HTTP || !conn->pcb) {
|
||||
return;
|
||||
}
|
||||
if (!content_type) {
|
||||
content_type = "application/octet-stream";
|
||||
}
|
||||
if (content_encoding && content_encoding[0]) {
|
||||
conn->hdr_len = snprintf(conn->hdr, sizeof(conn->hdr),
|
||||
"HTTP/1.1 %d %s\r\n"
|
||||
"Content-Type: %s\r\n"
|
||||
"Content-Encoding: %s\r\n"
|
||||
"Content-Length: %u\r\n"
|
||||
"Connection: close\r\n"
|
||||
"\r\n",
|
||||
status, status_text(status), content_type, content_encoding,
|
||||
(unsigned)body_len);
|
||||
} else {
|
||||
conn->hdr_len = snprintf(conn->hdr, sizeof(conn->hdr),
|
||||
"HTTP/1.1 %d %s\r\n"
|
||||
"Content-Type: %s\r\n"
|
||||
"Content-Length: %u\r\n"
|
||||
"Connection: close\r\n"
|
||||
"\r\n",
|
||||
status, status_text(status), content_type, (unsigned)body_len);
|
||||
}
|
||||
conn->hdr_sent = 0;
|
||||
conn->static_body = body ? body : (const uint8_t *)"";
|
||||
conn->static_len = body_len;
|
||||
conn->static_sent = 0;
|
||||
conn->tx_acked = 0;
|
||||
conn->tx_total = (size_t)conn->hdr_len + body_len;
|
||||
conn->write_done = false;
|
||||
pump_static(conn);
|
||||
}
|
||||
|
||||
void httpserver_send(httpserver_conn_t *conn, int status, const char *content_type,
|
||||
const void *body, size_t body_len) {
|
||||
httpserver_send_static(conn, status, content_type, (const uint8_t *)body, body_len, NULL);
|
||||
}
|
||||
|
||||
void httpserver_send_html(httpserver_conn_t *conn, const char *html) {
|
||||
if (!html) {
|
||||
html = "";
|
||||
}
|
||||
httpserver_send(conn, 200, "text/html; charset=utf-8", html, strlen(html));
|
||||
}
|
||||
|
||||
const char *httpserver_request_body(httpserver_conn_t *conn, size_t *len_out) {
|
||||
if (!conn || conn->header_end < 0) {
|
||||
if (len_out) {
|
||||
*len_out = 0;
|
||||
}
|
||||
return "";
|
||||
}
|
||||
size_t len = (size_t)(conn->buf_len - conn->header_end);
|
||||
if (conn->content_length >= 0 && (size_t)conn->content_length < len) {
|
||||
len = (size_t)conn->content_length;
|
||||
}
|
||||
if (len_out) {
|
||||
*len_out = len;
|
||||
}
|
||||
return conn->buf + conn->header_end;
|
||||
}
|
||||
|
||||
bool httpserver_ws_send(httpserver_conn_t *ws, const void *data, size_t len, bool text) {
|
||||
return ws_send_frame(ws, text ? 0x1 : 0x2, data, len) == ERR_OK;
|
||||
}
|
||||
|
||||
void httpserver_ws_broadcast(httpserver_t *s, const void *data, size_t len, bool text) {
|
||||
if (!s) {
|
||||
return;
|
||||
}
|
||||
for (int i = 0; i < HS_MAX_CONNS; i++) {
|
||||
if (s->conns[i].mode == CONN_WS) {
|
||||
httpserver_ws_send(&s->conns[i], data, len, text);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
httpserver_t *httpserver_conn_server(httpserver_conn_t *conn) {
|
||||
return conn ? conn->server : NULL;
|
||||
}
|
||||
@@ -0,0 +1,55 @@
|
||||
#ifndef HTTPSERVER_H
|
||||
#define HTTPSERVER_H
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef struct httpserver httpserver_t;
|
||||
typedef struct httpserver_conn httpserver_conn_t;
|
||||
|
||||
typedef void (*httpserver_handler_t)(httpserver_conn_t *conn, const char *path, const char *query);
|
||||
typedef void (*httpserver_ws_open_t)(httpserver_conn_t *ws);
|
||||
typedef void (*httpserver_ws_msg_t)(httpserver_conn_t *ws, const uint8_t *data, size_t len, bool text);
|
||||
typedef void (*httpserver_ws_close_t)(httpserver_conn_t *ws);
|
||||
|
||||
httpserver_t *httpserver_create(void);
|
||||
|
||||
void httpserver_route(httpserver_t *s, const char *method, const char *path, httpserver_handler_t fn);
|
||||
|
||||
void httpserver_websocket(httpserver_t *s, const char *path,
|
||||
httpserver_ws_open_t on_open,
|
||||
httpserver_ws_msg_t on_msg,
|
||||
httpserver_ws_close_t on_close);
|
||||
|
||||
bool httpserver_listen(httpserver_t *s, uint16_t port);
|
||||
|
||||
void httpserver_send(httpserver_conn_t *conn, int status, const char *content_type,
|
||||
const void *body, size_t body_len);
|
||||
|
||||
/* Stream a large const body (no copy of entire file into conn buffer).
|
||||
* content_encoding may be NULL, or e.g. "gzip". */
|
||||
void httpserver_send_static(httpserver_conn_t *conn, int status, const char *content_type,
|
||||
const uint8_t *body, size_t body_len,
|
||||
const char *content_encoding);
|
||||
|
||||
void httpserver_send_html(httpserver_conn_t *conn, const char *html);
|
||||
|
||||
/* POST/PUT body after headers (points into connection buffer). */
|
||||
const char *httpserver_request_body(httpserver_conn_t *conn, size_t *len_out);
|
||||
|
||||
bool httpserver_ws_send(httpserver_conn_t *ws, const void *data, size_t len, bool text);
|
||||
|
||||
void httpserver_ws_broadcast(httpserver_t *s, const void *data, size_t len, bool text);
|
||||
|
||||
httpserver_t *httpserver_conn_server(httpserver_conn_t *conn);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,26 @@
|
||||
#pragma once
|
||||
|
||||
#include <array>
|
||||
#include <cstdint>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
struct RGB {
|
||||
uint8_t r = 0;
|
||||
uint8_t g = 0;
|
||||
uint8_t b = 0;
|
||||
};
|
||||
|
||||
class Preset {
|
||||
public:
|
||||
std::string p = "off";
|
||||
int d = 100;
|
||||
int b = 127;
|
||||
std::vector<RGB> c{{255, 255, 255}};
|
||||
bool a = true;
|
||||
int n1 = 0, n2 = 0, n3 = 0, n4 = 0;
|
||||
int n5 = 0, n6 = 0, n7 = 0, n8 = 0;
|
||||
|
||||
Preset() = default;
|
||||
explicit Preset(std::string pattern) : p(std::move(pattern)) {}
|
||||
};
|
||||
@@ -0,0 +1,97 @@
|
||||
#include "leds/presets.hpp"
|
||||
|
||||
#include <algorithm>
|
||||
#include "patterns/patterns.hpp"
|
||||
|
||||
namespace {
|
||||
struct StripConfig { uint pin, count, midpoint; };
|
||||
constexpr StripConfig kConfig[] = {
|
||||
{6, 291, 291 / 2}, {29, 290, 290 / 2 - 1}, {3, 283, 283 / 2},
|
||||
{28, 278, 278 / 2 - 1}, {2, 278, 275 / 2}, {0, 283, 278 / 2 - 1},
|
||||
{4, 290, 283 / 2}, {7, 291, 290 / 2 - 1},
|
||||
};
|
||||
}
|
||||
|
||||
Presets::Presets() {
|
||||
for (size_t i = 0; i < kStripCount; ++i) {
|
||||
strips[i] = std::make_unique<WS2812B>(kConfig[i].count, kConfig[i].pin, i);
|
||||
strip_midpoints[i] = kConfig[i].midpoint;
|
||||
scale_map[i].resize(kConfig[0].count);
|
||||
for (size_t led = 0; led < scale_map[i].size(); ++led)
|
||||
scale_map[i][led] = led * kConfig[i].count / kConfig[0].count;
|
||||
}
|
||||
}
|
||||
Presets::~Presets() = default;
|
||||
|
||||
std::unique_ptr<Pattern> Presets::make_pattern(const std::string& name) const {
|
||||
#define MAKE(name) if (name == #name) return std::make_unique<name>();
|
||||
if (name == "off" || name == "on") return nullptr;
|
||||
if (name == "blink") return std::make_unique<Blink>();
|
||||
if (name == "rainbow") return std::make_unique<Rainbow>();
|
||||
if (name == "pulse") return std::make_unique<Pulse>();
|
||||
if (name == "transition") return std::make_unique<Transition>();
|
||||
if (name == "chase") return std::make_unique<Chase>();
|
||||
if (name == "circle") return std::make_unique<Circle>();
|
||||
if (name == "roll") return std::make_unique<Roll>();
|
||||
if (name == "calibration") return std::make_unique<Calibration>();
|
||||
if (name == "test") return std::make_unique<Test>();
|
||||
if (name == "grab") return std::make_unique<Grab>();
|
||||
if (name == "spin") return std::make_unique<Spin>();
|
||||
if (name == "lift") return std::make_unique<Lift>();
|
||||
if (name == "flare") return std::make_unique<Flare>();
|
||||
if (name == "hook") return std::make_unique<Hook>();
|
||||
if (name == "pose") return std::make_unique<Pose>();
|
||||
if (name == "point") return std::make_unique<Point>();
|
||||
if (name == "scale_test") return std::make_unique<ScaleTest>();
|
||||
return nullptr;
|
||||
#undef MAKE
|
||||
}
|
||||
|
||||
bool Presets::select(const std::string& name, int next_step) {
|
||||
auto saved = presets.find(name);
|
||||
Preset* preset = saved == presets.end() ? nullptr : &saved->second;
|
||||
const std::string pattern = preset ? preset->p : name;
|
||||
if (pattern == "off") { off(); current.reset(); selected = name; step = 0; return true; }
|
||||
if (pattern == "on") {
|
||||
static Preset default_on("on");
|
||||
on(preset ? preset : &default_on); current.reset(); selected = name; return true;
|
||||
}
|
||||
current = make_pattern(pattern);
|
||||
if (!current) return false;
|
||||
static Preset built_in;
|
||||
if (!preset) { built_in = Preset(pattern); preset = &built_in; }
|
||||
if (next_step >= 0) step = next_step;
|
||||
else if (selected != name) step = 0;
|
||||
current->start(*this, preset);
|
||||
selected = name;
|
||||
return true;
|
||||
}
|
||||
bool Presets::edit(const std::string& name, const Preset& preset) { presets[name] = preset; return true; }
|
||||
bool Presets::remove(const std::string& name) { return presets.erase(name) != 0; }
|
||||
void Presets::tick() { if (current && !current->tick()) current.reset(); }
|
||||
void Presets::fill(RGB color) { for (auto& strip : strips) strip->fill(color); }
|
||||
void Presets::fill_n(RGB color, int first, int last) {
|
||||
first = std::max(0, first); last = std::min<int>(kConfig[0].count, last);
|
||||
for (int i = first; i < last; ++i) for (size_t s = 0; s < kStripCount; ++s) set(s, i, color);
|
||||
}
|
||||
bool Presets::set(size_t strip, int index, RGB color) {
|
||||
if (strip >= kStripCount || index < 0 || index >= static_cast<int>(scale_map[strip].size())) return false;
|
||||
strips[strip]->set(scale_map[strip][index], color); return true;
|
||||
}
|
||||
RGB Presets::apply_brightness(RGB color, int local) const {
|
||||
const int effective = std::clamp(local, 0, 255) * b / 255;
|
||||
return {static_cast<uint8_t>(color.r * effective / 255), static_cast<uint8_t>(color.g * effective / 255),
|
||||
static_cast<uint8_t>(color.b * effective / 255)};
|
||||
}
|
||||
void Presets::show_all() { for (auto& strip : strips) strip->show(); }
|
||||
void Presets::show_all_parallel() {
|
||||
uint32_t mask = 0;
|
||||
for (auto& strip : strips) { strip->prepare_show(); mask |= 1u << strip->dma_channel; }
|
||||
dma_start_channel_mask(mask);
|
||||
}
|
||||
void Presets::off() { fill({0, 0, 0}); show_all_parallel(); }
|
||||
void Presets::on(Preset* preset) {
|
||||
const RGB color = preset && !preset->c.empty() ? preset->c[0] : RGB{255, 255, 255};
|
||||
fill(apply_brightness(color, preset ? preset->b : 255)); show_all_parallel();
|
||||
}
|
||||
uint16_t Presets::strip_length(size_t strip) const { return strip < kStripCount ? strips[strip]->num_leds : 0; }
|
||||
@@ -0,0 +1,46 @@
|
||||
#pragma once
|
||||
|
||||
#include <array>
|
||||
#include <memory>
|
||||
#include <string>
|
||||
#include <unordered_map>
|
||||
#include <vector>
|
||||
|
||||
#include "leds/preset.hpp"
|
||||
#include "leds/ws2812.hpp"
|
||||
|
||||
class Pattern;
|
||||
|
||||
class Presets {
|
||||
public:
|
||||
static constexpr size_t kStripCount = 8;
|
||||
Presets();
|
||||
~Presets();
|
||||
|
||||
bool select(const std::string& name, int step = -1);
|
||||
bool edit(const std::string& name, const Preset& preset);
|
||||
bool remove(const std::string& name);
|
||||
void tick();
|
||||
void fill(RGB color);
|
||||
void fill_n(RGB color, int first, int last);
|
||||
bool set(size_t strip, int reference_index, RGB color);
|
||||
RGB apply_brightness(RGB color, int local = 255) const;
|
||||
void show_all();
|
||||
void show_all_parallel();
|
||||
void off();
|
||||
void on(Preset* preset);
|
||||
uint16_t strip_length(size_t strip) const;
|
||||
|
||||
std::array<std::unique_ptr<WS2812B>, kStripCount> strips;
|
||||
std::array<uint16_t, kStripCount> strip_midpoints{};
|
||||
std::array<std::vector<uint16_t>, kStripCount> scale_map;
|
||||
std::unordered_map<std::string, Preset> presets;
|
||||
std::unique_ptr<Pattern> current;
|
||||
std::string selected;
|
||||
int step = 0;
|
||||
int last_roll_head = 0;
|
||||
uint8_t b = 255;
|
||||
|
||||
private:
|
||||
std::unique_ptr<Pattern> make_pattern(const std::string& name) const;
|
||||
};
|
||||
@@ -0,0 +1,84 @@
|
||||
#include "leds/ws2812.hpp"
|
||||
|
||||
#include "hardware/clocks.h"
|
||||
#include "hardware/gpio.h"
|
||||
#include "leds/preset.hpp"
|
||||
|
||||
namespace {
|
||||
constexpr uint T1 = 2, T2 = 5, T3 = 3;
|
||||
const uint16_t ws2812_instructions[] = {
|
||||
static_cast<uint16_t>(pio_encode_out(pio_x, 1) | pio_encode_sideset(1, 0) | pio_encode_delay(T3 - 1)),
|
||||
static_cast<uint16_t>(pio_encode_jmp_not_x(3) | pio_encode_sideset(1, 1) | pio_encode_delay(T1 - 1)),
|
||||
static_cast<uint16_t>(pio_encode_jmp(0) | pio_encode_sideset(1, 1) | pio_encode_delay(T2 - 1)),
|
||||
static_cast<uint16_t>(pio_encode_nop() | pio_encode_sideset(1, 0) | pio_encode_delay(T2 - 1)),
|
||||
};
|
||||
const pio_program ws2812_program = {
|
||||
.instructions = ws2812_instructions, .length = 4, .origin = -1,
|
||||
};
|
||||
bool pio_program_added[2] = {};
|
||||
uint pio_offsets[2] = {};
|
||||
|
||||
uint program_offset(PIO pio) {
|
||||
const uint index = pio == pio0 ? 0 : 1;
|
||||
if (!pio_program_added[index]) {
|
||||
pio_offsets[index] = pio_add_program(pio, &ws2812_program);
|
||||
pio_program_added[index] = true;
|
||||
}
|
||||
return pio_offsets[index];
|
||||
}
|
||||
} // namespace
|
||||
|
||||
WS2812B::WS2812B(uint16_t count, uint pin, uint strip_index, float level)
|
||||
: num_leds(count), brightness(level), buffer(static_cast<size_t>(count) * 3),
|
||||
pio(strip_index < 4 ? pio0 : pio1), sm(strip_index % 4), pin_(pin) {
|
||||
const uint offset = program_offset(pio);
|
||||
pio_gpio_init(pio, pin_);
|
||||
pio_sm_set_consecutive_pindirs(pio, sm, pin_, 1, true);
|
||||
pio_sm_config config = pio_get_default_sm_config();
|
||||
sm_config_set_wrap(&config, offset, offset + 3);
|
||||
sm_config_set_sideset(&config, 1, false, false);
|
||||
sm_config_set_sideset_pins(&config, pin_);
|
||||
sm_config_set_out_shift(&config, false, true, 8);
|
||||
sm_config_set_fifo_join(&config, PIO_FIFO_JOIN_TX);
|
||||
sm_config_set_clkdiv(&config, static_cast<float>(clock_get_hz(clk_sys)) / 8000000.0f);
|
||||
pio_sm_init(pio, sm, offset, &config);
|
||||
pio_sm_set_enabled(pio, sm, true);
|
||||
|
||||
dma_channel = dma_claim_unused_channel(true);
|
||||
dma_channel_config dma_config = dma_channel_get_default_config(dma_channel);
|
||||
channel_config_set_transfer_data_size(&dma_config, DMA_SIZE_8);
|
||||
channel_config_set_dreq(&dma_config, pio_get_dreq(pio, sm, true));
|
||||
channel_config_set_read_increment(&dma_config, true);
|
||||
channel_config_set_write_increment(&dma_config, false);
|
||||
dma_channel_configure(dma_channel, &dma_config, &pio->txf[sm], nullptr,
|
||||
buffer.size(), false);
|
||||
}
|
||||
|
||||
WS2812B::~WS2812B() {
|
||||
if (dma_channel >= 0) dma_channel_unclaim(dma_channel);
|
||||
}
|
||||
|
||||
void WS2812B::set(uint16_t index, RGB color) {
|
||||
if (index >= num_leds) return;
|
||||
const size_t pos = static_cast<size_t>(index) * 3;
|
||||
buffer[pos] = static_cast<uint8_t>(color.g * brightness);
|
||||
buffer[pos + 1] = static_cast<uint8_t>(color.r * brightness);
|
||||
buffer[pos + 2] = static_cast<uint8_t>(color.b * brightness);
|
||||
}
|
||||
|
||||
void WS2812B::fill(RGB color) {
|
||||
for (uint16_t i = 0; i < num_leds; ++i) set(i, color);
|
||||
}
|
||||
|
||||
void WS2812B::prepare_show(const uint8_t* source, size_t offset) {
|
||||
if (!source) source = buffer.data();
|
||||
dma_channel_set_read_addr(dma_channel, source + offset, false);
|
||||
dma_channel_set_trans_count(dma_channel, buffer.size(), false);
|
||||
}
|
||||
|
||||
void WS2812B::trigger() { dma_channel_start(dma_channel); }
|
||||
void WS2812B::show(const uint8_t* source, size_t offset) {
|
||||
prepare_show(source, offset);
|
||||
trigger();
|
||||
}
|
||||
bool WS2812B::busy() const { return dma_channel_is_busy(dma_channel); }
|
||||
@@ -0,0 +1,34 @@
|
||||
#pragma once
|
||||
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
#include <vector>
|
||||
#include "hardware/dma.h"
|
||||
#include "hardware/pio.h"
|
||||
|
||||
struct RGB;
|
||||
|
||||
class WS2812B {
|
||||
public:
|
||||
WS2812B(uint16_t num_leds, uint pin, uint strip_index, float brightness = 1.0f);
|
||||
~WS2812B();
|
||||
WS2812B(const WS2812B&) = delete;
|
||||
WS2812B& operator=(const WS2812B&) = delete;
|
||||
|
||||
void fill(RGB color);
|
||||
void set(uint16_t index, RGB color);
|
||||
void show(const uint8_t* buffer = nullptr, size_t offset = 0);
|
||||
void prepare_show(const uint8_t* buffer = nullptr, size_t offset = 0);
|
||||
void trigger();
|
||||
bool busy() const;
|
||||
|
||||
uint16_t num_leds;
|
||||
float brightness;
|
||||
std::vector<uint8_t> buffer;
|
||||
int dma_channel = -1;
|
||||
PIO pio = pio0;
|
||||
uint sm = 0;
|
||||
|
||||
private:
|
||||
uint pin_;
|
||||
};
|
||||
@@ -0,0 +1,49 @@
|
||||
#ifndef _LWIPOPTS_H
|
||||
#define _LWIPOPTS_H
|
||||
|
||||
#ifndef NO_SYS
|
||||
#define NO_SYS 1
|
||||
#endif
|
||||
#ifndef LWIP_SOCKET
|
||||
#define LWIP_SOCKET 0
|
||||
#endif
|
||||
#if PICO_CYW43_ARCH_POLL
|
||||
#define MEM_LIBC_MALLOC 1
|
||||
#else
|
||||
#define MEM_LIBC_MALLOC 0
|
||||
#endif
|
||||
#define MEM_ALIGNMENT 4
|
||||
#ifndef MEM_SIZE
|
||||
#define MEM_SIZE 16000
|
||||
#endif
|
||||
#define MEMP_NUM_TCP_SEG 32
|
||||
#define MEMP_NUM_ARP_QUEUE 10
|
||||
#define PBUF_POOL_SIZE 24
|
||||
#define LWIP_ARP 1
|
||||
#define LWIP_ETHERNET 1
|
||||
#define LWIP_ICMP 1
|
||||
#define LWIP_RAW 1
|
||||
#define TCP_WND (8 * TCP_MSS)
|
||||
#define TCP_MSS 1460
|
||||
#define TCP_SND_BUF (8 * TCP_MSS)
|
||||
#define TCP_SND_QUEUELEN ((4 * (TCP_SND_BUF) + (TCP_MSS - 1)) / (TCP_MSS))
|
||||
#define LWIP_NETIF_STATUS_CALLBACK 1
|
||||
#define LWIP_NETIF_LINK_CALLBACK 1
|
||||
#define LWIP_NETIF_HOSTNAME 1
|
||||
#define LWIP_NETCONN 0
|
||||
#define MEM_STATS 0
|
||||
#define SYS_STATS 0
|
||||
#define MEMP_STATS 0
|
||||
#define LINK_STATS 0
|
||||
#define LWIP_CHKSUM_ALGORITHM 3
|
||||
#define LWIP_DHCP 1
|
||||
#define LWIP_IPV4 1
|
||||
#define LWIP_TCP 1
|
||||
#define LWIP_UDP 1
|
||||
#define LWIP_DNS 1
|
||||
#define LWIP_TCP_KEEPALIVE 1
|
||||
#define LWIP_NETIF_TX_SINGLE_PBUF 1
|
||||
#define DHCP_DOES_ARP_CHECK 0
|
||||
#define LWIP_DHCP_DOES_ACD_CHECK 0
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,121 @@
|
||||
# This is a copy of <PICO_SDK_PATH>/external/pico_sdk_import.cmake
|
||||
|
||||
# This can be dropped into an external project to help locate this SDK
|
||||
# It should be include()ed prior to project()
|
||||
|
||||
# Copyright 2020 (c) 2020 Raspberry Pi (Trading) Ltd.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
|
||||
# following conditions are met:
|
||||
#
|
||||
# 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following
|
||||
# disclaimer.
|
||||
#
|
||||
# 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
|
||||
# disclaimer in the documentation and/or other materials provided with the distribution.
|
||||
#
|
||||
# 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products
|
||||
# derived from this software without specific prior written permission.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
|
||||
# INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
||||
# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
||||
# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||
# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
if (DEFINED ENV{PICO_SDK_PATH} AND (NOT PICO_SDK_PATH))
|
||||
set(PICO_SDK_PATH $ENV{PICO_SDK_PATH})
|
||||
message("Using PICO_SDK_PATH from environment ('${PICO_SDK_PATH}')")
|
||||
endif ()
|
||||
|
||||
if (DEFINED ENV{PICO_SDK_FETCH_FROM_GIT} AND (NOT PICO_SDK_FETCH_FROM_GIT))
|
||||
set(PICO_SDK_FETCH_FROM_GIT $ENV{PICO_SDK_FETCH_FROM_GIT})
|
||||
message("Using PICO_SDK_FETCH_FROM_GIT from environment ('${PICO_SDK_FETCH_FROM_GIT}')")
|
||||
endif ()
|
||||
|
||||
if (DEFINED ENV{PICO_SDK_FETCH_FROM_GIT_PATH} AND (NOT PICO_SDK_FETCH_FROM_GIT_PATH))
|
||||
set(PICO_SDK_FETCH_FROM_GIT_PATH $ENV{PICO_SDK_FETCH_FROM_GIT_PATH})
|
||||
message("Using PICO_SDK_FETCH_FROM_GIT_PATH from environment ('${PICO_SDK_FETCH_FROM_GIT_PATH}')")
|
||||
endif ()
|
||||
|
||||
if (DEFINED ENV{PICO_SDK_FETCH_FROM_GIT_TAG} AND (NOT PICO_SDK_FETCH_FROM_GIT_TAG))
|
||||
set(PICO_SDK_FETCH_FROM_GIT_TAG $ENV{PICO_SDK_FETCH_FROM_GIT_TAG})
|
||||
message("Using PICO_SDK_FETCH_FROM_GIT_TAG from environment ('${PICO_SDK_FETCH_FROM_GIT_TAG}')")
|
||||
endif ()
|
||||
|
||||
if (PICO_SDK_FETCH_FROM_GIT AND NOT PICO_SDK_FETCH_FROM_GIT_TAG)
|
||||
set(PICO_SDK_FETCH_FROM_GIT_TAG "master")
|
||||
message("Using master as default value for PICO_SDK_FETCH_FROM_GIT_TAG")
|
||||
endif()
|
||||
|
||||
set(PICO_SDK_PATH "${PICO_SDK_PATH}" CACHE PATH "Path to the Raspberry Pi Pico SDK")
|
||||
set(PICO_SDK_FETCH_FROM_GIT "${PICO_SDK_FETCH_FROM_GIT}" CACHE BOOL "Set to ON to fetch copy of SDK from git if not otherwise locatable")
|
||||
set(PICO_SDK_FETCH_FROM_GIT_PATH "${PICO_SDK_FETCH_FROM_GIT_PATH}" CACHE FILEPATH "location to download SDK")
|
||||
set(PICO_SDK_FETCH_FROM_GIT_TAG "${PICO_SDK_FETCH_FROM_GIT_TAG}" CACHE FILEPATH "release tag for SDK")
|
||||
|
||||
if (NOT PICO_SDK_PATH)
|
||||
if (PICO_SDK_FETCH_FROM_GIT)
|
||||
include(FetchContent)
|
||||
set(FETCHCONTENT_BASE_DIR_SAVE ${FETCHCONTENT_BASE_DIR})
|
||||
if (PICO_SDK_FETCH_FROM_GIT_PATH)
|
||||
get_filename_component(FETCHCONTENT_BASE_DIR "${PICO_SDK_FETCH_FROM_GIT_PATH}" REALPATH BASE_DIR "${CMAKE_SOURCE_DIR}")
|
||||
endif ()
|
||||
FetchContent_Declare(
|
||||
pico_sdk
|
||||
GIT_REPOSITORY https://github.com/raspberrypi/pico-sdk
|
||||
GIT_TAG ${PICO_SDK_FETCH_FROM_GIT_TAG}
|
||||
)
|
||||
|
||||
if (NOT pico_sdk)
|
||||
message("Downloading Raspberry Pi Pico SDK")
|
||||
# GIT_SUBMODULES_RECURSE was added in 3.17
|
||||
if (${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.17.0")
|
||||
FetchContent_Populate(
|
||||
pico_sdk
|
||||
QUIET
|
||||
GIT_REPOSITORY https://github.com/raspberrypi/pico-sdk
|
||||
GIT_TAG ${PICO_SDK_FETCH_FROM_GIT_TAG}
|
||||
GIT_SUBMODULES_RECURSE FALSE
|
||||
|
||||
SOURCE_DIR ${FETCHCONTENT_BASE_DIR}/pico_sdk-src
|
||||
BINARY_DIR ${FETCHCONTENT_BASE_DIR}/pico_sdk-build
|
||||
SUBBUILD_DIR ${FETCHCONTENT_BASE_DIR}/pico_sdk-subbuild
|
||||
)
|
||||
else ()
|
||||
FetchContent_Populate(
|
||||
pico_sdk
|
||||
QUIET
|
||||
GIT_REPOSITORY https://github.com/raspberrypi/pico-sdk
|
||||
GIT_TAG ${PICO_SDK_FETCH_FROM_GIT_TAG}
|
||||
|
||||
SOURCE_DIR ${FETCHCONTENT_BASE_DIR}/pico_sdk-src
|
||||
BINARY_DIR ${FETCHCONTENT_BASE_DIR}/pico_sdk-build
|
||||
SUBBUILD_DIR ${FETCHCONTENT_BASE_DIR}/pico_sdk-subbuild
|
||||
)
|
||||
endif ()
|
||||
|
||||
set(PICO_SDK_PATH ${pico_sdk_SOURCE_DIR})
|
||||
endif ()
|
||||
set(FETCHCONTENT_BASE_DIR ${FETCHCONTENT_BASE_DIR_SAVE})
|
||||
else ()
|
||||
message(FATAL_ERROR
|
||||
"SDK location was not specified. Please set PICO_SDK_PATH or set PICO_SDK_FETCH_FROM_GIT to on to fetch from git."
|
||||
)
|
||||
endif ()
|
||||
endif ()
|
||||
|
||||
get_filename_component(PICO_SDK_PATH "${PICO_SDK_PATH}" REALPATH BASE_DIR "${CMAKE_BINARY_DIR}")
|
||||
if (NOT EXISTS ${PICO_SDK_PATH})
|
||||
message(FATAL_ERROR "Directory '${PICO_SDK_PATH}' not found")
|
||||
endif ()
|
||||
|
||||
set(PICO_SDK_INIT_CMAKE_FILE ${PICO_SDK_PATH}/pico_sdk_init.cmake)
|
||||
if (NOT EXISTS ${PICO_SDK_INIT_CMAKE_FILE})
|
||||
message(FATAL_ERROR "Directory '${PICO_SDK_PATH}' does not appear to contain the Raspberry Pi Pico SDK")
|
||||
endif ()
|
||||
|
||||
set(PICO_SDK_PATH ${PICO_SDK_PATH} CACHE PATH "Path to the Raspberry Pi Pico SDK" FORCE)
|
||||
|
||||
include(${PICO_SDK_INIT_CMAKE_FILE})
|
||||
@@ -0,0 +1,98 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Minify + gzip a web asset, then emit a C byte-array header."""
|
||||
from __future__ import annotations
|
||||
|
||||
import gzip
|
||||
import re
|
||||
import shutil
|
||||
import subprocess
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
|
||||
def minify_html(text: str) -> str:
|
||||
text = re.sub(r"<!--.*?-->", "", text, flags=re.DOTALL)
|
||||
text = re.sub(r">\s+<", "><", text)
|
||||
text = re.sub(r"\s+", " ", text)
|
||||
return text.strip()
|
||||
|
||||
|
||||
def minify_css(text: str) -> str:
|
||||
text = re.sub(r"/\*.*?\*/", "", text, flags=re.DOTALL)
|
||||
text = re.sub(r"\s+", " ", text)
|
||||
text = re.sub(r"\s*([{};:,>~+])\s*", r"\1", text)
|
||||
text = re.sub(r";}", "}", text)
|
||||
return text.strip()
|
||||
|
||||
|
||||
def minify_js(text: str, src: Path) -> str:
|
||||
terser = shutil.which("terser")
|
||||
cmd = None
|
||||
if terser:
|
||||
cmd = [terser, str(src), "--compress", "--mangle"]
|
||||
elif shutil.which("npx"):
|
||||
cmd = ["npx", "--yes", "terser", str(src), "--compress", "--mangle"]
|
||||
if cmd:
|
||||
try:
|
||||
r = subprocess.run(cmd, check=True, capture_output=True, text=True)
|
||||
if r.stdout.strip():
|
||||
return r.stdout
|
||||
except (subprocess.CalledProcessError, OSError) as e:
|
||||
print(f"embed_file: terser failed ({e}); using light JS minify", file=sys.stderr)
|
||||
|
||||
# Light fallback: drop block/line comments and collapse blank lines.
|
||||
text = re.sub(r"/\*.*?\*/", "", text, flags=re.DOTALL)
|
||||
text = re.sub(r"(?m)^\s*//.*$", "", text)
|
||||
text = re.sub(r"\n\s*\n+", "\n", text)
|
||||
return text.strip() + "\n"
|
||||
|
||||
|
||||
def minify(src: Path, data: bytes) -> bytes:
|
||||
suffix = src.suffix.lower()
|
||||
text = data.decode("utf-8")
|
||||
if suffix in (".html", ".htm"):
|
||||
return minify_html(text).encode("utf-8")
|
||||
if suffix == ".css":
|
||||
return minify_css(text).encode("utf-8")
|
||||
if suffix == ".js":
|
||||
return minify_js(text, src).encode("utf-8")
|
||||
return data
|
||||
|
||||
|
||||
def write_header(out: Path, symbol: str, src: Path, data: bytes, raw_len: int, min_len: int) -> None:
|
||||
lines = [
|
||||
f"/* auto-generated from {src} (minified+gzip) — do not edit */",
|
||||
f"/* raw={raw_len} minified={min_len} gzipped={len(data)} */",
|
||||
"#pragma once",
|
||||
"#include <stddef.h>",
|
||||
"#include <stdint.h>",
|
||||
f"static const uint8_t {symbol}[] = {{",
|
||||
]
|
||||
for i in range(0, len(data), 16):
|
||||
chunk = ", ".join(f"0x{b:02x}" for b in data[i : i + 16])
|
||||
lines.append(f" {chunk},")
|
||||
lines.append("};")
|
||||
lines.append(f"static const size_t {symbol}_len = sizeof({symbol});")
|
||||
lines.append("")
|
||||
out.parent.mkdir(parents=True, exist_ok=True)
|
||||
out.write_text("\n".join(lines), encoding="utf-8")
|
||||
|
||||
|
||||
def main() -> int:
|
||||
if len(sys.argv) != 4:
|
||||
print(f"usage: {sys.argv[0]} <input> <symbol> <output.h>", file=sys.stderr)
|
||||
return 2
|
||||
|
||||
src = Path(sys.argv[1])
|
||||
symbol = sys.argv[2]
|
||||
out = Path(sys.argv[3])
|
||||
raw = src.read_bytes()
|
||||
mini = minify(src, raw)
|
||||
gz = gzip.compress(mini, compresslevel=9, mtime=0)
|
||||
write_header(out, symbol, src, gz, len(raw), len(mini))
|
||||
print(f"embed {src.name}: {len(raw)} -> {len(mini)} min -> {len(gz)} gzip")
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
+29
@@ -0,0 +1,29 @@
|
||||
#include <stdio.h>
|
||||
|
||||
#include "pico/stdlib.h"
|
||||
#include "pico/cyw43_arch.h"
|
||||
#include "cyw43.h"
|
||||
#include "lwip/ip_addr.h"
|
||||
|
||||
#include "ap.h"
|
||||
#include "dhcpserver.h"
|
||||
|
||||
static dhcp_server_t dhcp_server;
|
||||
|
||||
bool ap_start(void) {
|
||||
cyw43_arch_enable_ap_mode(AP_SSID, AP_PASS, CYW43_AUTH_WPA2_AES_PSK);
|
||||
cyw43_wifi_pm(&cyw43_state, CYW43_NONE_PM);
|
||||
|
||||
ip_addr_t gw, mask;
|
||||
|
||||
gw.addr = PP_HTONL(CYW43_DEFAULT_IP_AP_ADDRESS);
|
||||
mask.addr = PP_HTONL(CYW43_DEFAULT_IP_MASK);
|
||||
|
||||
dhcp_server_init(&dhcp_server, &gw, &mask);
|
||||
|
||||
|
||||
printf("AP up: SSID=%s pass=%s ip=%s\n",
|
||||
AP_SSID, AP_PASS, ipaddr_ntoa(&gw));
|
||||
|
||||
return true;
|
||||
}
|
||||
+12
@@ -0,0 +1,12 @@
|
||||
#ifndef AP_H
|
||||
#define AP_H
|
||||
|
||||
#include <stdbool.h>
|
||||
|
||||
#define AP_SSID "hoop"
|
||||
#define AP_PASS "hoop-1234"
|
||||
|
||||
// Start soft-AP + DHCP. cyw43_arch_init() must already have succeeded.
|
||||
bool ap_start(void);
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,65 @@
|
||||
#include "cmd_queue.h"
|
||||
|
||||
#include <string.h>
|
||||
|
||||
#include "hardware/sync.h"
|
||||
#include "pico/multicore.h"
|
||||
|
||||
/* RP2350 SIO FIFO is 4 entries deep; keep the pool the same size. */
|
||||
#define CMD_QUEUE_SIZE 4
|
||||
|
||||
static led_cmd_t slots[CMD_QUEUE_SIZE];
|
||||
static uint8_t free_stack[CMD_QUEUE_SIZE];
|
||||
static int free_top;
|
||||
static bool inited;
|
||||
|
||||
void cmd_queue_init(void) {
|
||||
free_top = 0;
|
||||
for (int i = 0; i < CMD_QUEUE_SIZE; i++) {
|
||||
free_stack[free_top++] = (uint8_t)i;
|
||||
}
|
||||
inited = true;
|
||||
}
|
||||
|
||||
/* Core0: reclaim slot indices returned by core1. */
|
||||
static void reclaim_returns(void) {
|
||||
while (multicore_fifo_rvalid()) {
|
||||
uint32_t idx = multicore_fifo_pop_blocking();
|
||||
if (idx < CMD_QUEUE_SIZE && free_top < CMD_QUEUE_SIZE) {
|
||||
free_stack[free_top++] = (uint8_t)idx;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool cmd_queue_push(const led_cmd_t *cmd) {
|
||||
if (!inited || !cmd) {
|
||||
return false;
|
||||
}
|
||||
reclaim_returns();
|
||||
if (free_top == 0) {
|
||||
return false;
|
||||
}
|
||||
uint8_t idx = free_stack[--free_top];
|
||||
slots[idx] = *cmd;
|
||||
__dmb();
|
||||
if (!multicore_fifo_push_timeout_us(idx, 0)) {
|
||||
free_stack[free_top++] = idx;
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool cmd_queue_pop(led_cmd_t *cmd) {
|
||||
if (!cmd || !multicore_fifo_rvalid()) {
|
||||
return false;
|
||||
}
|
||||
uint32_t idx = multicore_fifo_pop_blocking();
|
||||
if (idx >= CMD_QUEUE_SIZE) {
|
||||
return false;
|
||||
}
|
||||
__dmb();
|
||||
*cmd = slots[idx];
|
||||
/* Return slot ownership to core0 via the opposite FIFO. */
|
||||
multicore_fifo_push_blocking(idx);
|
||||
return true;
|
||||
}
|
||||
@@ -0,0 +1,59 @@
|
||||
#ifndef CMD_QUEUE_H
|
||||
#define CMD_QUEUE_H
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef enum {
|
||||
CMD_SELECT = 1,
|
||||
CMD_EDIT,
|
||||
CMD_DELETE,
|
||||
CMD_SAVE,
|
||||
CMD_BRIGHTNESS,
|
||||
} cmd_type_t;
|
||||
|
||||
#define CMD_NAME_MAX 32
|
||||
#define CMD_PATTERN_MAX 32
|
||||
#define CMD_COLORS_MAX 16
|
||||
|
||||
typedef struct {
|
||||
uint8_t r;
|
||||
uint8_t g;
|
||||
uint8_t b;
|
||||
} cmd_rgb_t;
|
||||
|
||||
/* Typed preset fields for CMD_EDIT (parsed from JSON on core 0). */
|
||||
typedef struct {
|
||||
char pattern[CMD_PATTERN_MAX];
|
||||
int d;
|
||||
int b;
|
||||
cmd_rgb_t c[CMD_COLORS_MAX];
|
||||
uint8_t c_count;
|
||||
int n1, n2, n3, n4;
|
||||
int n5, n6, n7, n8;
|
||||
} cmd_preset_t;
|
||||
|
||||
typedef struct {
|
||||
cmd_type_t type;
|
||||
char name[CMD_NAME_MAX];
|
||||
union {
|
||||
cmd_preset_t edit;
|
||||
int brightness;
|
||||
} u;
|
||||
} led_cmd_t;
|
||||
|
||||
/* Call on core0 before multicore_launch_core1. */
|
||||
void cmd_queue_init(void);
|
||||
|
||||
bool cmd_queue_push(const led_cmd_t *cmd);
|
||||
bool cmd_queue_pop(led_cmd_t *cmd);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,74 @@
|
||||
#include "flash_store.h"
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "hardware/flash.h"
|
||||
#include "hardware/sync.h"
|
||||
#include "pico/stdlib.h"
|
||||
|
||||
/* Two sectors near end of flash: buttons, presets */
|
||||
#ifndef PICO_FLASH_SIZE_BYTES
|
||||
#define PICO_FLASH_SIZE_BYTES (2 * 1024 * 1024)
|
||||
#endif
|
||||
|
||||
#define STORE_MAGIC 0x484F4F50u /* HOOP */
|
||||
|
||||
typedef struct {
|
||||
uint32_t magic;
|
||||
uint32_t len;
|
||||
char name[16];
|
||||
char data[FLASH_STORE_MAX - 24];
|
||||
} store_blob_t;
|
||||
|
||||
_Static_assert(sizeof(store_blob_t) <= FLASH_SECTOR_SIZE, "blob too big");
|
||||
|
||||
static uint32_t slot_offset(const char *name) {
|
||||
uint32_t base = PICO_FLASH_SIZE_BYTES - 2 * FLASH_SECTOR_SIZE;
|
||||
if (strcmp(name, "buttons") == 0) {
|
||||
return base;
|
||||
}
|
||||
return base + FLASH_SECTOR_SIZE; /* presets */
|
||||
}
|
||||
|
||||
bool flash_store_load(const char *name, char *out, size_t out_len, size_t *out_size) {
|
||||
if (!name || !out || out_len == 0) {
|
||||
return false;
|
||||
}
|
||||
const store_blob_t *blob = (const store_blob_t *)(XIP_BASE + slot_offset(name));
|
||||
if (blob->magic != STORE_MAGIC || blob->len == 0 || blob->len >= sizeof(blob->data)) {
|
||||
return false;
|
||||
}
|
||||
if (strncmp(blob->name, name, sizeof(blob->name)) != 0) {
|
||||
return false;
|
||||
}
|
||||
size_t n = blob->len;
|
||||
if (n >= out_len) {
|
||||
n = out_len - 1;
|
||||
}
|
||||
memcpy(out, blob->data, n);
|
||||
out[n] = '\0';
|
||||
if (out_size) {
|
||||
*out_size = n;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool flash_store_save(const char *name, const char *data, size_t len) {
|
||||
if (!name || !data || len >= FLASH_STORE_MAX - 24) {
|
||||
return false;
|
||||
}
|
||||
store_blob_t blob;
|
||||
memset(&blob, 0, sizeof(blob));
|
||||
blob.magic = STORE_MAGIC;
|
||||
blob.len = (uint32_t)len;
|
||||
snprintf(blob.name, sizeof(blob.name), "%s", name);
|
||||
memcpy(blob.data, data, len);
|
||||
|
||||
uint32_t off = slot_offset(name);
|
||||
uint32_t ints = save_and_disable_interrupts();
|
||||
flash_range_erase(off, FLASH_SECTOR_SIZE);
|
||||
flash_range_program(off, (const uint8_t *)&blob, sizeof(blob));
|
||||
restore_interrupts(ints);
|
||||
return true;
|
||||
}
|
||||
@@ -0,0 +1,20 @@
|
||||
#ifndef FLASH_STORE_H
|
||||
#define FLASH_STORE_H
|
||||
|
||||
#include <stddef.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#define FLASH_STORE_MAX 4096
|
||||
|
||||
bool flash_store_load(const char *name, char *out, size_t out_len, size_t *out_size);
|
||||
bool flash_store_save(const char *name, const char *data, size_t len);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,77 @@
|
||||
#include "led_core.h"
|
||||
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <string>
|
||||
|
||||
#include "pico/stdlib.h"
|
||||
|
||||
#include "cmd_queue.h"
|
||||
#include "leds/presets.hpp"
|
||||
#include "leds/preset.hpp"
|
||||
|
||||
static Preset preset_from_cmd(const cmd_preset_t &src) {
|
||||
Preset p;
|
||||
p.p = src.pattern;
|
||||
p.d = src.d;
|
||||
p.b = src.b;
|
||||
p.n1 = src.n1;
|
||||
p.n2 = src.n2;
|
||||
p.n3 = src.n3;
|
||||
p.n4 = src.n4;
|
||||
p.n5 = src.n5;
|
||||
p.n6 = src.n6;
|
||||
p.n7 = src.n7;
|
||||
p.n8 = src.n8;
|
||||
p.c.clear();
|
||||
uint8_t n = src.c_count;
|
||||
if (n > CMD_COLORS_MAX) {
|
||||
n = CMD_COLORS_MAX;
|
||||
}
|
||||
for (uint8_t i = 0; i < n; i++) {
|
||||
p.c.push_back({src.c[i].r, src.c[i].g, src.c[i].b});
|
||||
}
|
||||
if (p.c.empty()) {
|
||||
p.c.push_back({255, 255, 255});
|
||||
}
|
||||
return p;
|
||||
}
|
||||
|
||||
static void apply_cmd(Presets &presets, const led_cmd_t &cmd) {
|
||||
switch (cmd.type) {
|
||||
case CMD_SELECT:
|
||||
presets.select(cmd.name);
|
||||
break;
|
||||
case CMD_EDIT:
|
||||
presets.edit(cmd.name, preset_from_cmd(cmd.u.edit));
|
||||
break;
|
||||
case CMD_DELETE:
|
||||
presets.remove(cmd.name);
|
||||
break;
|
||||
case CMD_SAVE:
|
||||
/* RAM only for now; flash persistence of presets can be added later */
|
||||
printf("led: preset_save acknowledged (%zu presets)\n", presets.presets.size());
|
||||
break;
|
||||
case CMD_BRIGHTNESS:
|
||||
presets.b = (uint8_t)cmd.u.brightness;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
extern "C" void led_core_entry(void) {
|
||||
Presets presets;
|
||||
presets.select("off");
|
||||
printf("led core1: ready (%zu strips)\n", Presets::kStripCount);
|
||||
|
||||
while (true) {
|
||||
led_cmd_t cmd;
|
||||
while (cmd_queue_pop(&cmd)) {
|
||||
apply_cmd(presets, cmd);
|
||||
}
|
||||
presets.tick();
|
||||
if (presets.current) {
|
||||
presets.show_all_parallel();
|
||||
}
|
||||
sleep_ms(1);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,14 @@
|
||||
#ifndef LED_CORE_H
|
||||
#define LED_CORE_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
void led_core_entry(void);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,38 @@
|
||||
#include <stdio.h>
|
||||
|
||||
#include "pico/stdlib.h"
|
||||
#include "pico/multicore.h"
|
||||
#include "pico/cyw43_arch.h"
|
||||
|
||||
#include "ap.h"
|
||||
#include "web.h"
|
||||
#include "led_core.h"
|
||||
#include "cmd_queue.h"
|
||||
|
||||
int main() {
|
||||
stdio_init_all();
|
||||
sleep_ms(200);
|
||||
|
||||
while (cyw43_arch_init()) {
|
||||
printf("cyw43_arch_init failed; retrying...\n");
|
||||
sleep_ms(1000);
|
||||
}
|
||||
|
||||
printf("led_hoop: Soft-AP + web + LEDs\n");
|
||||
|
||||
cmd_queue_init();
|
||||
multicore_launch_core1(led_core_entry);
|
||||
|
||||
ap_start();
|
||||
web_start();
|
||||
|
||||
unsigned count = 0;
|
||||
while (true) {
|
||||
/* Keep core0 responsive for cyw43 background; light status print */
|
||||
if (count % 20 == 0) {
|
||||
printf("core0 alive count=%u\n", count);
|
||||
}
|
||||
count++;
|
||||
sleep_ms(500);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,190 @@
|
||||
#include "mini_json.h"
|
||||
|
||||
#include <ctype.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
static const char *skip_ws(const char *p) {
|
||||
while (*p && isspace((unsigned char)*p)) {
|
||||
p++;
|
||||
}
|
||||
return p;
|
||||
}
|
||||
|
||||
static const char *find_key(const char *json, const char *key) {
|
||||
char pat[64];
|
||||
snprintf(pat, sizeof(pat), "\"%s\"", key);
|
||||
const char *p = json;
|
||||
while ((p = strstr(p, pat)) != NULL) {
|
||||
const char *after = p + strlen(pat);
|
||||
after = skip_ws(after);
|
||||
if (*after == ':') {
|
||||
return skip_ws(after + 1);
|
||||
}
|
||||
p++;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static bool copy_string_value(const char *p, char *out, size_t out_len) {
|
||||
p = skip_ws(p);
|
||||
if (*p != '"') {
|
||||
return false;
|
||||
}
|
||||
p++;
|
||||
size_t i = 0;
|
||||
while (*p && *p != '"' && i + 1 < out_len) {
|
||||
if (*p == '\\' && p[1]) {
|
||||
p++;
|
||||
}
|
||||
out[i++] = *p++;
|
||||
}
|
||||
out[i] = '\0';
|
||||
return true;
|
||||
}
|
||||
|
||||
bool json_get_string(const char *json, const char *key, char *out, size_t out_len) {
|
||||
const char *p = find_key(json, key);
|
||||
if (!p) {
|
||||
return false;
|
||||
}
|
||||
return copy_string_value(p, out, out_len);
|
||||
}
|
||||
|
||||
bool json_get_object(const char *json, const char *key, char *out, size_t out_len) {
|
||||
const char *p = find_key(json, key);
|
||||
if (!p) {
|
||||
return false;
|
||||
}
|
||||
p = skip_ws(p);
|
||||
if (*p != '{') {
|
||||
return false;
|
||||
}
|
||||
int depth = 0;
|
||||
const char *start = p;
|
||||
do {
|
||||
if (*p == '{') {
|
||||
depth++;
|
||||
} else if (*p == '}') {
|
||||
depth--;
|
||||
} else if (*p == '"') {
|
||||
p++;
|
||||
while (*p && *p != '"') {
|
||||
if (*p == '\\' && p[1]) {
|
||||
p++;
|
||||
}
|
||||
p++;
|
||||
}
|
||||
}
|
||||
if (!*p) {
|
||||
return false;
|
||||
}
|
||||
p++;
|
||||
} while (depth > 0);
|
||||
size_t n = (size_t)(p - start);
|
||||
if (n >= out_len) {
|
||||
n = out_len - 1;
|
||||
}
|
||||
memcpy(out, start, n);
|
||||
out[n] = '\0';
|
||||
return true;
|
||||
}
|
||||
|
||||
bool json_get_bool(const char *json, const char *key, bool *out) {
|
||||
const char *p = find_key(json, key);
|
||||
if (!p || !out) {
|
||||
return false;
|
||||
}
|
||||
p = skip_ws(p);
|
||||
if (strncmp(p, "true", 4) == 0) {
|
||||
*out = true;
|
||||
return true;
|
||||
}
|
||||
if (strncmp(p, "false", 5) == 0) {
|
||||
*out = false;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool json_get_int(const char *json, const char *key, int *out) {
|
||||
const char *p = find_key(json, key);
|
||||
if (!p || !out) {
|
||||
return false;
|
||||
}
|
||||
p = skip_ws(p);
|
||||
char *end = NULL;
|
||||
long v = strtol(p, &end, 10);
|
||||
if (end == p) {
|
||||
return false;
|
||||
}
|
||||
*out = (int)v;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool json_get_rgb_array(const char *json, const char *key,
|
||||
uint8_t (*out)[3], size_t max, size_t *count_out) {
|
||||
if (!json || !key || !out || !count_out || max == 0) {
|
||||
return false;
|
||||
}
|
||||
const char *p = find_key(json, key);
|
||||
if (!p) {
|
||||
return false;
|
||||
}
|
||||
p = skip_ws(p);
|
||||
if (*p != '[') {
|
||||
return false;
|
||||
}
|
||||
size_t n = 0;
|
||||
const char *scan = p;
|
||||
while (n < max && (scan = strchr(scan, '[')) != NULL) {
|
||||
if (scan == p) {
|
||||
scan++;
|
||||
continue;
|
||||
}
|
||||
int r = 0, g = 0, b = 0;
|
||||
if (sscanf(scan, "[%d,%d,%d]", &r, &g, &b) == 3) {
|
||||
out[n][0] = (uint8_t)r;
|
||||
out[n][1] = (uint8_t)g;
|
||||
out[n][2] = (uint8_t)b;
|
||||
n++;
|
||||
}
|
||||
scan++;
|
||||
}
|
||||
*count_out = n;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool json_get_select_name(const char *json, char *out, size_t out_len) {
|
||||
const char *p = find_key(json, "select");
|
||||
if (!p) {
|
||||
return false;
|
||||
}
|
||||
p = skip_ws(p);
|
||||
if (*p == '"') {
|
||||
return copy_string_value(p, out, out_len);
|
||||
}
|
||||
if (*p == '[') {
|
||||
/* ["id","name"] — take second string */
|
||||
p++;
|
||||
p = skip_ws(p);
|
||||
if (*p == '"') {
|
||||
char tmp[64];
|
||||
if (!copy_string_value(p, tmp, sizeof(tmp))) {
|
||||
return false;
|
||||
}
|
||||
p = strchr(p + 1, '"');
|
||||
if (!p) {
|
||||
return false;
|
||||
}
|
||||
p++;
|
||||
p = skip_ws(p);
|
||||
if (*p == ',') {
|
||||
p = skip_ws(p + 1);
|
||||
}
|
||||
return copy_string_value(p, out, out_len);
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
@@ -0,0 +1,32 @@
|
||||
#ifndef MINI_JSON_H
|
||||
#define MINI_JSON_H
|
||||
|
||||
#include <stddef.h>
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* Extract JSON string value for key into out (unescaped simple strings). */
|
||||
bool json_get_string(const char *json, const char *key, char *out, size_t out_len);
|
||||
|
||||
/* Extract nested object text for key into out (raw substring including braces). */
|
||||
bool json_get_object(const char *json, const char *key, char *out, size_t out_len);
|
||||
|
||||
bool json_get_bool(const char *json, const char *key, bool *out);
|
||||
bool json_get_int(const char *json, const char *key, int *out);
|
||||
|
||||
/* Parse "key":[[r,g,b],...] into out[i][0..2]. Returns false if key missing. */
|
||||
bool json_get_rgb_array(const char *json, const char *key,
|
||||
uint8_t (*out)[3], size_t max, size_t *count_out);
|
||||
|
||||
/* If select is a string, copy it; if ["id","name"], copy name. */
|
||||
bool json_get_select_name(const char *json, char *out, size_t out_len);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,201 @@
|
||||
#include "patterns/patterns.hpp"
|
||||
|
||||
#include <algorithm>
|
||||
#include <cmath>
|
||||
#include "pico/stdlib.h"
|
||||
#include "leds/presets.hpp"
|
||||
|
||||
namespace {
|
||||
uint32_t now() { return to_ms_since_boot(get_absolute_time()); }
|
||||
bool due(uint32_t& last, uint32_t ms) {
|
||||
const uint32_t current = now();
|
||||
if (current - last < ms) return false;
|
||||
last = current; return true;
|
||||
}
|
||||
RGB black() { return {0, 0, 0}; }
|
||||
RGB lerp(RGB a, RGB b, float t) {
|
||||
return {static_cast<uint8_t>(a.r + (b.r - a.r) * t), static_cast<uint8_t>(a.g + (b.g - a.g) * t),
|
||||
static_cast<uint8_t>(a.b + (b.b - a.b) * t)};
|
||||
}
|
||||
RGB hue(int hue) {
|
||||
hue = ((hue % 360) + 360) % 360;
|
||||
const float x = 1.0f - std::abs(std::fmod(hue / 60.0f, 2.0f) - 1.0f);
|
||||
if (hue < 60) return {255, static_cast<uint8_t>(x * 255), 0};
|
||||
if (hue < 120) return {static_cast<uint8_t>(x * 255), 255, 0};
|
||||
if (hue < 180) return {0, 255, static_cast<uint8_t>(x * 255)};
|
||||
if (hue < 240) return {0, static_cast<uint8_t>(x * 255), 255};
|
||||
if (hue < 300) return {static_cast<uint8_t>(x * 255), 0, 255};
|
||||
return {255, 0, static_cast<uint8_t>(x * 255)};
|
||||
}
|
||||
RGB color(const Preset* p, size_t index, RGB fallback = {255, 255, 255}) {
|
||||
return p->c.empty() ? fallback : p->c[index % p->c.size()];
|
||||
}
|
||||
void begin(Presets*& dest, Preset*& preset_dest, uint32_t& started, uint32_t& last,
|
||||
Presets& ps, Preset* p) {
|
||||
dest = &ps; preset_dest = p; started = last = now();
|
||||
}
|
||||
void static_done(Presets*& ps, Preset*& p, uint32_t& started, uint32_t& last,
|
||||
Presets& x, Preset* y) { begin(ps, p, started, last, x, y); }
|
||||
}
|
||||
|
||||
#define START(CLASS) void CLASS::start(Presets& ps, Preset* p) { begin(ps_, p_, started_, last_, ps, p); step_ = head_ = tail_ = phase_ = 0; drawn_ = false; }
|
||||
|
||||
START(Blink)
|
||||
bool Blink::tick() {
|
||||
if (!due(last_, std::max(1, p_->d))) return true;
|
||||
if (phase_++ % 2 == 0) ps_->fill(ps_->apply_brightness(color(p_, step_++), p_->b));
|
||||
else ps_->fill(black());
|
||||
ps_->show_all_parallel(); return true;
|
||||
}
|
||||
|
||||
START(Rainbow)
|
||||
bool Rainbow::tick() {
|
||||
if (!due(last_, p_->a ? std::max(1, p_->d) : 0)) return true;
|
||||
const int advance = std::max(1, p_->n1);
|
||||
for (size_t s = 0; s < Presets::kStripCount; ++s)
|
||||
for (uint16_t i = 0; i < ps_->strips[s]->num_leds; ++i)
|
||||
ps_->strips[s]->set(i, ps_->apply_brightness(hue((i * 720 / ps_->strips[s]->num_leds) + step_), p_->b));
|
||||
ps_->show_all_parallel(); step_ += advance; ps_->step = step_ * 256 / 873;
|
||||
return p_->a;
|
||||
}
|
||||
|
||||
START(Pulse)
|
||||
bool Pulse::tick() {
|
||||
const int attack = std::max(0, p_->n1), hold = std::max(0, p_->n2), decay = std::max(0, p_->n3);
|
||||
const int total = std::max(1, attack + hold + decay + std::max(0, p_->d));
|
||||
const uint32_t elapsed = now() - started_;
|
||||
float factor = 0;
|
||||
if (elapsed < static_cast<uint32_t>(attack) && attack) factor = float(elapsed) / attack;
|
||||
else if (elapsed < static_cast<uint32_t>(attack + hold)) factor = 1;
|
||||
else if (elapsed < static_cast<uint32_t>(attack + hold + decay) && decay)
|
||||
factor = 1.0f - float(elapsed - attack - hold) / decay;
|
||||
ps_->fill(ps_->apply_brightness(lerp(black(), color(p_, step_), factor), p_->b));
|
||||
ps_->show_all_parallel();
|
||||
if (elapsed >= static_cast<uint32_t>(total)) { started_ = now(); ++step_; return p_->a; }
|
||||
return true;
|
||||
}
|
||||
|
||||
START(Transition)
|
||||
bool Transition::tick() {
|
||||
if (p_->c.empty()) { ps_->off(); return false; }
|
||||
if (p_->c.size() == 1) { ps_->fill(ps_->apply_brightness(p_->c[0], p_->b)); ps_->show_all_parallel(); return true; }
|
||||
const int duration = std::max(10, p_->d); const uint32_t elapsed = now() - started_;
|
||||
if (elapsed >= static_cast<uint32_t>(duration)) {
|
||||
ps_->fill(ps_->apply_brightness(color(p_, step_ + 1), p_->b)); ps_->show_all_parallel();
|
||||
if (!p_->a) return false; ++step_; started_ = now(); return true;
|
||||
}
|
||||
ps_->fill(ps_->apply_brightness(lerp(color(p_, step_), color(p_, step_ + 1), float(elapsed) / duration), p_->b));
|
||||
ps_->show_all_parallel(); return true;
|
||||
}
|
||||
|
||||
START(Chase)
|
||||
bool Chase::tick() {
|
||||
if (drawn_ && (!p_->a || !due(last_, std::max(10, p_->d)))) return p_->a;
|
||||
const int n1 = std::max(1, p_->n1), n2 = std::max(1, p_->n2), len = n1 + n2;
|
||||
const int position = (step_ % 2 == 0 ? (step_ / 2) * (p_->n3 + p_->n4) + p_->n3
|
||||
: ((step_ + 1) / 2) * (p_->n3 + p_->n4));
|
||||
for (int i = 0; i < 291; ++i) ps_->fill_n(ps_->apply_brightness(((i - position + len * 100) % len) < n1 ? color(p_, 0) : color(p_, 1), p_->b), i, i + 1);
|
||||
ps_->show_all_parallel(); ps_->step = ++step_; drawn_ = true; return p_->a;
|
||||
}
|
||||
|
||||
START(Circle)
|
||||
bool Circle::tick() {
|
||||
const int head_delay = 1000 / std::max(1, p_->n1), tail_delay = 1000 / std::max(1, p_->n3);
|
||||
const int max_len = std::max(1, p_->n2), min_len = std::max(0, p_->n4);
|
||||
if (due(last_, head_delay)) ++head_;
|
||||
if (phase_ == 1 && due(started_, tail_delay)) ++tail_;
|
||||
const int length = std::max(0, head_ - tail_);
|
||||
if (phase_ == 0 && length >= max_len) phase_ = 1;
|
||||
if (phase_ == 1 && length <= min_len) phase_ = min_len ? 0 : 2;
|
||||
if (phase_ == 2) { phase_ = 0; tail_ = head_; }
|
||||
ps_->fill(phase_ == 2 ? ps_->apply_brightness(color(p_, 1, black()), p_->b) : black());
|
||||
for (int i = 0; i <= length; ++i) ps_->fill_n(ps_->apply_brightness(color(p_, 0), p_->b), tail_ + i, tail_ + i + 1);
|
||||
ps_->show_all_parallel(); return true;
|
||||
}
|
||||
|
||||
START(Roll)
|
||||
bool Roll::tick() {
|
||||
if (drawn_ && (!p_->a || !due(last_, std::max(1, p_->d)))) return p_->a;
|
||||
const int head = (p_->n4 == 0 ? step_ : 7 - step_) & 7; ps_->last_roll_head = head;
|
||||
const RGB c1 = ps_->apply_brightness(color(p_, 0), p_->b), c2 = ps_->apply_brightness(color(p_, 1, black()), p_->b);
|
||||
for (int s = 0; s < 8; ++s) {
|
||||
const int dist = p_->n4 == 0 ? (head - s + 8) % 8 : (s - head + 8) % 8;
|
||||
const RGB c = lerp(c1, c2, dist / 7.0f); auto& strip = *ps_->strips[s];
|
||||
const int begin_at = std::max(0, p_->n1), end_at = std::max(begin_at, int(strip.num_leds) - std::max(0, p_->n2));
|
||||
for (uint16_t i = 0; i < strip.num_leds; ++i) strip.set(i, i >= begin_at && i < end_at ? c : black());
|
||||
}
|
||||
ps_->show_all_parallel(); ++step_; ps_->step = step_; drawn_ = true;
|
||||
return !(p_->n3 > 0 && step_ >= p_->n3 * 8);
|
||||
}
|
||||
|
||||
START(Calibration)
|
||||
bool Calibration::tick() {
|
||||
if (drawn_) return true;
|
||||
for (int s = 0; s < 8; ++s) for (uint16_t i = 0; i < ps_->strips[s]->num_leds; ++i)
|
||||
ps_->strips[s]->set(i, (s == 2 || s == 6) ? (i < 10 ? RGB{0,25,0} : (((i-10)/10)%2 ? RGB{25,0,0} : RGB{0,0,25})) : black());
|
||||
ps_->show_all_parallel(); drawn_ = true; return true;
|
||||
}
|
||||
START(Test)
|
||||
bool Test::tick() {
|
||||
if (drawn_) return true;
|
||||
ps_->fill(black()); for (int s = 0; s < 8; ++s) { for (int i=0;i<=s;++i) ps_->strips[s]->set(i,{127,0,0}); ps_->strips[s]->set(ps_->strip_midpoints[s],{127,0,0}); }
|
||||
ps_->show_all_parallel(); drawn_=true; return true;
|
||||
}
|
||||
START(Grab)
|
||||
bool Grab::tick() {
|
||||
if (drawn_) return true; ps_->fill(black());
|
||||
for (int s=0;s<8;++s) for (int i=std::max(0,int(ps_->strip_midpoints[s])-10); i<=int(ps_->strip_midpoints[s])+10; ++i) ps_->strips[s]->set(i,color(p_,0,{180,0,255}));
|
||||
ps_->show_all_parallel(); drawn_=true; return true;
|
||||
}
|
||||
|
||||
START(Spin)
|
||||
bool Spin::tick() {
|
||||
if (!due(last_, std::max(1,p_->d))) return true;
|
||||
const int rate=std::max(1,p_->n1), margin=std::max(0,p_->n2);
|
||||
for (int s : {0,4}) { auto& strip=*ps_->strips[s]; int mid=ps_->strip_midpoints[s], expand=step_*(s==0?std::max(1,rate/2):rate);
|
||||
int left=std::max(margin,mid-10-expand), right=std::min(int(strip.num_leds)-margin,mid+11+expand);
|
||||
for(int i=left;i<mid-10;++i) strip.set(i,lerp(color(p_,1),color(p_,0),float(i-left)/std::max(1,mid-10-left-1)));
|
||||
for(int i=mid+11;i<right;++i) strip.set(i,lerp(color(p_,0),color(p_,1),float(i-mid-11)/std::max(1,right-mid-12))); }
|
||||
ps_->show_all_parallel(); ++step_; return true;
|
||||
}
|
||||
START(Lift)
|
||||
bool Lift::tick() {
|
||||
if (!due(last_,std::max(1,p_->d))) return true;
|
||||
const int rate=std::max(1,p_->n1), margin=std::max(0,p_->n2); bool done=true;
|
||||
for(int s : {0,4}) { auto& strip=*ps_->strips[s]; int mid=ps_->strip_midpoints[s], shrink=step_*(s==0?std::max(1,rate/2):rate);
|
||||
int left=std::min(mid-10,margin+shrink), right=std::max(mid+11,int(strip.num_leds)-margin-shrink);
|
||||
for(int i=margin;i<mid-10;++i) strip.set(i,black()); for(int i=mid+11;i<int(strip.num_leds)-margin;++i) strip.set(i,black());
|
||||
for(int i=left;i<mid-10;++i) strip.set(i,lerp(color(p_,1),color(p_,0),float(i-left)/std::max(1,mid-10-left-1)));
|
||||
for(int i=mid+11;i<right;++i) strip.set(i,lerp(color(p_,0),color(p_,1),float(i-mid-11)/std::max(1,right-mid-12)));
|
||||
done &= left==mid-10 && right==mid+11; }
|
||||
ps_->show_all_parallel(); ++step_; return true; // Lift holds its final image.
|
||||
}
|
||||
START(Flare)
|
||||
bool Flare::tick() {
|
||||
const int fade=std::max(1,p_->d); const float f=std::min(1.0f,float(now()-started_)/fade); auto& strip=*ps_->strips[std::clamp(ps_->last_roll_head,0,7)];
|
||||
const int count=std::clamp(p_->n1,0,int(strip.num_leds)); for(uint16_t i=0;i<strip.num_leds;++i) strip.set(i,ps_->apply_brightness(lerp(black(),color(p_,i<count?0:1,black()),f),p_->b));
|
||||
strip.show(); return true;
|
||||
}
|
||||
START(Hook)
|
||||
bool Hook::tick() {
|
||||
if(drawn_) return true; ps_->fill(black()); const int a=std::max(0,p_->n1),b=std::min(7,std::max(a,p_->n2)),span=std::max(0,p_->n3);
|
||||
for(int s=a;s<=b;++s) { int center=ps_->strip_midpoints[s]+p_->n4; for(int i=std::max(0,center-span);i<=std::min(int(ps_->strips[s]->num_leds)-1,center+span);++i) ps_->strips[s]->set(i,color(p_,0,black())); }
|
||||
ps_->show_all_parallel(); drawn_=true; return true;
|
||||
}
|
||||
START(Pose)
|
||||
bool Pose::tick() {
|
||||
if(drawn_) return true; const int ranges[8]={p_->n1,p_->n2,p_->n3,p_->n4,p_->n5,p_->n6,p_->n7,p_->n8};
|
||||
for(auto& sp:ps_->strips) for(uint16_t i=0;i<sp->num_leds;++i) { RGB out=black(); for(int n=0;n<4;++n) {int a=std::min(ranges[n*2],ranges[n*2+1]),b=std::max(ranges[n*2],ranges[n*2+1]);if(i>=a&&i<=b)out=ps_->apply_brightness(color(p_,n,black()),p_->b);} sp->set(i,out); }
|
||||
ps_->show_all_parallel();drawn_=true;return true;
|
||||
}
|
||||
START(Point)
|
||||
bool Point::tick() {
|
||||
if(drawn_) return false; ps_->fill(black()); const int r[8]={p_->n1,p_->n2,p_->n3,p_->n4,p_->n5,p_->n6,p_->n7,p_->n8};
|
||||
for(int n=0;n<4;++n) ps_->fill_n(ps_->apply_brightness(color(p_,n,black()),p_->b),r[n*2],r[n*2+1]);
|
||||
ps_->show_all_parallel();drawn_=true;return false;
|
||||
}
|
||||
START(ScaleTest)
|
||||
bool ScaleTest::tick() {
|
||||
if(!due(last_,std::max(1,p_->d)))return true;ps_->fill(black());for(size_t s=0;s<8;++s)ps_->set(s,step_%291,ps_->apply_brightness({255,0,0},p_->b));ps_->show_all_parallel();ps_->step=++step_;return true;
|
||||
}
|
||||
#undef START
|
||||
@@ -0,0 +1,33 @@
|
||||
#pragma once
|
||||
|
||||
#include <cstdint>
|
||||
|
||||
class Presets;
|
||||
class Preset;
|
||||
|
||||
class Pattern {
|
||||
public:
|
||||
virtual ~Pattern() = default;
|
||||
virtual void start(Presets& presets, Preset* preset) = 0;
|
||||
virtual bool tick() = 0;
|
||||
};
|
||||
|
||||
#define DECLARE_PATTERN(name) class name final : public Pattern { public: void start(Presets&, Preset*) override; bool tick() override; private: Presets* ps_ = nullptr; Preset* p_ = nullptr; uint32_t started_ = 0, last_ = 0; int step_ = 0, head_ = 0, tail_ = 0, phase_ = 0; bool drawn_ = false; };
|
||||
DECLARE_PATTERN(Blink)
|
||||
DECLARE_PATTERN(Rainbow)
|
||||
DECLARE_PATTERN(Pulse)
|
||||
DECLARE_PATTERN(Transition)
|
||||
DECLARE_PATTERN(Chase)
|
||||
DECLARE_PATTERN(Circle)
|
||||
DECLARE_PATTERN(Roll)
|
||||
DECLARE_PATTERN(Calibration)
|
||||
DECLARE_PATTERN(Test)
|
||||
DECLARE_PATTERN(Grab)
|
||||
DECLARE_PATTERN(Spin)
|
||||
DECLARE_PATTERN(Lift)
|
||||
DECLARE_PATTERN(Flare)
|
||||
DECLARE_PATTERN(Hook)
|
||||
DECLARE_PATTERN(Pose)
|
||||
DECLARE_PATTERN(Point)
|
||||
DECLARE_PATTERN(ScaleTest)
|
||||
#undef DECLARE_PATTERN
|
||||
+206
@@ -0,0 +1,206 @@
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "httpserver.h"
|
||||
#include "web.h"
|
||||
#include "web_index_html.h"
|
||||
#include "web_main_js.h"
|
||||
#include "web_styles_css.h"
|
||||
#include "flash_store.h"
|
||||
#include "mini_json.h"
|
||||
#include "cmd_queue.h"
|
||||
|
||||
#define WS_MSG_MAX 2048
|
||||
#define JSON_OBJ_MAX 1024
|
||||
|
||||
static httpserver_t *g_http;
|
||||
static char g_buttons_json[FLASH_STORE_MAX];
|
||||
|
||||
static void buttons_load(void) {
|
||||
size_t n = 0;
|
||||
if (!flash_store_load("buttons", g_buttons_json, sizeof(g_buttons_json), &n)) {
|
||||
snprintf(g_buttons_json, sizeof(g_buttons_json), "{\"buttons\":[]}");
|
||||
}
|
||||
}
|
||||
|
||||
static void on_index(httpserver_conn_t *conn, const char *path, const char *query) {
|
||||
(void)path;
|
||||
(void)query;
|
||||
httpserver_send_static(conn, 200, "text/html; charset=utf-8",
|
||||
web_index_html, web_index_html_len, "gzip");
|
||||
}
|
||||
|
||||
static void on_main_js(httpserver_conn_t *conn, const char *path, const char *query) {
|
||||
(void)path;
|
||||
(void)query;
|
||||
httpserver_send_static(conn, 200, "application/javascript; charset=utf-8",
|
||||
web_main_js, web_main_js_len, "gzip");
|
||||
}
|
||||
|
||||
static void on_styles_css(httpserver_conn_t *conn, const char *path, const char *query) {
|
||||
(void)path;
|
||||
(void)query;
|
||||
httpserver_send_static(conn, 200, "text/css; charset=utf-8",
|
||||
web_styles_css, web_styles_css_len, "gzip");
|
||||
}
|
||||
|
||||
static void on_get_buttons(httpserver_conn_t *conn, const char *path, const char *query) {
|
||||
(void)path;
|
||||
(void)query;
|
||||
httpserver_send(conn, 200, "application/json", g_buttons_json, strlen(g_buttons_json));
|
||||
}
|
||||
|
||||
static void on_post_buttons(httpserver_conn_t *conn, const char *path, const char *query) {
|
||||
(void)path;
|
||||
(void)query;
|
||||
size_t len = 0;
|
||||
const char *body = httpserver_request_body(conn, &len);
|
||||
if (!body || len == 0 || len >= sizeof(g_buttons_json)) {
|
||||
httpserver_send(conn, 500, "application/json", "{\"ok\":false}", 12);
|
||||
return;
|
||||
}
|
||||
memcpy(g_buttons_json, body, len);
|
||||
g_buttons_json[len] = '\0';
|
||||
if (!flash_store_save("buttons", g_buttons_json, len)) {
|
||||
httpserver_send(conn, 500, "application/json", "{\"ok\":false,\"error\":\"save failed\"}", 34);
|
||||
return;
|
||||
}
|
||||
httpserver_send(conn, 200, "application/json", "{\"ok\":true}", 11);
|
||||
}
|
||||
|
||||
static void on_ws_open(httpserver_conn_t *ws) {
|
||||
(void)ws;
|
||||
printf("ws: open\n");
|
||||
}
|
||||
|
||||
static void push_select(const char *name) {
|
||||
led_cmd_t cmd;
|
||||
memset(&cmd, 0, sizeof(cmd));
|
||||
cmd.type = CMD_SELECT;
|
||||
snprintf(cmd.name, sizeof(cmd.name), "%s", name);
|
||||
cmd_queue_push(&cmd);
|
||||
}
|
||||
|
||||
static void parse_preset_fields(const char *json, cmd_preset_t *p) {
|
||||
memset(p, 0, sizeof(*p));
|
||||
p->d = 100;
|
||||
p->b = 127;
|
||||
snprintf(p->pattern, sizeof(p->pattern), "off");
|
||||
|
||||
char s[CMD_PATTERN_MAX];
|
||||
if (json_get_string(json, "p", s, sizeof(s))) {
|
||||
snprintf(p->pattern, sizeof(p->pattern), "%s", s);
|
||||
}
|
||||
json_get_int(json, "d", &p->d);
|
||||
json_get_int(json, "b", &p->b);
|
||||
json_get_int(json, "n1", &p->n1);
|
||||
json_get_int(json, "n2", &p->n2);
|
||||
json_get_int(json, "n3", &p->n3);
|
||||
json_get_int(json, "n4", &p->n4);
|
||||
json_get_int(json, "n5", &p->n5);
|
||||
json_get_int(json, "n6", &p->n6);
|
||||
json_get_int(json, "n7", &p->n7);
|
||||
json_get_int(json, "n8", &p->n8);
|
||||
|
||||
uint8_t colors[CMD_COLORS_MAX][3];
|
||||
size_t n = 0;
|
||||
if (json_get_rgb_array(json, "c", colors, CMD_COLORS_MAX, &n) && n > 0) {
|
||||
p->c_count = (uint8_t)n;
|
||||
for (size_t i = 0; i < n; i++) {
|
||||
p->c[i].r = colors[i][0];
|
||||
p->c[i].g = colors[i][1];
|
||||
p->c[i].b = colors[i][2];
|
||||
}
|
||||
} else {
|
||||
p->c_count = 1;
|
||||
p->c[0].r = 255;
|
||||
p->c[0].g = 255;
|
||||
p->c[0].b = 255;
|
||||
}
|
||||
}
|
||||
|
||||
static void on_ws_msg(httpserver_conn_t *ws, const uint8_t *data, size_t len, bool text) {
|
||||
(void)text;
|
||||
char msg[WS_MSG_MAX + 1];
|
||||
if (len >= sizeof(msg)) {
|
||||
len = sizeof(msg) - 1;
|
||||
}
|
||||
memcpy(msg, data, len);
|
||||
msg[len] = '\0';
|
||||
printf("ws: %s\n", msg);
|
||||
|
||||
char name[CMD_NAME_MAX];
|
||||
if (json_get_select_name(msg, name, sizeof(name))) {
|
||||
push_select(name);
|
||||
char out[96];
|
||||
int n = snprintf(out, sizeof(out), "{\"select\":\"%s\"}", name);
|
||||
if (g_http) {
|
||||
httpserver_ws_broadcast(g_http, out, (size_t)n, true);
|
||||
} else {
|
||||
httpserver_ws_send(ws, out, (size_t)n, true);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
char obj[JSON_OBJ_MAX];
|
||||
if (json_get_object(msg, "preset_edit", obj, sizeof(obj))) {
|
||||
led_cmd_t cmd;
|
||||
memset(&cmd, 0, sizeof(cmd));
|
||||
cmd.type = CMD_EDIT;
|
||||
if (!json_get_string(obj, "name", cmd.name, sizeof(cmd.name))) {
|
||||
return;
|
||||
}
|
||||
char data[JSON_OBJ_MAX];
|
||||
if (json_get_object(obj, "data", data, sizeof(data))) {
|
||||
parse_preset_fields(data, &cmd.u.edit);
|
||||
} else {
|
||||
parse_preset_fields(obj, &cmd.u.edit);
|
||||
}
|
||||
cmd_queue_push(&cmd);
|
||||
return;
|
||||
}
|
||||
|
||||
if (json_get_string(msg, "preset_delete", name, sizeof(name))) {
|
||||
led_cmd_t cmd;
|
||||
memset(&cmd, 0, sizeof(cmd));
|
||||
cmd.type = CMD_DELETE;
|
||||
snprintf(cmd.name, sizeof(cmd.name), "%s", name);
|
||||
cmd_queue_push(&cmd);
|
||||
return;
|
||||
}
|
||||
|
||||
bool save = false;
|
||||
if (json_get_bool(msg, "preset_save", &save) && save) {
|
||||
led_cmd_t cmd;
|
||||
memset(&cmd, 0, sizeof(cmd));
|
||||
cmd.type = CMD_SAVE;
|
||||
cmd_queue_push(&cmd);
|
||||
return;
|
||||
}
|
||||
|
||||
int b = 0;
|
||||
if (json_get_int(msg, "b", &b)) {
|
||||
led_cmd_t cmd;
|
||||
memset(&cmd, 0, sizeof(cmd));
|
||||
cmd.type = CMD_BRIGHTNESS;
|
||||
cmd.u.brightness = b;
|
||||
cmd_queue_push(&cmd);
|
||||
}
|
||||
}
|
||||
|
||||
static void on_ws_close(httpserver_conn_t *ws) {
|
||||
(void)ws;
|
||||
printf("ws: close\n");
|
||||
}
|
||||
|
||||
bool web_start(void) {
|
||||
buttons_load();
|
||||
g_http = httpserver_create();
|
||||
httpserver_route(g_http, "GET", "/", on_index);
|
||||
httpserver_route(g_http, "GET", "/static/main.js", on_main_js);
|
||||
httpserver_route(g_http, "GET", "/static/styles.css", on_styles_css);
|
||||
httpserver_route(g_http, "GET", "/api/buttons", on_get_buttons);
|
||||
httpserver_route(g_http, "POST", "/api/buttons", on_post_buttons);
|
||||
httpserver_websocket(g_http, "/ws", on_ws_open, on_ws_msg, on_ws_close);
|
||||
return httpserver_listen(g_http, 80);
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
#ifndef WEB_H
|
||||
#define WEB_H
|
||||
|
||||
#include <stdbool.h>
|
||||
|
||||
bool web_start(void);
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,140 @@
|
||||
<!DOCTYPE html>
|
||||
<html lang="en">
|
||||
<head>
|
||||
<meta charset="UTF-8" />
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
|
||||
<title>Led Hoop</title>
|
||||
<link rel="stylesheet" href="static/styles.css" />
|
||||
</head>
|
||||
<body data-device-id="1">
|
||||
<div class="header">
|
||||
<button class="menu-btn" type="button" onclick="toggleMenu()" aria-label="Menu">☰ Menu</button>
|
||||
<div class="menu" id="menu">
|
||||
<button class="menu-item off" type="button" onclick="sendSelect('off', null); closeMenu();">Off</button>
|
||||
<button class="menu-item" type="button" onclick="sendSelect('test', null); closeMenu();">Test</button>
|
||||
<button class="menu-item" type="button" onclick="sendSelect('calibration', null); closeMenu();">Calibration</button>
|
||||
<button class="menu-item" type="button" onclick="closeMenu(); openNewButtonEditor();">Add button</button>
|
||||
<button class="menu-item" type="button" onclick="closeMenu(); saveCurrentButtons();">Save</button>
|
||||
</div>
|
||||
</div>
|
||||
<div class="buttons" id="buttonsContainer">
|
||||
</div>
|
||||
|
||||
<div class="preset-editor" id="buttonEditor">
|
||||
<div class="preset-editor-inner">
|
||||
<h2 class="preset-editor-title" id="buttonEditorTitle">Button</h2>
|
||||
<label class="preset-editor-field">
|
||||
<span>Button label</span>
|
||||
<input id="be-label" type="text" placeholder="e.g. grab" />
|
||||
</label>
|
||||
<label class="preset-editor-field">
|
||||
<span>Preset name</span>
|
||||
<input id="be-preset" type="text" placeholder="e.g. grab" />
|
||||
</label>
|
||||
<label class="preset-editor-field">
|
||||
<span>Pattern (p)</span>
|
||||
<select id="be-pattern">
|
||||
<option value="spin">spin</option>
|
||||
<option value="roll">roll</option>
|
||||
<option value="grab">grab</option>
|
||||
<option value="lift">lift</option>
|
||||
<option value="flare">flare</option>
|
||||
<option value="hook">hook</option>
|
||||
<option value="invertsplit">invertsplit</option>
|
||||
<option value="pose">pose</option>
|
||||
<option value="backbalance">backbalance</option>
|
||||
<option value="beat">beat</option>
|
||||
<option value="crouch">crouch</option>
|
||||
<option value="backbendsplit">backbendsplit</option>
|
||||
<option value="straddle">straddle</option>
|
||||
<option value="frontbalance">frontbalance</option>
|
||||
<option value="elbowhang">elbowhang</option>
|
||||
<option value="elbowhangspin">elbowhangspin</option>
|
||||
<option value="dismount">dismount</option>
|
||||
<option value="fluff">fluff</option>
|
||||
<option value="elbowhangsplit">elbowhangsplit</option>
|
||||
<option value="invert">invert</option>
|
||||
<option value="backbend">backbend</option>
|
||||
<option value="seat">seat</option>
|
||||
<option value="kneehang">kneehang</option>
|
||||
<option value="legswoop">legswoop</option>
|
||||
<option value="split">split</option>
|
||||
<option value="foothang">foothang</option>
|
||||
<option value="point">point</option>
|
||||
<option value="off">off</option>
|
||||
<option value="on">on</option>
|
||||
<option value="blink">blink</option>
|
||||
<option value="rainbow">rainbow</option>
|
||||
<option value="pulse">pulse</option>
|
||||
<option value="transition">transition</option>
|
||||
<option value="chase">chase</option>
|
||||
<option value="circle">circle</option>
|
||||
<option value="calibration">calibration</option>
|
||||
<option value="test">test</option>
|
||||
</select>
|
||||
</label>
|
||||
<div class="preset-editor-row">
|
||||
<label class="preset-editor-field">
|
||||
<span>Delay (d)</span>
|
||||
<input id="be-delay" type="number" inputmode="numeric" />
|
||||
</label>
|
||||
<label class="preset-editor-field">
|
||||
<span>Brightness (b)</span>
|
||||
<input id="be-brightness" type="number" inputmode="numeric" min="0" max="255" />
|
||||
</label>
|
||||
</div>
|
||||
<label class="preset-editor-field">
|
||||
<span>Colors (c)</span>
|
||||
<input id="be-colors" type="text" placeholder="r,g,b; r,g,b (0–255)" />
|
||||
</label>
|
||||
<div class="preset-editor-row">
|
||||
<label class="preset-editor-field small">
|
||||
<span>n1</span>
|
||||
<input id="be-n1" type="number" inputmode="numeric" />
|
||||
</label>
|
||||
<label class="preset-editor-field small">
|
||||
<span>n2</span>
|
||||
<input id="be-n2" type="number" inputmode="numeric" />
|
||||
</label>
|
||||
</div>
|
||||
<div class="preset-editor-row">
|
||||
<label class="preset-editor-field small">
|
||||
<span>n3</span>
|
||||
<input id="be-n3" type="number" inputmode="numeric" />
|
||||
</label>
|
||||
<label class="preset-editor-field small">
|
||||
<span>n4</span>
|
||||
<input id="be-n4" type="number" inputmode="numeric" />
|
||||
</label>
|
||||
</div>
|
||||
<div class="preset-editor-row">
|
||||
<label class="preset-editor-field small">
|
||||
<span>n5</span>
|
||||
<input id="be-n5" type="number" inputmode="numeric" />
|
||||
</label>
|
||||
<label class="preset-editor-field small">
|
||||
<span>n6</span>
|
||||
<input id="be-n6" type="number" inputmode="numeric" />
|
||||
</label>
|
||||
</div>
|
||||
<div class="preset-editor-row">
|
||||
<label class="preset-editor-field small">
|
||||
<span>n7</span>
|
||||
<input id="be-n7" type="number" inputmode="numeric" />
|
||||
</label>
|
||||
<label class="preset-editor-field small">
|
||||
<span>n8</span>
|
||||
<input id="be-n8" type="number" inputmode="numeric" />
|
||||
</label>
|
||||
</div>
|
||||
<div class="preset-editor-actions">
|
||||
<button type="button" class="preset-editor-btn primary" onclick="saveButtonFromEditor()">Save</button>
|
||||
<button type="button" class="preset-editor-btn" onclick="closeButtonEditor()">Cancel</button>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<button class="next-btn" type="button" onclick="nextPreset()">Next</button>
|
||||
<script src="static/main.js"></script>
|
||||
</body>
|
||||
</html>
|
||||
@@ -0,0 +1,617 @@
|
||||
var deviceId = document.body.getAttribute('data-device-id') || '1';
|
||||
var ws = null;
|
||||
var currentEditIndex = -1; // -1 means "new button"
|
||||
|
||||
function getButtonsFromDom() {
|
||||
var btns = document.querySelectorAll('#buttonsContainer .btn');
|
||||
return Array.prototype.map.call(btns, function (el) {
|
||||
var obj = {
|
||||
id: el.getAttribute('data-id') || el.textContent.trim(),
|
||||
preset: el.getAttribute('data-preset') || ''
|
||||
};
|
||||
var p = el.getAttribute('data-p');
|
||||
if (p) obj.p = p;
|
||||
var d = el.getAttribute('data-d');
|
||||
if (d !== null && d !== '') obj.d = parseInt(d, 10) || 0;
|
||||
var b = el.getAttribute('data-b');
|
||||
if (b !== null && b !== '') obj.b = parseInt(b, 10) || 0;
|
||||
var c = el.getAttribute('data-c');
|
||||
if (c) {
|
||||
try {
|
||||
var parsed = JSON.parse(c);
|
||||
if (Array.isArray(parsed)) obj.c = parsed;
|
||||
} catch (e) {}
|
||||
}
|
||||
for (var i = 1; i <= 8; i++) {
|
||||
var key = 'n' + i;
|
||||
var v = el.getAttribute('data-' + key);
|
||||
if (v !== null && v !== '') {
|
||||
obj[key] = parseInt(v, 10) || 0;
|
||||
}
|
||||
}
|
||||
return obj;
|
||||
});
|
||||
}
|
||||
|
||||
function renderButtons(buttons) {
|
||||
var container = document.getElementById('buttonsContainer');
|
||||
container.innerHTML = '';
|
||||
buttons.forEach(function (btn, idx) {
|
||||
var el = document.createElement('button');
|
||||
el.className = 'btn';
|
||||
el.type = 'button';
|
||||
el.setAttribute('data-preset', btn.preset);
|
||||
el.setAttribute('data-id', btn.id);
|
||||
el.setAttribute('data-index', String(idx));
|
||||
// Optional preset config stored per button
|
||||
if (btn.p !== undefined) el.setAttribute('data-p', btn.p);
|
||||
if (btn.d !== undefined) el.setAttribute('data-d', String(btn.d));
|
||||
if (btn.b !== undefined) el.setAttribute('data-b', String(btn.b));
|
||||
if (btn.c !== undefined) {
|
||||
try {
|
||||
el.setAttribute('data-c', JSON.stringify(btn.c));
|
||||
} catch (e) {}
|
||||
}
|
||||
for (var i = 1; i <= 8; i++) {
|
||||
var key = 'n' + i;
|
||||
if (btn[key] !== undefined) {
|
||||
el.setAttribute('data-' + key, String(btn[key]));
|
||||
}
|
||||
}
|
||||
el.draggable = true;
|
||||
el.textContent = btn.id;
|
||||
container.appendChild(el);
|
||||
});
|
||||
attachButtonListeners();
|
||||
}
|
||||
|
||||
function attachButtonListeners() {
|
||||
var container = document.getElementById('buttonsContainer');
|
||||
if (!container) return;
|
||||
var btns = container.querySelectorAll('.btn');
|
||||
for (var i = 0; i < btns.length; i++) {
|
||||
var el = btns[i];
|
||||
el.setAttribute('data-index', String(i));
|
||||
el.onclick = function(ev) {
|
||||
if (longPressTriggered) {
|
||||
ev.preventDefault();
|
||||
return;
|
||||
}
|
||||
var btn = ev.currentTarget;
|
||||
sendSelect(btn.getAttribute('data-preset'), btn);
|
||||
};
|
||||
el.oncontextmenu = function(ev) {
|
||||
ev.preventDefault();
|
||||
showButtonContextMenu(ev, ev.currentTarget);
|
||||
};
|
||||
(function(buttonEl) {
|
||||
var startX, startY;
|
||||
el.ontouchstart = function(ev) {
|
||||
if (ev.touches.length !== 1) return;
|
||||
longPressTriggered = false;
|
||||
startX = ev.touches[0].clientX;
|
||||
startY = ev.touches[0].clientY;
|
||||
longPressTimer = setTimeout(function() {
|
||||
longPressTimer = null;
|
||||
longPressTriggered = true;
|
||||
showButtonContextMenu({ clientX: startX, clientY: startY }, buttonEl);
|
||||
}, 500);
|
||||
};
|
||||
el.ontouchmove = function(ev) {
|
||||
if (longPressTimer && ev.touches.length === 1) {
|
||||
var dx = ev.touches[0].clientX - startX;
|
||||
var dy = ev.touches[0].clientY - startY;
|
||||
if (dx * dx + dy * dy > 100) {
|
||||
clearTimeout(longPressTimer);
|
||||
longPressTimer = null;
|
||||
}
|
||||
}
|
||||
};
|
||||
el.ontouchend = el.ontouchcancel = function() {
|
||||
if (longPressTimer) {
|
||||
clearTimeout(longPressTimer);
|
||||
longPressTimer = null;
|
||||
}
|
||||
setTimeout(function() { longPressTriggered = false; }, 400);
|
||||
};
|
||||
})(el);
|
||||
el.ondragstart = function(ev) {
|
||||
ev.dataTransfer.setData('text/plain', ev.currentTarget.getAttribute('data-index'));
|
||||
ev.dataTransfer.effectAllowed = 'move';
|
||||
ev.currentTarget.classList.add('dragging');
|
||||
};
|
||||
el.ondragend = function(ev) {
|
||||
ev.currentTarget.classList.remove('dragging');
|
||||
};
|
||||
el.ondragover = function(ev) {
|
||||
ev.preventDefault();
|
||||
ev.dataTransfer.dropEffect = 'move';
|
||||
var target = ev.currentTarget;
|
||||
if (target.classList.contains('dragging')) return;
|
||||
target.classList.add('drop-target');
|
||||
};
|
||||
el.ondragleave = function(ev) {
|
||||
ev.currentTarget.classList.remove('drop-target');
|
||||
};
|
||||
el.ondrop = function(ev) {
|
||||
ev.preventDefault();
|
||||
ev.currentTarget.classList.remove('drop-target');
|
||||
var fromIdx = parseInt(ev.dataTransfer.getData('text/plain'), 10);
|
||||
var toIdx = parseInt(ev.currentTarget.getAttribute('data-index'), 10);
|
||||
if (fromIdx === toIdx) return;
|
||||
var buttons = getButtonsFromDom();
|
||||
var item = buttons.splice(fromIdx, 1)[0];
|
||||
buttons.splice(toIdx, 0, item);
|
||||
renderButtons(buttons);
|
||||
saveButtons(buttons);
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
// Button editor (per-button preset config)
|
||||
|
||||
function saveButtons(buttons, callback) {
|
||||
fetch('/api/buttons', {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ buttons: buttons })
|
||||
}).then(function(r) { return r.json(); }).then(function(data) {
|
||||
if (callback) callback(data);
|
||||
else showToast(data.ok ? 'Saved' : (data.error || 'Save failed'));
|
||||
}).catch(function() {
|
||||
if (callback) callback({ ok: false });
|
||||
else showToast('Save failed');
|
||||
});
|
||||
}
|
||||
|
||||
function saveCurrentButtons() {
|
||||
var buttons = getButtonsFromDom();
|
||||
saveButtons(buttons, function(data) {
|
||||
showToast(data.ok ? 'Saved' : (data.error || 'Save failed'));
|
||||
});
|
||||
}
|
||||
|
||||
var toastTimer = null;
|
||||
|
||||
function showToast(message) {
|
||||
var el = document.getElementById('toast');
|
||||
if (!el) {
|
||||
el = document.createElement('div');
|
||||
el.id = 'toast';
|
||||
el.className = 'toast';
|
||||
document.body.appendChild(el);
|
||||
}
|
||||
el.textContent = message;
|
||||
el.classList.add('toast-visible');
|
||||
if (toastTimer) clearTimeout(toastTimer);
|
||||
toastTimer = setTimeout(function() {
|
||||
el.classList.remove('toast-visible');
|
||||
toastTimer = null;
|
||||
}, 2000);
|
||||
}
|
||||
|
||||
function addButton(button) {
|
||||
var buttons = getButtonsFromDom();
|
||||
buttons.push(button);
|
||||
renderButtons(buttons);
|
||||
saveButtons(buttons);
|
||||
}
|
||||
|
||||
var contextMenuEl = null;
|
||||
var longPressTimer = null;
|
||||
var longPressTriggered = false;
|
||||
|
||||
function openNewButtonEditor() {
|
||||
currentEditIndex = -1;
|
||||
var title = document.getElementById('buttonEditorTitle');
|
||||
if (title) title.textContent = 'New button';
|
||||
fillButtonEditorFields({
|
||||
id: '',
|
||||
preset: '',
|
||||
p: 'off',
|
||||
d: 0,
|
||||
b: 0,
|
||||
c: [[0, 0, 0]]
|
||||
});
|
||||
openButtonEditor();
|
||||
}
|
||||
|
||||
function openExistingButtonEditor(index) {
|
||||
currentEditIndex = index;
|
||||
var buttons = getButtonsFromDom();
|
||||
var btn = buttons[index];
|
||||
var title = document.getElementById('buttonEditorTitle');
|
||||
if (title) title.textContent = 'Edit button';
|
||||
fillButtonEditorFields(btn);
|
||||
openButtonEditor();
|
||||
}
|
||||
|
||||
function openButtonEditor() {
|
||||
var editor = document.getElementById('buttonEditor');
|
||||
if (!editor) return;
|
||||
editor.classList.add('open');
|
||||
document.body.classList.add('button-editor-open');
|
||||
}
|
||||
|
||||
function closeButtonEditor() {
|
||||
var editor = document.getElementById('buttonEditor');
|
||||
if (!editor) return;
|
||||
editor.classList.remove('open');
|
||||
document.body.classList.remove('button-editor-open');
|
||||
}
|
||||
|
||||
function fillButtonEditorFields(btn) {
|
||||
document.getElementById('be-label').value = btn.id || '';
|
||||
document.getElementById('be-preset').value = btn.preset || btn.id || '';
|
||||
var pattern = btn.p || btn.preset || 'off';
|
||||
var patternSelect = document.getElementById('be-pattern');
|
||||
if (patternSelect) {
|
||||
patternSelect.value = pattern;
|
||||
}
|
||||
document.getElementById('be-delay').value = btn.d != null ? String(btn.d) : '';
|
||||
document.getElementById('be-brightness').value = btn.b != null ? String(btn.b) : '';
|
||||
var colors = btn.c;
|
||||
var colorsStr = '';
|
||||
if (Array.isArray(colors) && colors.length) {
|
||||
colorsStr = colors.map(function (rgb) {
|
||||
return (rgb[0] || 0) + ',' + (rgb[1] || 0) + ',' + (rgb[2] || 0);
|
||||
}).join('; ');
|
||||
}
|
||||
document.getElementById('be-colors').value = colorsStr;
|
||||
for (var i = 1; i <= 8; i++) {
|
||||
var key = 'n' + i;
|
||||
var el = document.getElementById('be-' + key);
|
||||
if (el) el.value = btn[key] != null ? String(btn[key]) : '';
|
||||
}
|
||||
}
|
||||
|
||||
function buildButtonFromEditor() {
|
||||
function toInt(val, fallback) {
|
||||
var n = parseInt(val, 10);
|
||||
return isNaN(n) ? fallback : n;
|
||||
}
|
||||
|
||||
var label = (document.getElementById('be-label').value || '').trim();
|
||||
var presetName = (document.getElementById('be-preset').value || '').trim() || label || 'preset';
|
||||
var patternEl = document.getElementById('be-pattern');
|
||||
var pattern = patternEl ? (patternEl.value || '').trim() : 'off';
|
||||
var delayVal = document.getElementById('be-delay').value;
|
||||
var brightVal = document.getElementById('be-brightness').value;
|
||||
var colorsRaw = (document.getElementById('be-colors').value || '').trim();
|
||||
|
||||
var d = toInt(delayVal, 0);
|
||||
var b = toInt(brightVal, 0);
|
||||
|
||||
var colors = [];
|
||||
if (colorsRaw) {
|
||||
colorsRaw.split(';').forEach(function (chunk) {
|
||||
var parts = chunk.split(',').map(function (s) { return s.trim(); }).filter(Boolean);
|
||||
if (parts.length === 3) {
|
||||
var r = toInt(parts[0], 0);
|
||||
var g = toInt(parts[1], 0);
|
||||
var bl = toInt(parts[2], 0);
|
||||
r = Math.max(0, Math.min(255, r));
|
||||
g = Math.max(0, Math.min(255, g));
|
||||
bl = Math.max(0, Math.min(255, bl));
|
||||
colors.push([r, g, bl]);
|
||||
}
|
||||
});
|
||||
}
|
||||
if (!colors.length) colors = [[0, 0, 0]];
|
||||
|
||||
var btn = {
|
||||
id: label || presetName,
|
||||
preset: presetName,
|
||||
p: pattern,
|
||||
d: d,
|
||||
b: b,
|
||||
c: colors
|
||||
};
|
||||
|
||||
for (var i = 1; i <= 8; i++) {
|
||||
var key = 'n' + i;
|
||||
var el = document.getElementById('be-' + key);
|
||||
if (!el) continue;
|
||||
var v = el.value;
|
||||
if (v !== '') {
|
||||
btn[key] = toInt(v, 0);
|
||||
}
|
||||
}
|
||||
|
||||
return btn;
|
||||
}
|
||||
|
||||
function saveButtonFromEditor() {
|
||||
var btn = buildButtonFromEditor();
|
||||
var buttons = getButtonsFromDom();
|
||||
if (currentEditIndex >= 0 && currentEditIndex < buttons.length) {
|
||||
buttons[currentEditIndex] = btn;
|
||||
} else {
|
||||
buttons.push(btn);
|
||||
}
|
||||
renderButtons(buttons);
|
||||
saveButtons(buttons);
|
||||
|
||||
// Also send this preset to the Pico and save it there
|
||||
if (ws && ws.readyState === WebSocket.OPEN && btn.preset) {
|
||||
var presetData = {
|
||||
p: btn.p,
|
||||
d: btn.d,
|
||||
b: btn.b,
|
||||
c: btn.c
|
||||
};
|
||||
for (var i = 1; i <= 8; i++) {
|
||||
var key = 'n' + i;
|
||||
if (btn[key] !== undefined) {
|
||||
presetData[key] = btn[key];
|
||||
}
|
||||
}
|
||||
ws.send(JSON.stringify({
|
||||
preset_edit: {
|
||||
name: btn.preset,
|
||||
data: presetData
|
||||
}
|
||||
}));
|
||||
ws.send(JSON.stringify({ preset_save: true }));
|
||||
}
|
||||
|
||||
closeButtonEditor();
|
||||
}
|
||||
|
||||
function showButtonContextMenu(evOrCoords, buttonEl) {
|
||||
hideContextMenu();
|
||||
var x = evOrCoords.clientX != null ? evOrCoords.clientX : evOrCoords.x;
|
||||
var y = evOrCoords.clientY != null ? evOrCoords.clientY : evOrCoords.y;
|
||||
var buttons = getButtonsFromDom();
|
||||
var idx = parseInt(buttonEl.getAttribute('data-index'), 10);
|
||||
var btn = buttons[idx];
|
||||
contextMenuEl = document.createElement('div');
|
||||
contextMenuEl.className = 'context-menu';
|
||||
contextMenuEl.style.left = x + 'px';
|
||||
contextMenuEl.style.top = y + 'px';
|
||||
contextMenuEl.innerHTML = '<button type="button" class="context-menu-item" data-action="edit">Edit</button><button type="button" class="context-menu-item" data-action="delete">Delete</button>';
|
||||
document.body.appendChild(contextMenuEl);
|
||||
document.addEventListener('click', hideContextMenuOnce);
|
||||
contextMenuEl.querySelector('[data-action="edit"]').onclick = function() {
|
||||
hideContextMenu();
|
||||
openExistingButtonEditor(idx);
|
||||
};
|
||||
contextMenuEl.querySelector('[data-action="delete"]').onclick = function() {
|
||||
hideContextMenu();
|
||||
buttons.splice(idx, 1);
|
||||
renderButtons(buttons);
|
||||
saveButtons(buttons);
|
||||
};
|
||||
}
|
||||
|
||||
function hideContextMenu() {
|
||||
if (contextMenuEl && contextMenuEl.parentNode) contextMenuEl.parentNode.removeChild(contextMenuEl);
|
||||
contextMenuEl = null;
|
||||
document.removeEventListener('click', hideContextMenuOnce);
|
||||
}
|
||||
|
||||
function hideContextMenuOnce() {
|
||||
hideContextMenu();
|
||||
}
|
||||
|
||||
function connect() {
|
||||
var proto = location.protocol === "https:" ? "wss:" : "ws:";
|
||||
ws = new WebSocket(proto + "//" + location.host + "/ws");
|
||||
ws.onclose = function() { setTimeout(connect, 2000); };
|
||||
ws.onmessage = function(ev) {
|
||||
try {
|
||||
var msg = JSON.parse(ev.data);
|
||||
if (msg && msg.select != null) {
|
||||
var preset = typeof msg.select === 'string' ? msg.select : (Array.isArray(msg.select) ? msg.select[1] : null);
|
||||
if (preset != null) {
|
||||
document.querySelectorAll('.buttons .btn').forEach(function(b) { b.classList.remove('selected'); });
|
||||
if (preset !== 'off') {
|
||||
var el = document.querySelector('.buttons .btn[data-preset="' + preset + '"]');
|
||||
if (el) {
|
||||
el.classList.add('selected');
|
||||
scrollSelectedIntoView();
|
||||
updateSelectedObserver();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
} catch (e) {}
|
||||
};
|
||||
}
|
||||
|
||||
function sendSelect(preset, el) {
|
||||
var msg = JSON.stringify({ select: preset });
|
||||
if (ws && ws.readyState === WebSocket.OPEN) ws.send(msg);
|
||||
document.querySelectorAll('.buttons .btn').forEach(function(b) { b.classList.remove('selected'); });
|
||||
if (el) el.classList.add('selected');
|
||||
updateSelectedObserver();
|
||||
}
|
||||
|
||||
function togglePresetEditor() {
|
||||
var editor = document.getElementById('presetEditor');
|
||||
if (!editor) return;
|
||||
var isOpen = editor.classList.contains('open');
|
||||
if (isOpen) {
|
||||
editor.classList.remove('open');
|
||||
document.body.classList.remove('preset-editor-open');
|
||||
} else {
|
||||
editor.classList.add('open');
|
||||
document.body.classList.add('preset-editor-open');
|
||||
}
|
||||
}
|
||||
|
||||
function buildPresetPayloadFromForm() {
|
||||
var name = (document.getElementById('pe-name').value || '').trim();
|
||||
var patternEl = document.getElementById('pe-pattern');
|
||||
var pattern = patternEl ? (patternEl.value || '').trim() : 'off';
|
||||
var delayVal = document.getElementById('pe-delay').value;
|
||||
var brightVal = document.getElementById('pe-brightness').value;
|
||||
var colorsRaw = (document.getElementById('pe-colors').value || '').trim();
|
||||
|
||||
function toInt(val, fallback) {
|
||||
var n = parseInt(val, 10);
|
||||
return isNaN(n) ? fallback : n;
|
||||
}
|
||||
|
||||
var d = toInt(delayVal, 0);
|
||||
var b = toInt(brightVal, 0);
|
||||
|
||||
var colors = [];
|
||||
if (colorsRaw) {
|
||||
colorsRaw.split(';').forEach(function (chunk) {
|
||||
var parts = chunk.split(',').map(function (s) { return s.trim(); }).filter(Boolean);
|
||||
if (parts.length === 3) {
|
||||
var r = toInt(parts[0], 0);
|
||||
var g = toInt(parts[1], 0);
|
||||
var bl = toInt(parts[2], 0);
|
||||
r = Math.max(0, Math.min(255, r));
|
||||
g = Math.max(0, Math.min(255, g));
|
||||
bl = Math.max(0, Math.min(255, bl));
|
||||
colors.push([r, g, bl]);
|
||||
}
|
||||
});
|
||||
}
|
||||
if (!colors.length) colors = [[0, 0, 0]];
|
||||
|
||||
var data = { p: pattern, d: d, b: b, c: colors };
|
||||
|
||||
['n1', 'n2', 'n3', 'n4', 'n5', 'n6', 'n7', 'n8'].forEach(function (key) {
|
||||
var el = document.getElementById('pe-' + key);
|
||||
if (!el) return;
|
||||
var v = el.value;
|
||||
if (v !== '') {
|
||||
data[key] = toInt(v, 0);
|
||||
}
|
||||
});
|
||||
|
||||
return { name: name, data: data };
|
||||
}
|
||||
|
||||
function sendPresetToPico() {
|
||||
var payload = buildPresetPayloadFromForm();
|
||||
if (!payload.name) {
|
||||
showToast('Preset name is required');
|
||||
return;
|
||||
}
|
||||
if (ws && ws.readyState === WebSocket.OPEN) {
|
||||
ws.send(JSON.stringify({ preset_edit: payload }));
|
||||
ensurePresetInList(payload.name);
|
||||
showToast('Preset sent (not yet saved)');
|
||||
} else {
|
||||
showToast('Not connected');
|
||||
}
|
||||
}
|
||||
|
||||
function savePresetsOnPico() {
|
||||
var payload = buildPresetPayloadFromForm();
|
||||
if (!payload.name) {
|
||||
showToast('Preset name is required');
|
||||
return;
|
||||
}
|
||||
if (ws && ws.readyState === WebSocket.OPEN) {
|
||||
ws.send(JSON.stringify({ preset_edit: payload }));
|
||||
ws.send(JSON.stringify({ preset_save: true }));
|
||||
ensurePresetInList(payload.name);
|
||||
showToast('Preset saved to Pico');
|
||||
} else {
|
||||
showToast('Not connected');
|
||||
}
|
||||
}
|
||||
|
||||
function deletePresetOnPico() {
|
||||
var name = (document.getElementById('pe-name').value || '').trim();
|
||||
if (!name) {
|
||||
showToast('Preset name is required');
|
||||
return;
|
||||
}
|
||||
var msg = { preset_delete: name };
|
||||
if (ws && ws.readyState === WebSocket.OPEN) {
|
||||
ws.send(JSON.stringify(msg));
|
||||
removePresetFromList(name);
|
||||
ws.send(JSON.stringify(msg));
|
||||
showToast('Delete command sent');
|
||||
} else {
|
||||
showToast('Not connected');
|
||||
}
|
||||
}
|
||||
|
||||
function toggleMenu() {
|
||||
var menu = document.getElementById('menu');
|
||||
menu.classList.toggle('open');
|
||||
}
|
||||
|
||||
function closeMenu() {
|
||||
document.getElementById('menu').classList.remove('open');
|
||||
}
|
||||
|
||||
document.addEventListener('click', function(ev) {
|
||||
var menu = document.getElementById('menu');
|
||||
var menuBtn = document.querySelector('.menu-btn');
|
||||
if (menu.classList.contains('open') && menuBtn && !menu.contains(ev.target) && !menuBtn.contains(ev.target)) {
|
||||
closeMenu();
|
||||
}
|
||||
});
|
||||
|
||||
function scrollSelectedIntoView() {
|
||||
var el = document.querySelector('.buttons .btn.selected');
|
||||
if (el) el.scrollIntoView({ behavior: 'smooth', block: 'nearest', inline: 'nearest' });
|
||||
}
|
||||
|
||||
var scrollObserver = null;
|
||||
var observedSelectedEl = null;
|
||||
|
||||
function setupScrollObserver() {
|
||||
var container = document.getElementById('buttonsContainer');
|
||||
if (!container || scrollObserver) return;
|
||||
scrollObserver = new IntersectionObserver(
|
||||
function (entries) {
|
||||
entries.forEach(function (entry) {
|
||||
if (entry.intersectionRatio < 0.5 && entry.target.classList.contains('selected')) {
|
||||
scrollSelectedIntoView();
|
||||
}
|
||||
});
|
||||
},
|
||||
{ root: container, rootMargin: '0px', threshold: [0, 0.25, 0.5, 0.75, 1] }
|
||||
);
|
||||
}
|
||||
|
||||
function updateSelectedObserver() {
|
||||
var el = document.querySelector('.buttons .btn.selected');
|
||||
if (el === observedSelectedEl) return;
|
||||
if (scrollObserver) {
|
||||
if (observedSelectedEl) scrollObserver.unobserve(observedSelectedEl);
|
||||
observedSelectedEl = el;
|
||||
if (el) {
|
||||
setupScrollObserver();
|
||||
scrollObserver.observe(el);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function nextPreset() {
|
||||
var btns = document.querySelectorAll('.buttons .btn');
|
||||
if (btns.length === 0) return;
|
||||
var idx = -1;
|
||||
for (var i = 0; i < btns.length; i++) {
|
||||
if (btns[i].classList.contains('selected')) { idx = i; break; }
|
||||
}
|
||||
idx = (idx + 1) % btns.length;
|
||||
var nextEl = btns[idx];
|
||||
sendSelect(nextEl.getAttribute('data-preset'), nextEl);
|
||||
scrollSelectedIntoView();
|
||||
}
|
||||
|
||||
setupScrollObserver();
|
||||
// Re-render buttons from server config (including per-button presets) once loaded.
|
||||
fetch('/api/buttons')
|
||||
.then(function (r) { return r.json(); })
|
||||
.then(function (data) {
|
||||
var buttons = Array.isArray(data.buttons) ? data.buttons : getButtonsFromDom();
|
||||
renderButtons(buttons);
|
||||
})
|
||||
.catch(function () {
|
||||
// Fallback: use buttons rendered by the template
|
||||
renderButtons(getButtonsFromDom());
|
||||
});
|
||||
updateSelectedObserver();
|
||||
connect();
|
||||
@@ -0,0 +1,256 @@
|
||||
body { font-family: sans-serif; margin: 0; padding: 0 0 6.5rem 0; }
|
||||
|
||||
body.button-editor-open {
|
||||
overflow: hidden;
|
||||
}
|
||||
|
||||
.header { position: relative; }
|
||||
|
||||
.menu-btn {
|
||||
width: 100%;
|
||||
padding: 0.75rem 1rem;
|
||||
font-size: 1rem;
|
||||
cursor: pointer;
|
||||
border: 1px solid #555;
|
||||
border-radius: 0;
|
||||
background: #333;
|
||||
color: #fff;
|
||||
text-align: left;
|
||||
}
|
||||
|
||||
.menu {
|
||||
display: none;
|
||||
position: absolute;
|
||||
top: 100%;
|
||||
left: 0;
|
||||
right: 0;
|
||||
z-index: 10;
|
||||
flex-direction: column;
|
||||
border: 1px solid #555;
|
||||
border-top: none;
|
||||
background: #2a2a2a;
|
||||
box-shadow: 0 4px 8px rgba(0,0,0,0.3);
|
||||
}
|
||||
|
||||
.menu.open { display: flex; }
|
||||
|
||||
.menu-item {
|
||||
padding: 0.75rem 1rem;
|
||||
font-size: 1rem;
|
||||
cursor: pointer;
|
||||
border: none;
|
||||
border-bottom: 1px solid #444;
|
||||
background: transparent;
|
||||
color: #fff;
|
||||
text-align: left;
|
||||
}
|
||||
|
||||
.menu-item:last-child { border-bottom: none; }
|
||||
|
||||
.menu-item:hover { background: #444; }
|
||||
|
||||
.menu-item.off { background: #522; }
|
||||
|
||||
.buttons {
|
||||
display: grid;
|
||||
grid-template-columns: repeat(3, 1fr);
|
||||
gap: 1px;
|
||||
max-height: calc(100vh - 10rem);
|
||||
overflow-y: auto;
|
||||
-webkit-overflow-scrolling: touch;
|
||||
}
|
||||
|
||||
@media (min-width: 768px) {
|
||||
.buttons {
|
||||
grid-template-columns: repeat(6, 1fr);
|
||||
}
|
||||
}
|
||||
.btn {
|
||||
padding: 0.5rem 0.25rem;
|
||||
border: 1px solid #555;
|
||||
border-radius: 0;
|
||||
background: #444;
|
||||
color: #fff;
|
||||
font-size: 1rem;
|
||||
cursor: pointer;
|
||||
min-height: 4.15rem;
|
||||
}
|
||||
.btn.selected {
|
||||
background: #2a7;
|
||||
border-color: #3b8;
|
||||
}
|
||||
|
||||
.btn.dragging { opacity: 0.5; }
|
||||
|
||||
.btn.drop-target { outline: 2px solid #3b8; outline-offset: -2px; }
|
||||
|
||||
.context-menu {
|
||||
position: fixed;
|
||||
z-index: 100;
|
||||
background: #2a2a2a;
|
||||
border: 1px solid #555;
|
||||
box-shadow: 0 4px 12px rgba(0,0,0,0.4);
|
||||
min-width: 8rem;
|
||||
}
|
||||
|
||||
.context-menu-item {
|
||||
display: block;
|
||||
width: 100%;
|
||||
padding: 0.5rem 1rem;
|
||||
border: none;
|
||||
background: transparent;
|
||||
color: #fff;
|
||||
font-size: 1rem;
|
||||
text-align: left;
|
||||
cursor: pointer;
|
||||
}
|
||||
|
||||
.context-menu-item:hover { background: #444; }
|
||||
|
||||
.toast {
|
||||
position: fixed;
|
||||
bottom: 5rem;
|
||||
left: 50%;
|
||||
transform: translateX(-50%) translateY(2rem);
|
||||
padding: 0.5rem 1rem;
|
||||
background: #333;
|
||||
color: #fff;
|
||||
border-radius: 4px;
|
||||
font-size: 0.9rem;
|
||||
z-index: 1000;
|
||||
opacity: 0;
|
||||
transition: opacity 0.2s, transform 0.2s;
|
||||
pointer-events: none;
|
||||
}
|
||||
|
||||
.toast.toast-visible {
|
||||
opacity: 1;
|
||||
transform: translateX(-50%) translateY(0);
|
||||
}
|
||||
.next-btn {
|
||||
position: fixed;
|
||||
bottom: 0;
|
||||
left: 0;
|
||||
right: 0;
|
||||
width: 100%;
|
||||
padding: 2rem 1rem;
|
||||
padding-bottom: max(2rem, env(safe-area-inset-bottom));
|
||||
font-size: 1.25rem;
|
||||
cursor: pointer;
|
||||
border: 2px solid #555;
|
||||
border-radius: 0;
|
||||
background: #333;
|
||||
color: #fff;
|
||||
}
|
||||
|
||||
.preset-editor {
|
||||
position: fixed;
|
||||
inset: 0;
|
||||
background: rgba(0, 0, 0, 0.65);
|
||||
display: none;
|
||||
align-items: center;
|
||||
justify-content: center;
|
||||
z-index: 200;
|
||||
padding: 1rem;
|
||||
}
|
||||
|
||||
.preset-editor.open {
|
||||
display: flex;
|
||||
}
|
||||
|
||||
.preset-editor-inner {
|
||||
width: 100%;
|
||||
max-width: 28rem;
|
||||
max-height: calc(100vh - 4rem);
|
||||
overflow-y: auto;
|
||||
background: #222;
|
||||
border: 1px solid #555;
|
||||
box-shadow: 0 6px 16px rgba(0, 0, 0, 0.6);
|
||||
border-radius: 6px;
|
||||
padding: 1rem 1.25rem 0.75rem;
|
||||
box-sizing: border-box;
|
||||
}
|
||||
|
||||
.preset-editor-title {
|
||||
margin: 0 0 0.75rem;
|
||||
font-size: 1.25rem;
|
||||
color: #fff;
|
||||
}
|
||||
|
||||
.preset-editor-field {
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
margin-bottom: 0.5rem;
|
||||
gap: 0.25rem;
|
||||
font-size: 0.9rem;
|
||||
color: #ddd;
|
||||
}
|
||||
|
||||
.preset-editor-field span {
|
||||
opacity: 0.85;
|
||||
}
|
||||
|
||||
.preset-editor-field input {
|
||||
padding: 0.35rem 0.5rem;
|
||||
border-radius: 4px;
|
||||
border: 1px solid #555;
|
||||
background: #111;
|
||||
color: #fff;
|
||||
font-size: 0.95rem;
|
||||
}
|
||||
|
||||
.preset-editor-row {
|
||||
display: flex;
|
||||
gap: 0.5rem;
|
||||
}
|
||||
|
||||
.preset-editor-field.small {
|
||||
flex: 0 0 48%;
|
||||
}
|
||||
|
||||
.preset-editor-field.small input {
|
||||
padding: 0.25rem 0.4rem;
|
||||
font-size: 0.85rem;
|
||||
}
|
||||
|
||||
.preset-editor-actions {
|
||||
display: flex;
|
||||
flex-wrap: wrap;
|
||||
gap: 0.5rem;
|
||||
margin: 0.75rem 0 0.5rem;
|
||||
}
|
||||
|
||||
.preset-editor-btn {
|
||||
flex: 1;
|
||||
padding: 0.5rem 0.75rem;
|
||||
border-radius: 4px;
|
||||
border: 1px solid #555;
|
||||
background: #333;
|
||||
color: #fff;
|
||||
font-size: 0.95rem;
|
||||
cursor: pointer;
|
||||
}
|
||||
|
||||
.preset-editor-btn.primary {
|
||||
background: #2a7;
|
||||
border-color: #3b8;
|
||||
}
|
||||
|
||||
.preset-editor-btn.danger {
|
||||
background: #722;
|
||||
border-color: #a33;
|
||||
}
|
||||
|
||||
.preset-editor-close {
|
||||
width: 100%;
|
||||
margin-top: 0.25rem;
|
||||
padding: 0.4rem 0.75rem;
|
||||
border-radius: 4px;
|
||||
border: 1px solid #555;
|
||||
background: #111;
|
||||
color: #ccc;
|
||||
font-size: 0.9rem;
|
||||
cursor: pointer;
|
||||
}
|
||||
|
||||
/* preset-list removed with old preset editor */
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 44 KiB |
@@ -0,0 +1,243 @@
|
||||
// Pico enclosure that saddles a 25mm hoop bar (900mm hoop diameter).
|
||||
// OpenSCAD 2021+: F5 preview, F6 render, export STL.
|
||||
//
|
||||
// Prints as body + lid. Clip onto the bar, secure with zip-ties through the
|
||||
// saddle slots. Lid snaps into the bay rim.
|
||||
//
|
||||
// Frame: bar centre at origin, +Z away from hoop centre, +Y along hoop,
|
||||
// +X across the bar.
|
||||
|
||||
/* [Hoop] */
|
||||
// hoop_diameter kept for reference / future curved saddle (~0.9mm sag over 58mm)
|
||||
hoop_diameter = 900; // tube centerline diameter (mm)
|
||||
bar_diameter = 25; // bar / tube OD (mm)
|
||||
bar_clearance = 0.35; // radial slip around the bar
|
||||
|
||||
/* [Pico bay] */
|
||||
pico_length = 52.5; // clearance along hoop
|
||||
pico_width = 22.0; // clearance across bar
|
||||
pico_height = 12.0; // board + headers / wiring
|
||||
wall = 2.0;
|
||||
lid_thick = 2.0;
|
||||
lid_lip = 1.4;
|
||||
lid_clear = 0.3;
|
||||
|
||||
/* [Saddle / clamp] */
|
||||
saddle_wrap_deg = 230; // >180 so it snaps onto the bar
|
||||
saddle_wall = 2.6;
|
||||
saddle_length = 58; // along hoop (mm)
|
||||
ziptie_w = 3.8;
|
||||
ziptie_h = 2.0;
|
||||
ziptie_inset = 9; // from each saddle end toward centre
|
||||
ear_len = 7; // zip-tie ears sticking out each side
|
||||
ear_thick = 3;
|
||||
|
||||
/* [Ports / access] */
|
||||
// Pico USB end faces +Y. Board is centred on the bay; hole centres are
|
||||
// 2mm in from each short edge of the 51mm PCB.
|
||||
board_length = 51.0;
|
||||
board_width = 21.0;
|
||||
board_thick = 1.0;
|
||||
|
||||
// Micro-USB B cutout (plug clearance)
|
||||
usb_w = 9.0;
|
||||
usb_h = 4.2;
|
||||
usb_z_above_board = 0.2; // opening starts just above PCB top
|
||||
|
||||
// Power-out cable (opposite USB, -Y end) — LED / battery feed
|
||||
power_hole_d = 6.0;
|
||||
|
||||
// BOOTSEL through lid (from USB-end PCB edge / board centre)
|
||||
// Measured from Pico mechanical layout: ~5.7mm from USB edge, ~4.8mm left of centre.
|
||||
bootsel_from_usb_edge = 5.7;
|
||||
bootsel_x = -4.8; // -X when USB is at +Y
|
||||
bootsel_hole_d = 4.5;
|
||||
|
||||
/* [Pico mounting posts] */
|
||||
// Official Pico hole centres: 47.0 x 11.4 mm
|
||||
hole_span_l = 47.0;
|
||||
hole_span_w = 11.4;
|
||||
post_od = 4.2;
|
||||
post_id = 1.7; // M2 self-tap
|
||||
post_h = 3.0;
|
||||
|
||||
/* [Quality] */
|
||||
$fn = 80;
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
bar_r = bar_diameter / 2;
|
||||
saddle_ir = bar_r + bar_clearance;
|
||||
saddle_or = saddle_ir + saddle_wall;
|
||||
|
||||
bay_inner_l = pico_length;
|
||||
bay_inner_w = pico_width;
|
||||
bay_inner_h = pico_height;
|
||||
bay_outer_l = bay_inner_l + 2 * wall;
|
||||
bay_outer_w = max(bay_inner_w + 2 * wall, 2 * saddle_or + 1);
|
||||
bay_outer_h = bay_inner_h + wall;
|
||||
bay_floor_z = saddle_or;
|
||||
|
||||
// 2D clip profile in the plane normal to the bar (X = across, Y = up).
|
||||
module saddle_profile() {
|
||||
wrap = saddle_wrap_deg;
|
||||
// Keep the top half solid (shoulders under the bay) and a partial ring below.
|
||||
difference() {
|
||||
union() {
|
||||
// outer disc, then cut to wrap angle from the bottom
|
||||
circle(r = saddle_or);
|
||||
// rectangular shoulders up to bay floor
|
||||
translate([-saddle_or, 0])
|
||||
square([2 * saddle_or, saddle_or + 0.01]);
|
||||
}
|
||||
circle(r = saddle_ir);
|
||||
// remove the open sector at the bottom (clip mouth)
|
||||
half_gap = (360 - wrap) / 2;
|
||||
rotate(-(90 + wrap / 2))
|
||||
pie_slice(saddle_or + 1, 360 - wrap);
|
||||
}
|
||||
}
|
||||
|
||||
module pie_slice(r, ang) {
|
||||
// Triangle fan covering `ang` degrees starting at +X, CCW.
|
||||
steps = max(3, ceil(ang / 4));
|
||||
polygon(concat([[0, 0]],
|
||||
[for (i = [0:steps]) [r * cos(i * ang / steps), r * sin(i * ang / steps)]]));
|
||||
}
|
||||
|
||||
module pico_posts() {
|
||||
for (x = [-hole_span_w / 2, hole_span_w / 2])
|
||||
for (y = [-hole_span_l / 2, hole_span_l / 2])
|
||||
translate([x, y, 0])
|
||||
difference() {
|
||||
cylinder(h = post_h, d = post_od);
|
||||
translate([0, 0, -0.05])
|
||||
cylinder(h = post_h + 0.1, d = post_id, $fn = 20);
|
||||
}
|
||||
}
|
||||
|
||||
module body() {
|
||||
// USB opening bottom (board sits on standoffs)
|
||||
usb_z = bay_floor_z + wall + post_h + board_thick + usb_z_above_board;
|
||||
|
||||
difference() {
|
||||
union() {
|
||||
// Saddle — extruded along the bar (+Y). Hoop curvature over 58mm is
|
||||
// ~0.9mm sag; ignored so the part prints and clips simply.
|
||||
translate([0, saddle_length / 2, 0])
|
||||
rotate([90, 0, 0])
|
||||
linear_extrude(height = saddle_length, convexity = 8)
|
||||
saddle_profile();
|
||||
|
||||
// Electronics bay on top of the saddle
|
||||
translate([-bay_outer_w / 2, -bay_outer_l / 2, bay_floor_z])
|
||||
cube([bay_outer_w, bay_outer_l, bay_outer_h]);
|
||||
}
|
||||
|
||||
// Bay cavity
|
||||
translate([-bay_inner_w / 2, -bay_inner_l / 2, bay_floor_z + wall])
|
||||
cube([bay_inner_w, bay_inner_l, bay_inner_h + 0.2]);
|
||||
|
||||
// Lid ledge
|
||||
translate([
|
||||
-(bay_inner_w + 2 * lid_lip) / 2,
|
||||
-(bay_inner_l + 2 * lid_lip) / 2,
|
||||
bay_floor_z + bay_outer_h - lid_thick
|
||||
])
|
||||
cube([
|
||||
bay_inner_w + 2 * lid_lip,
|
||||
bay_inner_l + 2 * lid_lip,
|
||||
lid_thick + 0.15
|
||||
]);
|
||||
|
||||
// USB cutout — +Y end, height matches board on standoffs
|
||||
translate([0, bay_outer_l / 2 - wall / 2, usb_z + usb_h / 2])
|
||||
cube([usb_w, wall + 2, usb_h], center = true);
|
||||
|
||||
// Power-out hole — −Y end (opposite USB), for LED / battery wires
|
||||
translate([
|
||||
0,
|
||||
-(bay_outer_l / 2 - wall / 2),
|
||||
bay_floor_z + wall + power_hole_d / 2 + 1
|
||||
])
|
||||
rotate([90, 0, 0])
|
||||
cylinder(h = wall + 2, d = power_hole_d, center = true);
|
||||
|
||||
// Ensure bar bore is clear through the whole saddle
|
||||
rotate([90, 0, 0])
|
||||
cylinder(h = saddle_length + 2, r = saddle_ir, center = true);
|
||||
}
|
||||
|
||||
// Zip-tie ears on both sides — strap goes around bar + saddle
|
||||
for (sx = [-1, 1])
|
||||
translate([sx * (saddle_or + ear_len / 2 - 1.2), 0, -ear_thick / 2])
|
||||
difference() {
|
||||
cube([ear_len + 2.4, saddle_length - 2 * ziptie_inset + ziptie_w, ear_thick], center = true);
|
||||
// don't fill the bar bore
|
||||
rotate([90, 0, 0])
|
||||
cylinder(h = saddle_length, r = saddle_ir, center = true);
|
||||
for (sy = [-1, 1])
|
||||
translate([0, sy * (saddle_length / 2 - ziptie_inset), 0])
|
||||
cube([ear_len + 4, ziptie_w, ziptie_h], center = true);
|
||||
}
|
||||
|
||||
// Board standoffs
|
||||
translate([0, 0, bay_floor_z + wall])
|
||||
pico_posts();
|
||||
|
||||
// Lid retention nubs
|
||||
nub_z = bay_floor_z + bay_outer_h - lid_thick - 1.0;
|
||||
for (x = [-1, 1])
|
||||
translate([x * (bay_inner_w / 2 - 0.25), 0, nub_z])
|
||||
rotate([90, 0, 0])
|
||||
cylinder(h = 8, d = 1.5, center = true, $fn = 16);
|
||||
}
|
||||
|
||||
module lid() {
|
||||
outer_l = bay_inner_l + 2 * lid_lip - lid_clear;
|
||||
outer_w = bay_inner_w + 2 * lid_lip - lid_clear;
|
||||
inner_l = bay_inner_l - lid_clear;
|
||||
inner_w = bay_inner_w - lid_clear;
|
||||
|
||||
// BOOTSEL in body frame: USB end at +Y. Lid shares the same XY origin.
|
||||
bootsel_y = board_length / 2 - bootsel_from_usb_edge;
|
||||
|
||||
difference() {
|
||||
union() {
|
||||
translate([-outer_w / 2, -outer_l / 2, 0])
|
||||
cube([outer_w, outer_l, lid_thick]);
|
||||
translate([-inner_w / 2, -inner_l / 2, -lid_lip])
|
||||
cube([inner_w, inner_l, lid_lip]);
|
||||
}
|
||||
// BOOTSEL access (finger / pen)
|
||||
translate([bootsel_x, bootsel_y, -lid_lip - 0.5])
|
||||
cylinder(h = lid_thick + lid_lip + 1, d = bootsel_hole_d, $fn = 32);
|
||||
// Nail notch on USB end
|
||||
translate([0, outer_l / 2 - 0.5, lid_thick / 2])
|
||||
rotate([0, 90, 0])
|
||||
cylinder(h = 14, d = 3.2, center = true, $fn = 24);
|
||||
// Snap recesses matching body nubs
|
||||
for (x = [-1, 1])
|
||||
translate([x * (inner_w / 2 - 0.15), 0, -0.6])
|
||||
rotate([90, 0, 0])
|
||||
cylinder(h = 9, d = 1.7, center = true, $fn = 16);
|
||||
}
|
||||
}
|
||||
|
||||
module print_layout() {
|
||||
body();
|
||||
translate([bay_outer_w + 14, 0, lid_thick])
|
||||
rotate([0, 180, 0])
|
||||
lid();
|
||||
}
|
||||
|
||||
module preview_on_bar() {
|
||||
body();
|
||||
translate([0, 0, bay_floor_z + bay_outer_h - lid_thick])
|
||||
color("steelblue", 0.7) lid();
|
||||
color("silver", 0.35)
|
||||
rotate([90, 0, 0])
|
||||
cylinder(h = 90, d = bar_diameter, center = true);
|
||||
}
|
||||
|
||||
print_layout();
|
||||
// preview_on_bar();
|
||||
+19014
File diff suppressed because it is too large.
Load diff
Binary file not shown.
|
After Width: | Height: | Size: 41 KiB |
@@ -0,0 +1,2 @@
|
||||
from microdot.microdot import Microdot, Request, Response, abort, redirect, \
|
||||
send_file # noqa: F401
|
||||
@@ -0,0 +1,8 @@
|
||||
try:
|
||||
from functools import wraps
|
||||
except ImportError: # pragma: no cover
|
||||
# MicroPython does not currently implement functools.wraps
|
||||
def wraps(wrapped):
|
||||
def _(wrapper):
|
||||
return wrapper
|
||||
return _
|
||||
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,70 @@
|
||||
from utemplate import recompile
|
||||
|
||||
_loader = None
|
||||
|
||||
|
||||
class Template:
|
||||
"""A template object.
|
||||
|
||||
:param template: The filename of the template to render, relative to the
|
||||
configured template directory.
|
||||
"""
|
||||
@classmethod
|
||||
def initialize(cls, template_dir='templates',
|
||||
loader_class=recompile.Loader):
|
||||
"""Initialize the templating subsystem.
|
||||
|
||||
:param template_dir: the directory where templates are stored. This
|
||||
argument is optional. The default is to load
|
||||
templates from a *templates* subdirectory.
|
||||
:param loader_class: the ``utemplate.Loader`` class to use when loading
|
||||
templates. This argument is optional. The default
|
||||
is the ``recompile.Loader`` class, which
|
||||
automatically recompiles templates when they
|
||||
change.
|
||||
"""
|
||||
global _loader
|
||||
_loader = loader_class(None, template_dir)
|
||||
|
||||
def __init__(self, template):
|
||||
if _loader is None: # pragma: no cover
|
||||
self.initialize()
|
||||
#: The name of the template
|
||||
self.name = template
|
||||
self.template = _loader.load(template)
|
||||
|
||||
def generate(self, *args, **kwargs):
|
||||
"""Return a generator that renders the template in chunks, with the
|
||||
given arguments."""
|
||||
return self.template(*args, **kwargs)
|
||||
|
||||
def render(self, *args, **kwargs):
|
||||
"""Render the template with the given arguments and return it as a
|
||||
string."""
|
||||
return ''.join(self.generate(*args, **kwargs))
|
||||
|
||||
def generate_async(self, *args, **kwargs):
|
||||
"""Return an asynchronous generator that renders the template in
|
||||
chunks, using the given arguments."""
|
||||
class sync_to_async_iter():
|
||||
def __init__(self, iter):
|
||||
self.iter = iter
|
||||
|
||||
def __aiter__(self):
|
||||
return self
|
||||
|
||||
async def __anext__(self):
|
||||
try:
|
||||
return next(self.iter)
|
||||
except StopIteration:
|
||||
raise StopAsyncIteration
|
||||
|
||||
return sync_to_async_iter(self.generate(*args, **kwargs))
|
||||
|
||||
async def render_async(self, *args, **kwargs):
|
||||
"""Render the template with the given arguments asynchronously and
|
||||
return it as a string."""
|
||||
response = ''
|
||||
async for chunk in self.generate_async(*args, **kwargs):
|
||||
response += chunk
|
||||
return response
|
||||
@@ -0,0 +1,231 @@
|
||||
import binascii
|
||||
import hashlib
|
||||
from microdot import Request, Response
|
||||
from microdot.microdot import MUTED_SOCKET_ERRORS, print_exception
|
||||
from microdot.helpers import wraps
|
||||
|
||||
|
||||
class WebSocketError(Exception):
|
||||
"""Exception raised when an error occurs in a WebSocket connection."""
|
||||
pass
|
||||
|
||||
|
||||
class WebSocket:
|
||||
"""A WebSocket connection object.
|
||||
|
||||
An instance of this class is sent to handler functions to manage the
|
||||
WebSocket connection.
|
||||
"""
|
||||
CONT = 0
|
||||
TEXT = 1
|
||||
BINARY = 2
|
||||
CLOSE = 8
|
||||
PING = 9
|
||||
PONG = 10
|
||||
|
||||
#: Specify the maximum message size that can be received when calling the
|
||||
#: ``receive()`` method. Messages with payloads that are larger than this
|
||||
#: size will be rejected and the connection closed. Set to 0 to disable
|
||||
#: the size check (be aware of potential security issues if you do this),
|
||||
#: or to -1 to use the value set in
|
||||
#: ``Request.max_body_length``. The default is -1.
|
||||
#:
|
||||
#: Example::
|
||||
#:
|
||||
#: WebSocket.max_message_length = 4 * 1024 # up to 4KB messages
|
||||
max_message_length = -1
|
||||
|
||||
def __init__(self, request):
|
||||
self.request = request
|
||||
self.closed = False
|
||||
|
||||
async def handshake(self):
|
||||
response = self._handshake_response()
|
||||
await self.request.sock[1].awrite(
|
||||
b'HTTP/1.1 101 Switching Protocols\r\n')
|
||||
await self.request.sock[1].awrite(b'Upgrade: websocket\r\n')
|
||||
await self.request.sock[1].awrite(b'Connection: Upgrade\r\n')
|
||||
await self.request.sock[1].awrite(
|
||||
b'Sec-WebSocket-Accept: ' + response + b'\r\n\r\n')
|
||||
|
||||
async def receive(self):
|
||||
"""Receive a message from the client."""
|
||||
while True:
|
||||
opcode, payload = await self._read_frame()
|
||||
send_opcode, data = self._process_websocket_frame(opcode, payload)
|
||||
if send_opcode: # pragma: no cover
|
||||
await self.send(data, send_opcode)
|
||||
elif data: # pragma: no branch
|
||||
return data
|
||||
|
||||
async def send(self, data, opcode=None):
|
||||
"""Send a message to the client.
|
||||
|
||||
:param data: the data to send, given as a string or bytes.
|
||||
:param opcode: a custom frame opcode to use. If not given, the opcode
|
||||
is ``TEXT`` or ``BINARY`` depending on the type of the
|
||||
data.
|
||||
"""
|
||||
frame = self._encode_websocket_frame(
|
||||
opcode or (self.TEXT if isinstance(data, str) else self.BINARY),
|
||||
data)
|
||||
await self.request.sock[1].awrite(frame)
|
||||
|
||||
async def close(self):
|
||||
"""Close the websocket connection."""
|
||||
if not self.closed: # pragma: no cover
|
||||
self.closed = True
|
||||
await self.send(b'', self.CLOSE)
|
||||
|
||||
def _handshake_response(self):
|
||||
connection = False
|
||||
upgrade = False
|
||||
websocket_key = None
|
||||
for header, value in self.request.headers.items():
|
||||
h = header.lower()
|
||||
if h == 'connection':
|
||||
connection = True
|
||||
if 'upgrade' not in value.lower():
|
||||
return self.request.app.abort(400)
|
||||
elif h == 'upgrade':
|
||||
upgrade = True
|
||||
if not value.lower() == 'websocket':
|
||||
return self.request.app.abort(400)
|
||||
elif h == 'sec-websocket-key':
|
||||
websocket_key = value
|
||||
if not connection or not upgrade or not websocket_key:
|
||||
return self.request.app.abort(400)
|
||||
d = hashlib.sha1(websocket_key.encode())
|
||||
d.update(b'258EAFA5-E914-47DA-95CA-C5AB0DC85B11')
|
||||
return binascii.b2a_base64(d.digest())[:-1]
|
||||
|
||||
@classmethod
|
||||
def _parse_frame_header(cls, header):
|
||||
fin = header[0] & 0x80
|
||||
opcode = header[0] & 0x0f
|
||||
if fin == 0 or opcode == cls.CONT: # pragma: no cover
|
||||
raise WebSocketError('Continuation frames not supported')
|
||||
has_mask = header[1] & 0x80
|
||||
length = header[1] & 0x7f
|
||||
if length == 126:
|
||||
length = -2
|
||||
elif length == 127:
|
||||
length = -8
|
||||
return fin, opcode, has_mask, length
|
||||
|
||||
def _process_websocket_frame(self, opcode, payload):
|
||||
if opcode == self.TEXT:
|
||||
payload = payload.decode()
|
||||
elif opcode == self.BINARY:
|
||||
pass
|
||||
elif opcode == self.CLOSE:
|
||||
raise WebSocketError('Websocket connection closed')
|
||||
elif opcode == self.PING:
|
||||
return self.PONG, payload
|
||||
elif opcode == self.PONG: # pragma: no branch
|
||||
return None, None
|
||||
return None, payload
|
||||
|
||||
@classmethod
|
||||
def _encode_websocket_frame(cls, opcode, payload):
|
||||
frame = bytearray()
|
||||
frame.append(0x80 | opcode)
|
||||
if opcode == cls.TEXT:
|
||||
payload = payload.encode()
|
||||
if len(payload) < 126:
|
||||
frame.append(len(payload))
|
||||
elif len(payload) < (1 << 16):
|
||||
frame.append(126)
|
||||
frame.extend(len(payload).to_bytes(2, 'big'))
|
||||
else:
|
||||
frame.append(127)
|
||||
frame.extend(len(payload).to_bytes(8, 'big'))
|
||||
frame.extend(payload)
|
||||
return frame
|
||||
|
||||
async def _read_frame(self):
|
||||
header = await self.request.sock[0].read(2)
|
||||
if len(header) != 2: # pragma: no cover
|
||||
raise WebSocketError('Websocket connection closed')
|
||||
fin, opcode, has_mask, length = self._parse_frame_header(header)
|
||||
if length == -2:
|
||||
length = await self.request.sock[0].read(2)
|
||||
length = int.from_bytes(length, 'big')
|
||||
elif length == -8:
|
||||
length = await self.request.sock[0].read(8)
|
||||
length = int.from_bytes(length, 'big')
|
||||
max_allowed_length = Request.max_body_length \
|
||||
if self.max_message_length == -1 else self.max_message_length
|
||||
if length > max_allowed_length:
|
||||
raise WebSocketError('Message too large')
|
||||
if has_mask: # pragma: no cover
|
||||
mask = await self.request.sock[0].read(4)
|
||||
payload = await self.request.sock[0].read(length)
|
||||
if has_mask: # pragma: no cover
|
||||
payload = bytes(x ^ mask[i % 4] for i, x in enumerate(payload))
|
||||
return opcode, payload
|
||||
|
||||
|
||||
async def websocket_upgrade(request):
|
||||
"""Upgrade a request handler to a websocket connection.
|
||||
|
||||
This function can be called directly inside a route function to process a
|
||||
WebSocket upgrade handshake, for example after the user's credentials are
|
||||
verified. The function returns the websocket object::
|
||||
|
||||
@app.route('/echo')
|
||||
async def echo(request):
|
||||
if not authenticate_user(request):
|
||||
abort(401)
|
||||
ws = await websocket_upgrade(request)
|
||||
while True:
|
||||
message = await ws.receive()
|
||||
await ws.send(message)
|
||||
"""
|
||||
ws = WebSocket(request)
|
||||
await ws.handshake()
|
||||
|
||||
@request.after_request
|
||||
async def after_request(request, response):
|
||||
return Response.already_handled
|
||||
|
||||
return ws
|
||||
|
||||
|
||||
def websocket_wrapper(f, upgrade_function):
|
||||
@wraps(f)
|
||||
async def wrapper(request, *args, **kwargs):
|
||||
ws = await upgrade_function(request)
|
||||
try:
|
||||
await f(request, ws, *args, **kwargs)
|
||||
except OSError as exc:
|
||||
if exc.errno not in MUTED_SOCKET_ERRORS: # pragma: no cover
|
||||
raise
|
||||
except WebSocketError:
|
||||
pass
|
||||
except Exception as exc:
|
||||
print_exception(exc)
|
||||
finally: # pragma: no cover
|
||||
try:
|
||||
await ws.close()
|
||||
except Exception:
|
||||
pass
|
||||
return Response.already_handled
|
||||
return wrapper
|
||||
|
||||
|
||||
def with_websocket(f):
|
||||
"""Decorator to make a route a WebSocket endpoint.
|
||||
|
||||
This decorator is used to define a route that accepts websocket
|
||||
connections. The route then receives a websocket object as a second
|
||||
argument that it can use to send and receive messages::
|
||||
|
||||
@app.route('/echo')
|
||||
@with_websocket
|
||||
async def echo(request, ws):
|
||||
while True:
|
||||
message = await ws.receive()
|
||||
await ws.send(message)
|
||||
"""
|
||||
return websocket_wrapper(f, websocket_upgrade)
|
||||
Whitespace-only changes.
@@ -0,0 +1,14 @@
|
||||
class Loader:
|
||||
|
||||
def __init__(self, pkg, dir):
|
||||
if dir == ".":
|
||||
dir = ""
|
||||
else:
|
||||
dir = dir.replace("/", ".") + "."
|
||||
if pkg and pkg != "__main__":
|
||||
dir = pkg + "." + dir
|
||||
self.p = dir
|
||||
|
||||
def load(self, name):
|
||||
name = name.replace(".", "_")
|
||||
return __import__(self.p + name, None, None, (name,)).render
|
||||
@@ -0,0 +1,21 @@
|
||||
# (c) 2014-2020 Paul Sokolovsky. MIT license.
|
||||
try:
|
||||
from uos import stat, remove
|
||||
except:
|
||||
from os import stat, remove
|
||||
from . import source
|
||||
|
||||
|
||||
class Loader(source.Loader):
|
||||
|
||||
def load(self, name):
|
||||
o_path = self.pkg_path + self.compiled_path(name)
|
||||
i_path = self.pkg_path + self.dir + "/" + name
|
||||
try:
|
||||
o_stat = stat(o_path)
|
||||
i_stat = stat(i_path)
|
||||
if i_stat[8] > o_stat[8]:
|
||||
# input file is newer, remove output to force recompile
|
||||
remove(o_path)
|
||||
finally:
|
||||
return super().load(name)
|
||||
@@ -0,0 +1,188 @@
|
||||
# (c) 2014-2019 Paul Sokolovsky. MIT license.
|
||||
from . import compiled
|
||||
|
||||
|
||||
class Compiler:
|
||||
|
||||
START_CHAR = "{"
|
||||
STMNT = "%"
|
||||
STMNT_END = "%}"
|
||||
EXPR = "{"
|
||||
EXPR_END = "}}"
|
||||
|
||||
def __init__(self, file_in, file_out, indent=0, seq=0, loader=None):
|
||||
self.file_in = file_in
|
||||
self.file_out = file_out
|
||||
self.loader = loader
|
||||
self.seq = seq
|
||||
self._indent = indent
|
||||
self.stack = []
|
||||
self.in_literal = False
|
||||
self.flushed_header = False
|
||||
self.args = "*a, **d"
|
||||
|
||||
def indent(self, adjust=0):
|
||||
if not self.flushed_header:
|
||||
self.flushed_header = True
|
||||
self.indent()
|
||||
self.file_out.write("def render%s(%s):\n" % (str(self.seq) if self.seq else "", self.args))
|
||||
self.stack.append("def")
|
||||
self.file_out.write(" " * (len(self.stack) + self._indent + adjust))
|
||||
|
||||
def literal(self, s):
|
||||
if not s:
|
||||
return
|
||||
if not self.in_literal:
|
||||
self.indent()
|
||||
self.file_out.write('yield """')
|
||||
self.in_literal = True
|
||||
self.file_out.write(s.replace('"', '\\"'))
|
||||
|
||||
def close_literal(self):
|
||||
if self.in_literal:
|
||||
self.file_out.write('"""\n')
|
||||
self.in_literal = False
|
||||
|
||||
def render_expr(self, e):
|
||||
self.indent()
|
||||
self.file_out.write('yield str(' + e + ')\n')
|
||||
|
||||
def parse_statement(self, stmt):
|
||||
tokens = stmt.split(None, 1)
|
||||
if tokens[0] == "args":
|
||||
if len(tokens) > 1:
|
||||
self.args = tokens[1]
|
||||
else:
|
||||
self.args = ""
|
||||
elif tokens[0] == "set":
|
||||
self.indent()
|
||||
self.file_out.write(stmt[3:].strip() + "\n")
|
||||
elif tokens[0] == "include":
|
||||
if not self.flushed_header:
|
||||
# If there was no other output, we still need a header now
|
||||
self.indent()
|
||||
tokens = tokens[1].split(None, 1)
|
||||
args = ""
|
||||
if len(tokens) > 1:
|
||||
args = tokens[1]
|
||||
if tokens[0][0] == "{":
|
||||
self.indent()
|
||||
# "1" as fromlist param is uPy hack
|
||||
self.file_out.write('_ = __import__(%s.replace(".", "_"), None, None, 1)\n' % tokens[0][2:-2])
|
||||
self.indent()
|
||||
self.file_out.write("yield from _.render(%s)\n" % args)
|
||||
return
|
||||
|
||||
with self.loader.input_open(tokens[0][1:-1]) as inc:
|
||||
self.seq += 1
|
||||
c = Compiler(inc, self.file_out, len(self.stack) + self._indent, self.seq)
|
||||
inc_id = self.seq
|
||||
self.seq = c.compile()
|
||||
self.indent()
|
||||
self.file_out.write("yield from render%d(%s)\n" % (inc_id, args))
|
||||
elif len(tokens) > 1:
|
||||
if tokens[0] == "elif":
|
||||
assert self.stack[-1] == "if"
|
||||
self.indent(-1)
|
||||
self.file_out.write(stmt + ":\n")
|
||||
else:
|
||||
self.indent()
|
||||
self.file_out.write(stmt + ":\n")
|
||||
self.stack.append(tokens[0])
|
||||
else:
|
||||
if stmt.startswith("end"):
|
||||
assert self.stack[-1] == stmt[3:]
|
||||
self.stack.pop(-1)
|
||||
elif stmt == "else":
|
||||
assert self.stack[-1] == "if"
|
||||
self.indent(-1)
|
||||
self.file_out.write("else:\n")
|
||||
else:
|
||||
assert False
|
||||
|
||||
def parse_line(self, l):
|
||||
while l:
|
||||
start = l.find(self.START_CHAR)
|
||||
if start == -1:
|
||||
self.literal(l)
|
||||
return
|
||||
self.literal(l[:start])
|
||||
self.close_literal()
|
||||
sel = l[start + 1]
|
||||
#print("*%s=%s=" % (sel, EXPR))
|
||||
if sel == self.STMNT:
|
||||
end = l.find(self.STMNT_END)
|
||||
assert end > 0
|
||||
stmt = l[start + len(self.START_CHAR + self.STMNT):end].strip()
|
||||
self.parse_statement(stmt)
|
||||
end += len(self.STMNT_END)
|
||||
l = l[end:]
|
||||
if not self.in_literal and l == "\n":
|
||||
break
|
||||
elif sel == self.EXPR:
|
||||
# print("EXPR")
|
||||
end = l.find(self.EXPR_END)
|
||||
assert end > 0
|
||||
expr = l[start + len(self.START_CHAR + self.EXPR):end].strip()
|
||||
self.render_expr(expr)
|
||||
end += len(self.EXPR_END)
|
||||
l = l[end:]
|
||||
else:
|
||||
self.literal(l[start])
|
||||
l = l[start + 1:]
|
||||
|
||||
def header(self):
|
||||
self.file_out.write("# Autogenerated file\n")
|
||||
|
||||
def compile(self):
|
||||
self.header()
|
||||
for l in self.file_in:
|
||||
self.parse_line(l)
|
||||
self.close_literal()
|
||||
return self.seq
|
||||
|
||||
|
||||
class Loader(compiled.Loader):
|
||||
|
||||
def __init__(self, pkg, dir):
|
||||
super().__init__(pkg, dir)
|
||||
self.dir = dir
|
||||
if pkg == "__main__":
|
||||
# if pkg isn't really a package, don't bother to use it
|
||||
# it means we're running from "filesystem directory", not
|
||||
# from a package.
|
||||
pkg = None
|
||||
|
||||
self.pkg_path = ""
|
||||
if pkg:
|
||||
p = __import__(pkg)
|
||||
if isinstance(p.__path__, str):
|
||||
# uPy
|
||||
self.pkg_path = p.__path__
|
||||
else:
|
||||
# CPy
|
||||
self.pkg_path = p.__path__[0]
|
||||
self.pkg_path += "/"
|
||||
|
||||
def input_open(self, template):
|
||||
path = self.pkg_path + self.dir + "/" + template
|
||||
return open(path)
|
||||
|
||||
def compiled_path(self, template):
|
||||
return self.dir + "/" + template.replace(".", "_") + ".py"
|
||||
|
||||
def load(self, name):
|
||||
try:
|
||||
return super().load(name)
|
||||
except (OSError, ImportError):
|
||||
pass
|
||||
|
||||
compiled_path = self.pkg_path + self.compiled_path(name)
|
||||
|
||||
f_in = self.input_open(name)
|
||||
f_out = open(compiled_path, "w")
|
||||
c = Compiler(f_in, f_out, loader=self)
|
||||
c.compile()
|
||||
f_in.close()
|
||||
f_out.close()
|
||||
return super().load(name)
|
||||
@@ -0,0 +1,12 @@
|
||||
#create an accesstpoit called led-hoop with password hoop-1234
|
||||
#enable password protection
|
||||
|
||||
import network
|
||||
|
||||
ap_if = network.WLAN(network.AP_IF)
|
||||
ap_mac = ap_if.config('mac')
|
||||
ap_if.active(True)
|
||||
ap_if.config(essid="led-hoop", password="hoop-1234")
|
||||
ap_if.active(False)
|
||||
ap_if.active(True)
|
||||
print(ap_if.ifconfig())
|
||||
@@ -0,0 +1,58 @@
|
||||
{
|
||||
"buttons": [
|
||||
{"id": "start", "preset": "off"},
|
||||
{"id": "grab", "preset": "grab"},
|
||||
{"id": "spin1", "preset": "spin1"},
|
||||
{"id": "lift", "preset": "lift"},
|
||||
{"id": "flare", "preset": "flare"},
|
||||
{"id": "hook", "preset": "hook"},
|
||||
{"id": "roll1", "preset": "roll1"},
|
||||
{"id": "invertsplit", "preset": "invertsplit"},
|
||||
{"id": "pose1", "preset": "pose1"},
|
||||
{"id": "pose1", "preset": "pose2"},
|
||||
{"id": "roll2", "preset": "roll2"},
|
||||
{"id": "backbalance1", "preset": "backbalance1"},
|
||||
{"id": "beat1", "preset": "beat1"},
|
||||
{"id": "pose3", "preset": "pose3"},
|
||||
{"id": "roll3", "preset": "roll3"},
|
||||
{"id": "crouch", "preset": "crouch"},
|
||||
{"id": "pose4", "preset": "pose4"},
|
||||
{"id": "roll4", "preset": "roll4"},
|
||||
{"id": "backbendsplit", "preset": "backbendsplit"},
|
||||
{"id": "backbalance2", "preset": "backbalance2"},
|
||||
{"id": "backbalance3", "preset": "backbalance3"},
|
||||
{"id": "beat2", "preset": "beat2"},
|
||||
{"id": "straddle", "preset": "straddle"},
|
||||
{"id": "beat3", "preset": "beat3"},
|
||||
{"id": "frontbalance1", "preset": "frontbalance1"},
|
||||
{"id": "pose5", "preset": "pose5"},
|
||||
{"id": "pose6", "preset": "pose6"},
|
||||
{"id": "elbowhang", "preset": "elbowhang"},
|
||||
{"id": "elbowhangspin", "preset": "elbowhangspin"},
|
||||
{"id": "spin2", "preset": "spin2"},
|
||||
{"id": "dismount", "preset": "dismount"},
|
||||
{"id": "spin3", "preset": "spin3"},
|
||||
{"id": "fluff", "preset": "fluff"},
|
||||
{"id": "spin4", "preset": "spin4"},
|
||||
{"id": "flare2", "preset": "flare2"},
|
||||
{"id": "elbowhang", "preset": "elbowhang"},
|
||||
{"id": "elbowhangsplit2", "preset": "elbowhangsplit2"},
|
||||
{"id": "invert", "preset": "invert"},
|
||||
{"id": "roll5", "preset": "roll5"},
|
||||
{"id": "backbend", "preset": "backbend"},
|
||||
{"id": "pose7", "preset": "pose7"},
|
||||
{"id": "roll6", "preset": "roll6"},
|
||||
{"id": "seat", "preset": "seat"},
|
||||
{"id": "kneehang", "preset": "kneehang"},
|
||||
{"id": "legswoop", "preset": "legswoop"},
|
||||
{"id": "split", "preset": "split"},
|
||||
{"id": "foothang", "preset": "foothang"},
|
||||
{"id": "end", "preset": "end"}
|
||||
]
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
+105
-30
@@ -1,34 +1,109 @@
|
||||
"""
|
||||
XIAO ESP32-C6: ESPNOW -> UART passthrough to Pico.
|
||||
Receives messages via ESPNOW, forwards them unchanged to UART (GPIO17).
|
||||
UART at 921600 baud. LED on GPIO15 blinks on activity.
|
||||
"""
|
||||
import network
|
||||
import espnow
|
||||
import machine
|
||||
import time
|
||||
from microdot import Microdot, send_file, Response
|
||||
from microdot.utemplate import Template
|
||||
from microdot.websocket import with_websocket
|
||||
import json
|
||||
from machine import Pin, UART, WDT
|
||||
import asyncio
|
||||
|
||||
# UART: TX on GPIO17 -> Pico RX, max baud for throughput
|
||||
UART_BAUD = 921600
|
||||
uart = machine.UART(1, baudrate=UART_BAUD, tx=17)
|
||||
led = machine.Pin(15, machine.Pin.OUT)
|
||||
# Load button config: {"buttons": [{"id": "...", "preset": "..."}, ...]}
|
||||
def _load_buttons():
|
||||
try:
|
||||
with open("buttons.json") as f:
|
||||
raw = json.load(f)
|
||||
return raw.get("buttons", [])
|
||||
except (OSError, KeyError, ValueError):
|
||||
return []
|
||||
|
||||
# WLAN must be active for ESPNOW (no need to connect)
|
||||
sta = network.WLAN(network.WLAN.IF_STA)
|
||||
sta.active(True)
|
||||
sta.disconnect()
|
||||
|
||||
e = espnow.ESPNow()
|
||||
e.active(True)
|
||||
# No peers needed to receive; add_peer() only for send()
|
||||
def _save_buttons(buttons):
|
||||
try:
|
||||
with open("buttons.json", "w") as f:
|
||||
json.dump({"buttons": buttons}, f)
|
||||
return True
|
||||
except OSError:
|
||||
return False
|
||||
|
||||
# Recv timeout 0 = non-blocking
|
||||
print("ESP32: ESPNOW -> UART passthrough, %d baud" % UART_BAUD)
|
||||
while True:
|
||||
mac, msg = e.irecv(0)
|
||||
if msg:
|
||||
uart.write(msg)
|
||||
led.value(1)
|
||||
else:
|
||||
led.value(0)
|
||||
time.sleep_ms(1)
|
||||
|
||||
BUTTONS = _load_buttons()
|
||||
|
||||
uart = UART(1, baudrate=921600, tx=Pin(16, Pin.OUT))
|
||||
|
||||
app = Microdot()
|
||||
Response.default_content_type = 'text/html'
|
||||
|
||||
# Device id used in select payload (e.g. Pico name)
|
||||
DEVICE_ID = "1"
|
||||
|
||||
# All connected WebSocket clients (for broadcasting button updates)
|
||||
_ws_clients = set()
|
||||
|
||||
|
||||
@app.route('/')
|
||||
async def index_handler(request):
|
||||
return Template('/index.html').render(buttons=BUTTONS, device_id=DEVICE_ID)
|
||||
|
||||
@app.route("/api/buttons", methods=["GET"])
|
||||
async def api_get_buttons(request):
|
||||
return {"buttons": BUTTONS}
|
||||
|
||||
|
||||
@app.route("/api/buttons", methods=["POST"])
|
||||
async def api_save_buttons(request):
|
||||
global BUTTONS
|
||||
try:
|
||||
data = request.json or {}
|
||||
buttons = data.get("buttons", [])
|
||||
if not isinstance(buttons, list):
|
||||
return {"ok": False, "error": "buttons must be a list"}, 400
|
||||
if _save_buttons(buttons):
|
||||
BUTTONS = buttons
|
||||
return {"ok": True}
|
||||
return {"ok": False, "error": "save failed"}, 500
|
||||
except Exception as e:
|
||||
return {"ok": False, "error": str(e)}, 500
|
||||
|
||||
|
||||
@app.route("/static/<path:path>")
|
||||
async def static_handler(request, path):
|
||||
if '..' in path:
|
||||
# Directory traversal is not allowed
|
||||
return 'Not found', 404
|
||||
return send_file('static/' + path)
|
||||
|
||||
@app.route("/ws")
|
||||
@with_websocket
|
||||
async def ws(request, ws):
|
||||
_ws_clients.add(ws)
|
||||
print("WebSocket connection established")
|
||||
|
||||
try:
|
||||
while True:
|
||||
data = await ws.receive()
|
||||
if data:
|
||||
# Forward WebSocket message to UART (line-delimited for Pico)
|
||||
payload = data if isinstance(data, bytes) else data.encode("utf-8")
|
||||
uart.write(payload + b"\n")
|
||||
print(data)
|
||||
|
||||
# Broadcast to all other clients so their UIs stay in sync
|
||||
for other in list(_ws_clients):
|
||||
if other is not ws and not other.closed:
|
||||
try:
|
||||
await other.send(data)
|
||||
except Exception:
|
||||
pass
|
||||
else:
|
||||
break
|
||||
finally:
|
||||
_ws_clients.discard(ws)
|
||||
print("WebSocket connection closed")
|
||||
|
||||
|
||||
|
||||
async def main():
|
||||
server = asyncio.create_task(app.start_server("0.0.0.0", 80))
|
||||
|
||||
await server
|
||||
|
||||
if __name__ == "__main__":
|
||||
asyncio.run(main())
|
||||
@@ -0,0 +1,48 @@
|
||||
start
|
||||
grab
|
||||
spin1
|
||||
lift
|
||||
flare
|
||||
hook
|
||||
roll1
|
||||
invertsplit
|
||||
pose1
|
||||
pose1
|
||||
roll2
|
||||
backbalance1
|
||||
beat1
|
||||
pose3
|
||||
roll3
|
||||
crouch
|
||||
pose4
|
||||
roll4
|
||||
backbendsplit
|
||||
backbalance2
|
||||
backbalance3
|
||||
beat2
|
||||
straddle
|
||||
beat3
|
||||
frontbalance1
|
||||
pose5
|
||||
pose6
|
||||
elbowhang
|
||||
elbowhangspin
|
||||
spin2
|
||||
dismount
|
||||
spin3
|
||||
fluff
|
||||
spin4
|
||||
flare2
|
||||
elbowhang
|
||||
elbowhangsplit2
|
||||
invert
|
||||
roll5
|
||||
backbend
|
||||
pose7
|
||||
roll6
|
||||
seat
|
||||
kneehang
|
||||
legswoop
|
||||
split
|
||||
foothang
|
||||
end
|
||||
@@ -0,0 +1,617 @@
|
||||
var deviceId = document.body.getAttribute('data-device-id') || '1';
|
||||
var ws = null;
|
||||
var currentEditIndex = -1; // -1 means "new button"
|
||||
|
||||
function getButtonsFromDom() {
|
||||
var btns = document.querySelectorAll('#buttonsContainer .btn');
|
||||
return Array.prototype.map.call(btns, function (el) {
|
||||
var obj = {
|
||||
id: el.getAttribute('data-id') || el.textContent.trim(),
|
||||
preset: el.getAttribute('data-preset') || ''
|
||||
};
|
||||
var p = el.getAttribute('data-p');
|
||||
if (p) obj.p = p;
|
||||
var d = el.getAttribute('data-d');
|
||||
if (d !== null && d !== '') obj.d = parseInt(d, 10) || 0;
|
||||
var b = el.getAttribute('data-b');
|
||||
if (b !== null && b !== '') obj.b = parseInt(b, 10) || 0;
|
||||
var c = el.getAttribute('data-c');
|
||||
if (c) {
|
||||
try {
|
||||
var parsed = JSON.parse(c);
|
||||
if (Array.isArray(parsed)) obj.c = parsed;
|
||||
} catch (e) {}
|
||||
}
|
||||
for (var i = 1; i <= 8; i++) {
|
||||
var key = 'n' + i;
|
||||
var v = el.getAttribute('data-' + key);
|
||||
if (v !== null && v !== '') {
|
||||
obj[key] = parseInt(v, 10) || 0;
|
||||
}
|
||||
}
|
||||
return obj;
|
||||
});
|
||||
}
|
||||
|
||||
function renderButtons(buttons) {
|
||||
var container = document.getElementById('buttonsContainer');
|
||||
container.innerHTML = '';
|
||||
buttons.forEach(function (btn, idx) {
|
||||
var el = document.createElement('button');
|
||||
el.className = 'btn';
|
||||
el.type = 'button';
|
||||
el.setAttribute('data-preset', btn.preset);
|
||||
el.setAttribute('data-id', btn.id);
|
||||
el.setAttribute('data-index', String(idx));
|
||||
// Optional preset config stored per button
|
||||
if (btn.p !== undefined) el.setAttribute('data-p', btn.p);
|
||||
if (btn.d !== undefined) el.setAttribute('data-d', String(btn.d));
|
||||
if (btn.b !== undefined) el.setAttribute('data-b', String(btn.b));
|
||||
if (btn.c !== undefined) {
|
||||
try {
|
||||
el.setAttribute('data-c', JSON.stringify(btn.c));
|
||||
} catch (e) {}
|
||||
}
|
||||
for (var i = 1; i <= 8; i++) {
|
||||
var key = 'n' + i;
|
||||
if (btn[key] !== undefined) {
|
||||
el.setAttribute('data-' + key, String(btn[key]));
|
||||
}
|
||||
}
|
||||
el.draggable = true;
|
||||
el.textContent = btn.id;
|
||||
container.appendChild(el);
|
||||
});
|
||||
attachButtonListeners();
|
||||
}
|
||||
|
||||
function attachButtonListeners() {
|
||||
var container = document.getElementById('buttonsContainer');
|
||||
if (!container) return;
|
||||
var btns = container.querySelectorAll('.btn');
|
||||
for (var i = 0; i < btns.length; i++) {
|
||||
var el = btns[i];
|
||||
el.setAttribute('data-index', String(i));
|
||||
el.onclick = function(ev) {
|
||||
if (longPressTriggered) {
|
||||
ev.preventDefault();
|
||||
return;
|
||||
}
|
||||
var btn = ev.currentTarget;
|
||||
sendSelect(btn.getAttribute('data-preset'), btn);
|
||||
};
|
||||
el.oncontextmenu = function(ev) {
|
||||
ev.preventDefault();
|
||||
showButtonContextMenu(ev, ev.currentTarget);
|
||||
};
|
||||
(function(buttonEl) {
|
||||
var startX, startY;
|
||||
el.ontouchstart = function(ev) {
|
||||
if (ev.touches.length !== 1) return;
|
||||
longPressTriggered = false;
|
||||
startX = ev.touches[0].clientX;
|
||||
startY = ev.touches[0].clientY;
|
||||
longPressTimer = setTimeout(function() {
|
||||
longPressTimer = null;
|
||||
longPressTriggered = true;
|
||||
showButtonContextMenu({ clientX: startX, clientY: startY }, buttonEl);
|
||||
}, 500);
|
||||
};
|
||||
el.ontouchmove = function(ev) {
|
||||
if (longPressTimer && ev.touches.length === 1) {
|
||||
var dx = ev.touches[0].clientX - startX;
|
||||
var dy = ev.touches[0].clientY - startY;
|
||||
if (dx * dx + dy * dy > 100) {
|
||||
clearTimeout(longPressTimer);
|
||||
longPressTimer = null;
|
||||
}
|
||||
}
|
||||
};
|
||||
el.ontouchend = el.ontouchcancel = function() {
|
||||
if (longPressTimer) {
|
||||
clearTimeout(longPressTimer);
|
||||
longPressTimer = null;
|
||||
}
|
||||
setTimeout(function() { longPressTriggered = false; }, 400);
|
||||
};
|
||||
})(el);
|
||||
el.ondragstart = function(ev) {
|
||||
ev.dataTransfer.setData('text/plain', ev.currentTarget.getAttribute('data-index'));
|
||||
ev.dataTransfer.effectAllowed = 'move';
|
||||
ev.currentTarget.classList.add('dragging');
|
||||
};
|
||||
el.ondragend = function(ev) {
|
||||
ev.currentTarget.classList.remove('dragging');
|
||||
};
|
||||
el.ondragover = function(ev) {
|
||||
ev.preventDefault();
|
||||
ev.dataTransfer.dropEffect = 'move';
|
||||
var target = ev.currentTarget;
|
||||
if (target.classList.contains('dragging')) return;
|
||||
target.classList.add('drop-target');
|
||||
};
|
||||
el.ondragleave = function(ev) {
|
||||
ev.currentTarget.classList.remove('drop-target');
|
||||
};
|
||||
el.ondrop = function(ev) {
|
||||
ev.preventDefault();
|
||||
ev.currentTarget.classList.remove('drop-target');
|
||||
var fromIdx = parseInt(ev.dataTransfer.getData('text/plain'), 10);
|
||||
var toIdx = parseInt(ev.currentTarget.getAttribute('data-index'), 10);
|
||||
if (fromIdx === toIdx) return;
|
||||
var buttons = getButtonsFromDom();
|
||||
var item = buttons.splice(fromIdx, 1)[0];
|
||||
buttons.splice(toIdx, 0, item);
|
||||
renderButtons(buttons);
|
||||
saveButtons(buttons);
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
// Button editor (per-button preset config)
|
||||
|
||||
function saveButtons(buttons, callback) {
|
||||
fetch('/api/buttons', {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ buttons: buttons })
|
||||
}).then(function(r) { return r.json(); }).then(function(data) {
|
||||
if (callback) callback(data);
|
||||
else showToast(data.ok ? 'Saved' : (data.error || 'Save failed'));
|
||||
}).catch(function() {
|
||||
if (callback) callback({ ok: false });
|
||||
else showToast('Save failed');
|
||||
});
|
||||
}
|
||||
|
||||
function saveCurrentButtons() {
|
||||
var buttons = getButtonsFromDom();
|
||||
saveButtons(buttons, function(data) {
|
||||
showToast(data.ok ? 'Saved' : (data.error || 'Save failed'));
|
||||
});
|
||||
}
|
||||
|
||||
var toastTimer = null;
|
||||
|
||||
function showToast(message) {
|
||||
var el = document.getElementById('toast');
|
||||
if (!el) {
|
||||
el = document.createElement('div');
|
||||
el.id = 'toast';
|
||||
el.className = 'toast';
|
||||
document.body.appendChild(el);
|
||||
}
|
||||
el.textContent = message;
|
||||
el.classList.add('toast-visible');
|
||||
if (toastTimer) clearTimeout(toastTimer);
|
||||
toastTimer = setTimeout(function() {
|
||||
el.classList.remove('toast-visible');
|
||||
toastTimer = null;
|
||||
}, 2000);
|
||||
}
|
||||
|
||||
function addButton(button) {
|
||||
var buttons = getButtonsFromDom();
|
||||
buttons.push(button);
|
||||
renderButtons(buttons);
|
||||
saveButtons(buttons);
|
||||
}
|
||||
|
||||
var contextMenuEl = null;
|
||||
var longPressTimer = null;
|
||||
var longPressTriggered = false;
|
||||
|
||||
function openNewButtonEditor() {
|
||||
currentEditIndex = -1;
|
||||
var title = document.getElementById('buttonEditorTitle');
|
||||
if (title) title.textContent = 'New button';
|
||||
fillButtonEditorFields({
|
||||
id: '',
|
||||
preset: '',
|
||||
p: 'off',
|
||||
d: 0,
|
||||
b: 0,
|
||||
c: [[0, 0, 0]]
|
||||
});
|
||||
openButtonEditor();
|
||||
}
|
||||
|
||||
function openExistingButtonEditor(index) {
|
||||
currentEditIndex = index;
|
||||
var buttons = getButtonsFromDom();
|
||||
var btn = buttons[index];
|
||||
var title = document.getElementById('buttonEditorTitle');
|
||||
if (title) title.textContent = 'Edit button';
|
||||
fillButtonEditorFields(btn);
|
||||
openButtonEditor();
|
||||
}
|
||||
|
||||
function openButtonEditor() {
|
||||
var editor = document.getElementById('buttonEditor');
|
||||
if (!editor) return;
|
||||
editor.classList.add('open');
|
||||
document.body.classList.add('button-editor-open');
|
||||
}
|
||||
|
||||
function closeButtonEditor() {
|
||||
var editor = document.getElementById('buttonEditor');
|
||||
if (!editor) return;
|
||||
editor.classList.remove('open');
|
||||
document.body.classList.remove('button-editor-open');
|
||||
}
|
||||
|
||||
function fillButtonEditorFields(btn) {
|
||||
document.getElementById('be-label').value = btn.id || '';
|
||||
document.getElementById('be-preset').value = btn.preset || btn.id || '';
|
||||
var pattern = btn.p || btn.preset || 'off';
|
||||
var patternSelect = document.getElementById('be-pattern');
|
||||
if (patternSelect) {
|
||||
patternSelect.value = pattern;
|
||||
}
|
||||
document.getElementById('be-delay').value = btn.d != null ? String(btn.d) : '';
|
||||
document.getElementById('be-brightness').value = btn.b != null ? String(btn.b) : '';
|
||||
var colors = btn.c;
|
||||
var colorsStr = '';
|
||||
if (Array.isArray(colors) && colors.length) {
|
||||
colorsStr = colors.map(function (rgb) {
|
||||
return (rgb[0] || 0) + ',' + (rgb[1] || 0) + ',' + (rgb[2] || 0);
|
||||
}).join('; ');
|
||||
}
|
||||
document.getElementById('be-colors').value = colorsStr;
|
||||
for (var i = 1; i <= 8; i++) {
|
||||
var key = 'n' + i;
|
||||
var el = document.getElementById('be-' + key);
|
||||
if (el) el.value = btn[key] != null ? String(btn[key]) : '';
|
||||
}
|
||||
}
|
||||
|
||||
function buildButtonFromEditor() {
|
||||
function toInt(val, fallback) {
|
||||
var n = parseInt(val, 10);
|
||||
return isNaN(n) ? fallback : n;
|
||||
}
|
||||
|
||||
var label = (document.getElementById('be-label').value || '').trim();
|
||||
var presetName = (document.getElementById('be-preset').value || '').trim() || label || 'preset';
|
||||
var patternEl = document.getElementById('be-pattern');
|
||||
var pattern = patternEl ? (patternEl.value || '').trim() : 'off';
|
||||
var delayVal = document.getElementById('be-delay').value;
|
||||
var brightVal = document.getElementById('be-brightness').value;
|
||||
var colorsRaw = (document.getElementById('be-colors').value || '').trim();
|
||||
|
||||
var d = toInt(delayVal, 0);
|
||||
var b = toInt(brightVal, 0);
|
||||
|
||||
var colors = [];
|
||||
if (colorsRaw) {
|
||||
colorsRaw.split(';').forEach(function (chunk) {
|
||||
var parts = chunk.split(',').map(function (s) { return s.trim(); }).filter(Boolean);
|
||||
if (parts.length === 3) {
|
||||
var r = toInt(parts[0], 0);
|
||||
var g = toInt(parts[1], 0);
|
||||
var bl = toInt(parts[2], 0);
|
||||
r = Math.max(0, Math.min(255, r));
|
||||
g = Math.max(0, Math.min(255, g));
|
||||
bl = Math.max(0, Math.min(255, bl));
|
||||
colors.push([r, g, bl]);
|
||||
}
|
||||
});
|
||||
}
|
||||
if (!colors.length) colors = [[0, 0, 0]];
|
||||
|
||||
var btn = {
|
||||
id: label || presetName,
|
||||
preset: presetName,
|
||||
p: pattern,
|
||||
d: d,
|
||||
b: b,
|
||||
c: colors
|
||||
};
|
||||
|
||||
for (var i = 1; i <= 8; i++) {
|
||||
var key = 'n' + i;
|
||||
var el = document.getElementById('be-' + key);
|
||||
if (!el) continue;
|
||||
var v = el.value;
|
||||
if (v !== '') {
|
||||
btn[key] = toInt(v, 0);
|
||||
}
|
||||
}
|
||||
|
||||
return btn;
|
||||
}
|
||||
|
||||
function saveButtonFromEditor() {
|
||||
var btn = buildButtonFromEditor();
|
||||
var buttons = getButtonsFromDom();
|
||||
if (currentEditIndex >= 0 && currentEditIndex < buttons.length) {
|
||||
buttons[currentEditIndex] = btn;
|
||||
} else {
|
||||
buttons.push(btn);
|
||||
}
|
||||
renderButtons(buttons);
|
||||
saveButtons(buttons);
|
||||
|
||||
// Also send this preset to the Pico and save it there
|
||||
if (ws && ws.readyState === WebSocket.OPEN && btn.preset) {
|
||||
var presetData = {
|
||||
p: btn.p,
|
||||
d: btn.d,
|
||||
b: btn.b,
|
||||
c: btn.c
|
||||
};
|
||||
for (var i = 1; i <= 8; i++) {
|
||||
var key = 'n' + i;
|
||||
if (btn[key] !== undefined) {
|
||||
presetData[key] = btn[key];
|
||||
}
|
||||
}
|
||||
ws.send(JSON.stringify({
|
||||
preset_edit: {
|
||||
name: btn.preset,
|
||||
data: presetData
|
||||
}
|
||||
}));
|
||||
ws.send(JSON.stringify({ preset_save: true }));
|
||||
}
|
||||
|
||||
closeButtonEditor();
|
||||
}
|
||||
|
||||
function showButtonContextMenu(evOrCoords, buttonEl) {
|
||||
hideContextMenu();
|
||||
var x = evOrCoords.clientX != null ? evOrCoords.clientX : evOrCoords.x;
|
||||
var y = evOrCoords.clientY != null ? evOrCoords.clientY : evOrCoords.y;
|
||||
var buttons = getButtonsFromDom();
|
||||
var idx = parseInt(buttonEl.getAttribute('data-index'), 10);
|
||||
var btn = buttons[idx];
|
||||
contextMenuEl = document.createElement('div');
|
||||
contextMenuEl.className = 'context-menu';
|
||||
contextMenuEl.style.left = x + 'px';
|
||||
contextMenuEl.style.top = y + 'px';
|
||||
contextMenuEl.innerHTML = '<button type="button" class="context-menu-item" data-action="edit">Edit</button><button type="button" class="context-menu-item" data-action="delete">Delete</button>';
|
||||
document.body.appendChild(contextMenuEl);
|
||||
document.addEventListener('click', hideContextMenuOnce);
|
||||
contextMenuEl.querySelector('[data-action="edit"]').onclick = function() {
|
||||
hideContextMenu();
|
||||
openExistingButtonEditor(idx);
|
||||
};
|
||||
contextMenuEl.querySelector('[data-action="delete"]').onclick = function() {
|
||||
hideContextMenu();
|
||||
buttons.splice(idx, 1);
|
||||
renderButtons(buttons);
|
||||
saveButtons(buttons);
|
||||
};
|
||||
}
|
||||
|
||||
function hideContextMenu() {
|
||||
if (contextMenuEl && contextMenuEl.parentNode) contextMenuEl.parentNode.removeChild(contextMenuEl);
|
||||
contextMenuEl = null;
|
||||
document.removeEventListener('click', hideContextMenuOnce);
|
||||
}
|
||||
|
||||
function hideContextMenuOnce() {
|
||||
hideContextMenu();
|
||||
}
|
||||
|
||||
function connect() {
|
||||
var proto = location.protocol === "https:" ? "wss:" : "ws:";
|
||||
ws = new WebSocket(proto + "//" + location.host + "/ws");
|
||||
ws.onclose = function() { setTimeout(connect, 2000); };
|
||||
ws.onmessage = function(ev) {
|
||||
try {
|
||||
var msg = JSON.parse(ev.data);
|
||||
if (msg && msg.select != null) {
|
||||
var preset = typeof msg.select === 'string' ? msg.select : (Array.isArray(msg.select) ? msg.select[1] : null);
|
||||
if (preset != null) {
|
||||
document.querySelectorAll('.buttons .btn').forEach(function(b) { b.classList.remove('selected'); });
|
||||
if (preset !== 'off') {
|
||||
var el = document.querySelector('.buttons .btn[data-preset="' + preset + '"]');
|
||||
if (el) {
|
||||
el.classList.add('selected');
|
||||
scrollSelectedIntoView();
|
||||
updateSelectedObserver();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
} catch (e) {}
|
||||
};
|
||||
}
|
||||
|
||||
function sendSelect(preset, el) {
|
||||
var msg = JSON.stringify({ select: preset });
|
||||
if (ws && ws.readyState === WebSocket.OPEN) ws.send(msg);
|
||||
document.querySelectorAll('.buttons .btn').forEach(function(b) { b.classList.remove('selected'); });
|
||||
if (el) el.classList.add('selected');
|
||||
updateSelectedObserver();
|
||||
}
|
||||
|
||||
function togglePresetEditor() {
|
||||
var editor = document.getElementById('presetEditor');
|
||||
if (!editor) return;
|
||||
var isOpen = editor.classList.contains('open');
|
||||
if (isOpen) {
|
||||
editor.classList.remove('open');
|
||||
document.body.classList.remove('preset-editor-open');
|
||||
} else {
|
||||
editor.classList.add('open');
|
||||
document.body.classList.add('preset-editor-open');
|
||||
}
|
||||
}
|
||||
|
||||
function buildPresetPayloadFromForm() {
|
||||
var name = (document.getElementById('pe-name').value || '').trim();
|
||||
var patternEl = document.getElementById('pe-pattern');
|
||||
var pattern = patternEl ? (patternEl.value || '').trim() : 'off';
|
||||
var delayVal = document.getElementById('pe-delay').value;
|
||||
var brightVal = document.getElementById('pe-brightness').value;
|
||||
var colorsRaw = (document.getElementById('pe-colors').value || '').trim();
|
||||
|
||||
function toInt(val, fallback) {
|
||||
var n = parseInt(val, 10);
|
||||
return isNaN(n) ? fallback : n;
|
||||
}
|
||||
|
||||
var d = toInt(delayVal, 0);
|
||||
var b = toInt(brightVal, 0);
|
||||
|
||||
var colors = [];
|
||||
if (colorsRaw) {
|
||||
colorsRaw.split(';').forEach(function (chunk) {
|
||||
var parts = chunk.split(',').map(function (s) { return s.trim(); }).filter(Boolean);
|
||||
if (parts.length === 3) {
|
||||
var r = toInt(parts[0], 0);
|
||||
var g = toInt(parts[1], 0);
|
||||
var bl = toInt(parts[2], 0);
|
||||
r = Math.max(0, Math.min(255, r));
|
||||
g = Math.max(0, Math.min(255, g));
|
||||
bl = Math.max(0, Math.min(255, bl));
|
||||
colors.push([r, g, bl]);
|
||||
}
|
||||
});
|
||||
}
|
||||
if (!colors.length) colors = [[0, 0, 0]];
|
||||
|
||||
var data = { p: pattern, d: d, b: b, c: colors };
|
||||
|
||||
['n1', 'n2', 'n3', 'n4', 'n5', 'n6', 'n7', 'n8'].forEach(function (key) {
|
||||
var el = document.getElementById('pe-' + key);
|
||||
if (!el) return;
|
||||
var v = el.value;
|
||||
if (v !== '') {
|
||||
data[key] = toInt(v, 0);
|
||||
}
|
||||
});
|
||||
|
||||
return { name: name, data: data };
|
||||
}
|
||||
|
||||
function sendPresetToPico() {
|
||||
var payload = buildPresetPayloadFromForm();
|
||||
if (!payload.name) {
|
||||
showToast('Preset name is required');
|
||||
return;
|
||||
}
|
||||
if (ws && ws.readyState === WebSocket.OPEN) {
|
||||
ws.send(JSON.stringify({ preset_edit: payload }));
|
||||
ensurePresetInList(payload.name);
|
||||
showToast('Preset sent (not yet saved)');
|
||||
} else {
|
||||
showToast('Not connected');
|
||||
}
|
||||
}
|
||||
|
||||
function savePresetsOnPico() {
|
||||
var payload = buildPresetPayloadFromForm();
|
||||
if (!payload.name) {
|
||||
showToast('Preset name is required');
|
||||
return;
|
||||
}
|
||||
if (ws && ws.readyState === WebSocket.OPEN) {
|
||||
ws.send(JSON.stringify({ preset_edit: payload }));
|
||||
ws.send(JSON.stringify({ preset_save: true }));
|
||||
ensurePresetInList(payload.name);
|
||||
showToast('Preset saved to Pico');
|
||||
} else {
|
||||
showToast('Not connected');
|
||||
}
|
||||
}
|
||||
|
||||
function deletePresetOnPico() {
|
||||
var name = (document.getElementById('pe-name').value || '').trim();
|
||||
if (!name) {
|
||||
showToast('Preset name is required');
|
||||
return;
|
||||
}
|
||||
var msg = { preset_delete: name };
|
||||
if (ws && ws.readyState === WebSocket.OPEN) {
|
||||
ws.send(JSON.stringify(msg));
|
||||
removePresetFromList(name);
|
||||
ws.send(JSON.stringify(msg));
|
||||
showToast('Delete command sent');
|
||||
} else {
|
||||
showToast('Not connected');
|
||||
}
|
||||
}
|
||||
|
||||
function toggleMenu() {
|
||||
var menu = document.getElementById('menu');
|
||||
menu.classList.toggle('open');
|
||||
}
|
||||
|
||||
function closeMenu() {
|
||||
document.getElementById('menu').classList.remove('open');
|
||||
}
|
||||
|
||||
document.addEventListener('click', function(ev) {
|
||||
var menu = document.getElementById('menu');
|
||||
var menuBtn = document.querySelector('.menu-btn');
|
||||
if (menu.classList.contains('open') && menuBtn && !menu.contains(ev.target) && !menuBtn.contains(ev.target)) {
|
||||
closeMenu();
|
||||
}
|
||||
});
|
||||
|
||||
function scrollSelectedIntoView() {
|
||||
var el = document.querySelector('.buttons .btn.selected');
|
||||
if (el) el.scrollIntoView({ behavior: 'smooth', block: 'nearest', inline: 'nearest' });
|
||||
}
|
||||
|
||||
var scrollObserver = null;
|
||||
var observedSelectedEl = null;
|
||||
|
||||
function setupScrollObserver() {
|
||||
var container = document.getElementById('buttonsContainer');
|
||||
if (!container || scrollObserver) return;
|
||||
scrollObserver = new IntersectionObserver(
|
||||
function (entries) {
|
||||
entries.forEach(function (entry) {
|
||||
if (entry.intersectionRatio < 0.5 && entry.target.classList.contains('selected')) {
|
||||
scrollSelectedIntoView();
|
||||
}
|
||||
});
|
||||
},
|
||||
{ root: container, rootMargin: '0px', threshold: [0, 0.25, 0.5, 0.75, 1] }
|
||||
);
|
||||
}
|
||||
|
||||
function updateSelectedObserver() {
|
||||
var el = document.querySelector('.buttons .btn.selected');
|
||||
if (el === observedSelectedEl) return;
|
||||
if (scrollObserver) {
|
||||
if (observedSelectedEl) scrollObserver.unobserve(observedSelectedEl);
|
||||
observedSelectedEl = el;
|
||||
if (el) {
|
||||
setupScrollObserver();
|
||||
scrollObserver.observe(el);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function nextPreset() {
|
||||
var btns = document.querySelectorAll('.buttons .btn');
|
||||
if (btns.length === 0) return;
|
||||
var idx = -1;
|
||||
for (var i = 0; i < btns.length; i++) {
|
||||
if (btns[i].classList.contains('selected')) { idx = i; break; }
|
||||
}
|
||||
idx = (idx + 1) % btns.length;
|
||||
var nextEl = btns[idx];
|
||||
sendSelect(nextEl.getAttribute('data-preset'), nextEl);
|
||||
scrollSelectedIntoView();
|
||||
}
|
||||
|
||||
setupScrollObserver();
|
||||
// Re-render buttons from server config (including per-button presets) once loaded.
|
||||
fetch('/api/buttons')
|
||||
.then(function (r) { return r.json(); })
|
||||
.then(function (data) {
|
||||
var buttons = Array.isArray(data.buttons) ? data.buttons : getButtonsFromDom();
|
||||
renderButtons(buttons);
|
||||
})
|
||||
.catch(function () {
|
||||
// Fallback: use buttons rendered by the template
|
||||
renderButtons(getButtonsFromDom());
|
||||
});
|
||||
updateSelectedObserver();
|
||||
connect();
|
||||
@@ -0,0 +1,256 @@
|
||||
body { font-family: sans-serif; margin: 0; padding: 0 0 6.5rem 0; }
|
||||
|
||||
body.button-editor-open {
|
||||
overflow: hidden;
|
||||
}
|
||||
|
||||
.header { position: relative; }
|
||||
|
||||
.menu-btn {
|
||||
width: 100%;
|
||||
padding: 0.75rem 1rem;
|
||||
font-size: 1rem;
|
||||
cursor: pointer;
|
||||
border: 1px solid #555;
|
||||
border-radius: 0;
|
||||
background: #333;
|
||||
color: #fff;
|
||||
text-align: left;
|
||||
}
|
||||
|
||||
.menu {
|
||||
display: none;
|
||||
position: absolute;
|
||||
top: 100%;
|
||||
left: 0;
|
||||
right: 0;
|
||||
z-index: 10;
|
||||
flex-direction: column;
|
||||
border: 1px solid #555;
|
||||
border-top: none;
|
||||
background: #2a2a2a;
|
||||
box-shadow: 0 4px 8px rgba(0,0,0,0.3);
|
||||
}
|
||||
|
||||
.menu.open { display: flex; }
|
||||
|
||||
.menu-item {
|
||||
padding: 0.75rem 1rem;
|
||||
font-size: 1rem;
|
||||
cursor: pointer;
|
||||
border: none;
|
||||
border-bottom: 1px solid #444;
|
||||
background: transparent;
|
||||
color: #fff;
|
||||
text-align: left;
|
||||
}
|
||||
|
||||
.menu-item:last-child { border-bottom: none; }
|
||||
|
||||
.menu-item:hover { background: #444; }
|
||||
|
||||
.menu-item.off { background: #522; }
|
||||
|
||||
.buttons {
|
||||
display: grid;
|
||||
grid-template-columns: repeat(3, 1fr);
|
||||
gap: 1px;
|
||||
max-height: calc(100vh - 10rem);
|
||||
overflow-y: auto;
|
||||
-webkit-overflow-scrolling: touch;
|
||||
}
|
||||
|
||||
@media (min-width: 768px) {
|
||||
.buttons {
|
||||
grid-template-columns: repeat(6, 1fr);
|
||||
}
|
||||
}
|
||||
.btn {
|
||||
padding: 0.5rem 0.25rem;
|
||||
border: 1px solid #555;
|
||||
border-radius: 0;
|
||||
background: #444;
|
||||
color: #fff;
|
||||
font-size: 1rem;
|
||||
cursor: pointer;
|
||||
min-height: 4.15rem;
|
||||
}
|
||||
.btn.selected {
|
||||
background: #2a7;
|
||||
border-color: #3b8;
|
||||
}
|
||||
|
||||
.btn.dragging { opacity: 0.5; }
|
||||
|
||||
.btn.drop-target { outline: 2px solid #3b8; outline-offset: -2px; }
|
||||
|
||||
.context-menu {
|
||||
position: fixed;
|
||||
z-index: 100;
|
||||
background: #2a2a2a;
|
||||
border: 1px solid #555;
|
||||
box-shadow: 0 4px 12px rgba(0,0,0,0.4);
|
||||
min-width: 8rem;
|
||||
}
|
||||
|
||||
.context-menu-item {
|
||||
display: block;
|
||||
width: 100%;
|
||||
padding: 0.5rem 1rem;
|
||||
border: none;
|
||||
background: transparent;
|
||||
color: #fff;
|
||||
font-size: 1rem;
|
||||
text-align: left;
|
||||
cursor: pointer;
|
||||
}
|
||||
|
||||
.context-menu-item:hover { background: #444; }
|
||||
|
||||
.toast {
|
||||
position: fixed;
|
||||
bottom: 5rem;
|
||||
left: 50%;
|
||||
transform: translateX(-50%) translateY(2rem);
|
||||
padding: 0.5rem 1rem;
|
||||
background: #333;
|
||||
color: #fff;
|
||||
border-radius: 4px;
|
||||
font-size: 0.9rem;
|
||||
z-index: 1000;
|
||||
opacity: 0;
|
||||
transition: opacity 0.2s, transform 0.2s;
|
||||
pointer-events: none;
|
||||
}
|
||||
|
||||
.toast.toast-visible {
|
||||
opacity: 1;
|
||||
transform: translateX(-50%) translateY(0);
|
||||
}
|
||||
.next-btn {
|
||||
position: fixed;
|
||||
bottom: 0;
|
||||
left: 0;
|
||||
right: 0;
|
||||
width: 100%;
|
||||
padding: 2rem 1rem;
|
||||
padding-bottom: max(2rem, env(safe-area-inset-bottom));
|
||||
font-size: 1.25rem;
|
||||
cursor: pointer;
|
||||
border: 2px solid #555;
|
||||
border-radius: 0;
|
||||
background: #333;
|
||||
color: #fff;
|
||||
}
|
||||
|
||||
.preset-editor {
|
||||
position: fixed;
|
||||
inset: 0;
|
||||
background: rgba(0, 0, 0, 0.65);
|
||||
display: none;
|
||||
align-items: center;
|
||||
justify-content: center;
|
||||
z-index: 200;
|
||||
padding: 1rem;
|
||||
}
|
||||
|
||||
.preset-editor.open {
|
||||
display: flex;
|
||||
}
|
||||
|
||||
.preset-editor-inner {
|
||||
width: 100%;
|
||||
max-width: 28rem;
|
||||
max-height: calc(100vh - 4rem);
|
||||
overflow-y: auto;
|
||||
background: #222;
|
||||
border: 1px solid #555;
|
||||
box-shadow: 0 6px 16px rgba(0, 0, 0, 0.6);
|
||||
border-radius: 6px;
|
||||
padding: 1rem 1.25rem 0.75rem;
|
||||
box-sizing: border-box;
|
||||
}
|
||||
|
||||
.preset-editor-title {
|
||||
margin: 0 0 0.75rem;
|
||||
font-size: 1.25rem;
|
||||
color: #fff;
|
||||
}
|
||||
|
||||
.preset-editor-field {
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
margin-bottom: 0.5rem;
|
||||
gap: 0.25rem;
|
||||
font-size: 0.9rem;
|
||||
color: #ddd;
|
||||
}
|
||||
|
||||
.preset-editor-field span {
|
||||
opacity: 0.85;
|
||||
}
|
||||
|
||||
.preset-editor-field input {
|
||||
padding: 0.35rem 0.5rem;
|
||||
border-radius: 4px;
|
||||
border: 1px solid #555;
|
||||
background: #111;
|
||||
color: #fff;
|
||||
font-size: 0.95rem;
|
||||
}
|
||||
|
||||
.preset-editor-row {
|
||||
display: flex;
|
||||
gap: 0.5rem;
|
||||
}
|
||||
|
||||
.preset-editor-field.small {
|
||||
flex: 0 0 48%;
|
||||
}
|
||||
|
||||
.preset-editor-field.small input {
|
||||
padding: 0.25rem 0.4rem;
|
||||
font-size: 0.85rem;
|
||||
}
|
||||
|
||||
.preset-editor-actions {
|
||||
display: flex;
|
||||
flex-wrap: wrap;
|
||||
gap: 0.5rem;
|
||||
margin: 0.75rem 0 0.5rem;
|
||||
}
|
||||
|
||||
.preset-editor-btn {
|
||||
flex: 1;
|
||||
padding: 0.5rem 0.75rem;
|
||||
border-radius: 4px;
|
||||
border: 1px solid #555;
|
||||
background: #333;
|
||||
color: #fff;
|
||||
font-size: 0.95rem;
|
||||
cursor: pointer;
|
||||
}
|
||||
|
||||
.preset-editor-btn.primary {
|
||||
background: #2a7;
|
||||
border-color: #3b8;
|
||||
}
|
||||
|
||||
.preset-editor-btn.danger {
|
||||
background: #722;
|
||||
border-color: #a33;
|
||||
}
|
||||
|
||||
.preset-editor-close {
|
||||
width: 100%;
|
||||
margin-top: 0.25rem;
|
||||
padding: 0.4rem 0.75rem;
|
||||
border-radius: 4px;
|
||||
border: 1px solid #555;
|
||||
background: #111;
|
||||
color: #ccc;
|
||||
font-size: 0.9rem;
|
||||
cursor: pointer;
|
||||
}
|
||||
|
||||
/* preset-list removed with old preset editor */
|
||||
@@ -0,0 +1,145 @@
|
||||
{% args buttons, device_id %}
|
||||
<!DOCTYPE html>
|
||||
<html lang="en">
|
||||
<head>
|
||||
<meta charset="UTF-8" />
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
|
||||
<title>Led Hoop</title>
|
||||
<link rel="stylesheet" href="static/styles.css" />
|
||||
</head>
|
||||
<body data-device-id="{{ device_id }}">
|
||||
<div class="header">
|
||||
<button class="menu-btn" type="button" onclick="toggleMenu()" aria-label="Menu">☰ Menu</button>
|
||||
<div class="menu" id="menu">
|
||||
<button class="menu-item off" type="button" onclick="sendSelect('off', null); closeMenu();">Off</button>
|
||||
<button class="menu-item" type="button" onclick="sendSelect('test', null); closeMenu();">Test</button>
|
||||
<button class="menu-item" type="button" onclick="sendSelect('calibration', null); closeMenu();">Calibration</button>
|
||||
<button class="menu-item" type="button" onclick="closeMenu(); openNewButtonEditor();">Add button</button>
|
||||
<button class="menu-item" type="button" onclick="closeMenu(); saveCurrentButtons();">Save</button>
|
||||
</div>
|
||||
</div>
|
||||
<div class="buttons" id="buttonsContainer">
|
||||
{% for btn in buttons %}
|
||||
<button class="btn" type="button" data-preset="{{ btn['preset'] }}" data-id="{{ btn['id'] }}"
|
||||
draggable="true">{{ btn['id'] }}</button>
|
||||
{% endfor %}
|
||||
</div>
|
||||
|
||||
<div class="preset-editor" id="buttonEditor">
|
||||
<div class="preset-editor-inner">
|
||||
<h2 class="preset-editor-title" id="buttonEditorTitle">Button</h2>
|
||||
<label class="preset-editor-field">
|
||||
<span>Button label</span>
|
||||
<input id="be-label" type="text" placeholder="e.g. grab" />
|
||||
</label>
|
||||
<label class="preset-editor-field">
|
||||
<span>Preset name</span>
|
||||
<input id="be-preset" type="text" placeholder="e.g. grab" />
|
||||
</label>
|
||||
<label class="preset-editor-field">
|
||||
<span>Pattern (p)</span>
|
||||
<select id="be-pattern">
|
||||
<option value="spin">spin</option>
|
||||
<option value="roll">roll</option>
|
||||
<option value="grab">grab</option>
|
||||
<option value="lift">lift</option>
|
||||
<option value="flare">flare</option>
|
||||
<option value="hook">hook</option>
|
||||
<option value="invertsplit">invertsplit</option>
|
||||
<option value="pose">pose</option>
|
||||
<option value="backbalance">backbalance</option>
|
||||
<option value="beat">beat</option>
|
||||
<option value="crouch">crouch</option>
|
||||
<option value="backbendsplit">backbendsplit</option>
|
||||
<option value="straddle">straddle</option>
|
||||
<option value="frontbalance">frontbalance</option>
|
||||
<option value="elbowhang">elbowhang</option>
|
||||
<option value="elbowhangspin">elbowhangspin</option>
|
||||
<option value="dismount">dismount</option>
|
||||
<option value="fluff">fluff</option>
|
||||
<option value="elbowhangsplit">elbowhangsplit</option>
|
||||
<option value="invert">invert</option>
|
||||
<option value="backbend">backbend</option>
|
||||
<option value="seat">seat</option>
|
||||
<option value="kneehang">kneehang</option>
|
||||
<option value="legswoop">legswoop</option>
|
||||
<option value="split">split</option>
|
||||
<option value="foothang">foothang</option>
|
||||
<option value="point">point</option>
|
||||
<option value="off">off</option>
|
||||
<option value="on">on</option>
|
||||
<option value="blink">blink</option>
|
||||
<option value="rainbow">rainbow</option>
|
||||
<option value="pulse">pulse</option>
|
||||
<option value="transition">transition</option>
|
||||
<option value="chase">chase</option>
|
||||
<option value="circle">circle</option>
|
||||
<option value="calibration">calibration</option>
|
||||
<option value="test">test</option>
|
||||
</select>
|
||||
</label>
|
||||
<div class="preset-editor-row">
|
||||
<label class="preset-editor-field">
|
||||
<span>Delay (d)</span>
|
||||
<input id="be-delay" type="number" inputmode="numeric" />
|
||||
</label>
|
||||
<label class="preset-editor-field">
|
||||
<span>Brightness (b)</span>
|
||||
<input id="be-brightness" type="number" inputmode="numeric" min="0" max="255" />
|
||||
</label>
|
||||
</div>
|
||||
<label class="preset-editor-field">
|
||||
<span>Colors (c)</span>
|
||||
<input id="be-colors" type="text" placeholder="r,g,b; r,g,b (0–255)" />
|
||||
</label>
|
||||
<div class="preset-editor-row">
|
||||
<label class="preset-editor-field small">
|
||||
<span>n1</span>
|
||||
<input id="be-n1" type="number" inputmode="numeric" />
|
||||
</label>
|
||||
<label class="preset-editor-field small">
|
||||
<span>n2</span>
|
||||
<input id="be-n2" type="number" inputmode="numeric" />
|
||||
</label>
|
||||
</div>
|
||||
<div class="preset-editor-row">
|
||||
<label class="preset-editor-field small">
|
||||
<span>n3</span>
|
||||
<input id="be-n3" type="number" inputmode="numeric" />
|
||||
</label>
|
||||
<label class="preset-editor-field small">
|
||||
<span>n4</span>
|
||||
<input id="be-n4" type="number" inputmode="numeric" />
|
||||
</label>
|
||||
</div>
|
||||
<div class="preset-editor-row">
|
||||
<label class="preset-editor-field small">
|
||||
<span>n5</span>
|
||||
<input id="be-n5" type="number" inputmode="numeric" />
|
||||
</label>
|
||||
<label class="preset-editor-field small">
|
||||
<span>n6</span>
|
||||
<input id="be-n6" type="number" inputmode="numeric" />
|
||||
</label>
|
||||
</div>
|
||||
<div class="preset-editor-row">
|
||||
<label class="preset-editor-field small">
|
||||
<span>n7</span>
|
||||
<input id="be-n7" type="number" inputmode="numeric" />
|
||||
</label>
|
||||
<label class="preset-editor-field small">
|
||||
<span>n8</span>
|
||||
<input id="be-n8" type="number" inputmode="numeric" />
|
||||
</label>
|
||||
</div>
|
||||
<div class="preset-editor-actions">
|
||||
<button type="button" class="preset-editor-btn primary" onclick="saveButtonFromEditor()">Save</button>
|
||||
<button type="button" class="preset-editor-btn" onclick="closeButtonEditor()">Cancel</button>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<button class="next-btn" type="button" onclick="nextPreset()">Next</button>
|
||||
<script src="static/main.js"></script>
|
||||
</body>
|
||||
</html>
|
||||
@@ -0,0 +1,135 @@
|
||||
from machine import Pin
|
||||
from neopixel import NeoPixel
|
||||
import time
|
||||
import json
|
||||
import os
|
||||
|
||||
BENCHMARK_FILE = "/benchmark.json"
|
||||
PIXEL_FILE = "/pixels.bin"
|
||||
|
||||
NUM_STRIPS = 8
|
||||
LEDS_PER_STRIP = 291
|
||||
BYTES_PER_PIXEL = 3
|
||||
PIXEL_BYTES = NUM_STRIPS * LEDS_PER_STRIP * BYTES_PER_PIXEL
|
||||
|
||||
|
||||
def load_pixels(strips):
|
||||
"""Load pixel buffer from flash into strips. Returns load time ms or None if no file."""
|
||||
try:
|
||||
start = time.ticks_ms()
|
||||
with open(PIXEL_FILE, "rb") as f:
|
||||
buf = f.read()
|
||||
if len(buf) != PIXEL_BYTES:
|
||||
return None
|
||||
ofs = 0
|
||||
for strip in strips:
|
||||
for i in range(LEDS_PER_STRIP):
|
||||
strip[i] = (buf[ofs], buf[ofs + 1], buf[ofs + 2])
|
||||
ofs += BYTES_PER_PIXEL
|
||||
return time.ticks_diff(time.ticks_ms(), start)
|
||||
except OSError:
|
||||
return None
|
||||
|
||||
|
||||
def save_pixels(strips):
|
||||
"""Write current strip pixel data to flash."""
|
||||
buf = bytearray(PIXEL_BYTES)
|
||||
ofs = 0
|
||||
for strip in strips:
|
||||
for i in range(LEDS_PER_STRIP):
|
||||
r, g, b = strip[i]
|
||||
buf[ofs] = r
|
||||
buf[ofs + 1] = g
|
||||
buf[ofs + 2] = b
|
||||
ofs += BYTES_PER_PIXEL
|
||||
with open(PIXEL_FILE, "wb") as f:
|
||||
f.write(buf)
|
||||
print(f"Saved {PIXEL_BYTES} bytes to {PIXEL_FILE}")
|
||||
|
||||
|
||||
def flash_stats(path="/"):
|
||||
"""Return (total_bytes, free_bytes, used_bytes) for the filesystem on flash, or None."""
|
||||
try:
|
||||
s = os.statvfs(path)
|
||||
# f_frsize = fragment size, f_blocks = total blocks, f_bfree = free blocks
|
||||
total = s[1] * s[2] # frsize * blocks
|
||||
free = s[1] * s[3] # frsize * bfree
|
||||
used = total - free
|
||||
return (total, free, used)
|
||||
except OSError:
|
||||
return None
|
||||
|
||||
|
||||
def print_flash():
|
||||
st = flash_stats()
|
||||
if st is None:
|
||||
print("Flash: (statvfs not available)")
|
||||
return
|
||||
total, free, used = st
|
||||
total_k = total // 1024
|
||||
free_k = free // 1024
|
||||
used_k = used // 1024
|
||||
print(f"Flash: {used_k} KB used, {free_k} KB free, {total_k} KB total")
|
||||
|
||||
|
||||
def load_benchmark():
|
||||
try:
|
||||
with open(BENCHMARK_FILE) as f:
|
||||
return json.load(f)
|
||||
except (OSError, ValueError):
|
||||
return None
|
||||
|
||||
|
||||
def save_benchmark(fill_ms, show_ms):
|
||||
try:
|
||||
with open(BENCHMARK_FILE, "w") as f:
|
||||
json.dump({"fill_ms": fill_ms, "show_ms": show_ms}, f)
|
||||
print(f"Saved to {BENCHMARK_FILE}")
|
||||
except OSError as e:
|
||||
print(f"Save failed: {e}")
|
||||
|
||||
|
||||
# set cpu frequency to 240MHz
|
||||
import machine
|
||||
machine.freq(240000000)
|
||||
|
||||
strips = [NeoPixel(Pin(i), 291) for i in range(8)]
|
||||
|
||||
print_flash()
|
||||
|
||||
# load and print previous run
|
||||
prev = load_benchmark()
|
||||
if prev:
|
||||
print(f"Previous: fill {prev['fill_ms']} ms, show {prev['show_ms']} ms")
|
||||
else:
|
||||
print("No previous benchmark stored")
|
||||
|
||||
# optional: time load from flash + show (if we have stored pixels)
|
||||
load_ms = load_pixels(strips)
|
||||
if load_ms is not None:
|
||||
print(f"Load pixels from flash: {load_ms} ms")
|
||||
start = time.ticks_ms()
|
||||
for strip in strips:
|
||||
strip.write()
|
||||
show_ms_loaded = time.ticks_diff(time.ticks_ms(), start)
|
||||
print(f"Show after load: {show_ms_loaded} ms")
|
||||
|
||||
print("Filling strips")
|
||||
start = time.ticks_ms()
|
||||
for i in range(1):
|
||||
for strip in strips:
|
||||
strip.fill((255, 0, 0))
|
||||
end = time.ticks_ms()
|
||||
fill_ms = time.ticks_diff(end, start)
|
||||
print(f"fill time: {fill_ms} ms")
|
||||
|
||||
print("Showing strips")
|
||||
start = time.ticks_ms()
|
||||
for strip in strips:
|
||||
strip.write()
|
||||
end = time.ticks_ms()
|
||||
show_ms = time.ticks_diff(end, start)
|
||||
print(f"show time: {show_ms} ms")
|
||||
|
||||
save_pixels(strips)
|
||||
save_benchmark(fill_ms, show_ms)
|
||||
+20
-3
@@ -93,8 +93,22 @@ class PIO_DMA_Transfer():
|
||||
self.dma_chan.CTRL_TRIG.INCR_WRITE = 0
|
||||
self.dma_chan.CTRL_TRIG.INCR_READ = 1
|
||||
|
||||
def _set_read_addr(self, buffer_or_address, offset=0):
|
||||
if isinstance(buffer_or_address, int):
|
||||
self.dma_chan.READ_ADDR_REG = buffer_or_address + offset
|
||||
else:
|
||||
self.dma_chan.READ_ADDR_REG = uctypes.addressof(buffer_or_address) + offset
|
||||
|
||||
def prepare_transfer(self, buffer_or_address, offset=0):
|
||||
"""Set read address only; do not start. Use with trigger() for parallel start."""
|
||||
self._set_read_addr(buffer_or_address, offset)
|
||||
|
||||
def start_transfer(self, buffer, offset=0):
|
||||
self.dma_chan.READ_ADDR_REG = uctypes.addressof(buffer) + offset
|
||||
self._set_read_addr(buffer, offset)
|
||||
self.dma_chan.CTRL_TRIG.EN = 1
|
||||
|
||||
def trigger(self):
|
||||
"""Start this channel (use after prepare_transfer for parallel start)."""
|
||||
self.dma_chan.CTRL_TRIG.EN = 1
|
||||
|
||||
def transfer_count(self):
|
||||
@@ -105,9 +119,12 @@ class PIO_DMA_Transfer():
|
||||
return True
|
||||
else:
|
||||
return False
|
||||
|
||||
|
||||
|
||||
|
||||
def trigger_channels(dma_transfers):
|
||||
"""Start multiple DMA channels in quick succession (parallel drive)."""
|
||||
for t in dma_transfers:
|
||||
t.trigger()
|
||||
|
||||
|
||||
|
||||
|
||||
+81
-70
@@ -1,70 +1,81 @@
|
||||
|
||||
import array, time
|
||||
from machine import Pin
|
||||
import rp2
|
||||
from time import sleep
|
||||
import dma
|
||||
|
||||
@rp2.asm_pio(sideset_init=rp2.PIO.OUT_LOW, out_shiftdir=rp2.PIO.SHIFT_LEFT, autopull=True, pull_thresh=8)
|
||||
def ws2812():
|
||||
T1 = 2
|
||||
T2 = 5
|
||||
T3 = 3
|
||||
wrap_target()
|
||||
label("bitloop")
|
||||
out(x, 1) .side(0) [T3 - 1]
|
||||
jmp(not_x, "do_zero") .side(1) [T1 - 1]
|
||||
jmp("bitloop") .side(1) [T2 - 1]
|
||||
label("do_zero")
|
||||
nop() .side(0) [T2 - 1]
|
||||
wrap()
|
||||
|
||||
class WS2812B:
|
||||
def __init__(self, num_leds, pin, state_machine, brightness=0.1, invert=False):
|
||||
self.sm = rp2.StateMachine(state_machine, ws2812, freq=8_000_000, sideset_base=Pin(pin))
|
||||
self.sm.active(1)
|
||||
self.ar = bytearray(num_leds*3)
|
||||
self.num_leds = num_leds
|
||||
self.brightness = brightness
|
||||
self.invert = invert
|
||||
self.pio_dma = dma.PIO_DMA_Transfer(state_machine+4, state_machine, 8, num_leds*3)
|
||||
|
||||
def show(self, array=None, offset=0):
|
||||
if array is None:
|
||||
array = self.ar
|
||||
self.pio_dma.start_transfer(array, offset)
|
||||
|
||||
def set(self, i, color):
|
||||
self.ar[i*3] = int(color[1]*self.brightness)
|
||||
self.ar[i*3+1] = int(color[0]*self.brightness)
|
||||
self.ar[i*3+2] = int(color[2]*self.brightness)
|
||||
|
||||
def fill(self, color):
|
||||
for i in range(self.num_leds):
|
||||
self.set(i, color)
|
||||
|
||||
def busy(self):
|
||||
return self.pio_dma.busy()
|
||||
|
||||
BLACK = (0, 0, 0)
|
||||
RED = (255, 0, 0)
|
||||
YELLOW = (255, 150, 0)
|
||||
GREEN = (0, 255, 0)
|
||||
CYAN = (0, 255, 255)
|
||||
BLUE = (0, 0, 255)
|
||||
PURPLE = (180, 0, 255)
|
||||
WHITE = (255, 255, 255)
|
||||
COLORS = (BLACK, RED, YELLOW, GREEN, CYAN, BLUE, PURPLE, WHITE)
|
||||
|
||||
if __name__ == "__main__":
|
||||
num_leds, pin, sm, brightness = 293, 2, 0, 0.1
|
||||
ws0 = WS2812B(num_leds, pin, sm, brightness)
|
||||
while True:
|
||||
for color in ws0.COLORS:
|
||||
ws0.fill(color)
|
||||
ws0.show()
|
||||
time.sleep(1)
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
import array, time
|
||||
from machine import Pin
|
||||
import rp2
|
||||
from time import sleep
|
||||
import dma
|
||||
|
||||
@rp2.asm_pio(sideset_init=rp2.PIO.OUT_LOW, out_shiftdir=rp2.PIO.SHIFT_LEFT, autopull=True, pull_thresh=8)
|
||||
def ws2812():
|
||||
T1 = 2
|
||||
T2 = 5
|
||||
T3 = 3
|
||||
wrap_target()
|
||||
label("bitloop")
|
||||
out(x, 1) .side(0) [T3 - 1]
|
||||
jmp(not_x, "do_zero") .side(1) [T1 - 1]
|
||||
jmp("bitloop") .side(1) [T2 - 1]
|
||||
label("do_zero")
|
||||
nop() .side(0) [T2 - 1]
|
||||
wrap()
|
||||
|
||||
class WS2812B:
|
||||
def __init__(self, num_leds, pin, state_machine, brightness=0.1, invert=False):
|
||||
self.sm = rp2.StateMachine(state_machine, ws2812, freq=8_000_000, sideset_base=Pin(pin))
|
||||
self.sm.active(1)
|
||||
self.ar = bytearray(num_leds*3)
|
||||
self.num_leds = num_leds
|
||||
self.brightness = brightness
|
||||
self.invert = invert
|
||||
self.pio_dma = dma.PIO_DMA_Transfer(state_machine+4, state_machine, 8, num_leds*3)
|
||||
|
||||
|
||||
def show(self, array=None, offset=0):
|
||||
if array is None:
|
||||
array = self.ar
|
||||
self.pio_dma.start_transfer(array, offset)
|
||||
|
||||
def prepare_show(self, buffer_or_address, offset=0):
|
||||
"""Set DMA read address only (buffer or int flash address). Use with trigger() for parallel start."""
|
||||
if buffer_or_address is None:
|
||||
buffer_or_address = self.ar
|
||||
self.pio_dma.prepare_transfer(buffer_or_address, offset)
|
||||
|
||||
def trigger(self):
|
||||
"""Start DMA for this strip (use after prepare_show on all strips for parallel drive)."""
|
||||
self.pio_dma.trigger()
|
||||
|
||||
def set(self, i, color):
|
||||
self.ar[i*3] = int(color[1]*self.brightness)
|
||||
self.ar[i*3+1] = int(color[0]*self.brightness)
|
||||
self.ar[i*3+2] = int(color[2]*self.brightness)
|
||||
|
||||
def fill(self, color):
|
||||
for i in range(self.num_leds):
|
||||
self.set(i, color)
|
||||
|
||||
def busy(self):
|
||||
return self.pio_dma.busy()
|
||||
|
||||
BLACK = (0, 0, 0)
|
||||
RED = (255, 0, 0)
|
||||
YELLOW = (255, 150, 0)
|
||||
GREEN = (0, 255, 0)
|
||||
CYAN = (0, 255, 255)
|
||||
BLUE = (0, 0, 255)
|
||||
PURPLE = (180, 0, 255)
|
||||
WHITE = (255, 255, 255)
|
||||
COLORS = (BLACK, RED, YELLOW, GREEN, CYAN, BLUE, PURPLE, WHITE)
|
||||
|
||||
if __name__ == "__main__":
|
||||
num_leds, pin, sm, brightness = 293, 2, 0, 0.1
|
||||
ws0 = WS2812B(num_leds, pin, sm, brightness)
|
||||
while True:
|
||||
for color in ws0.COLORS:
|
||||
ws0.fill(color)
|
||||
ws0.show()
|
||||
time.sleep(1)
|
||||
|
||||
|
||||
|
||||
|
||||
+56
-92
@@ -1,99 +1,63 @@
|
||||
import sys
|
||||
# So "from ws2812 import WS2812B" finds pico/lib when run from device / or test/
|
||||
if "lib" not in sys.path:
|
||||
sys.path.insert(0, "lib")
|
||||
if "../lib" not in sys.path:
|
||||
sys.path.insert(0, "../lib")
|
||||
from ws2812 import WS2812B
|
||||
import time
|
||||
from machine import UART, Pin
|
||||
import json
|
||||
from presets import Presets
|
||||
import gc
|
||||
|
||||
# --- Rainbow pattern (outside ws2812): pregen double buffer, show via head offset ---
|
||||
uart = UART(0, baudrate=921600, rx=Pin(1, Pin.IN))
|
||||
|
||||
def hue_to_rgb(hue):
|
||||
"""Hue 0..360 -> (r, g, b). Simple HSV with S=V=1."""
|
||||
h = hue % 360
|
||||
x = 1 - abs((h / 60) % 2 - 1)
|
||||
if h < 60:
|
||||
r, g, b = 1, x, 0
|
||||
elif h < 120:
|
||||
r, g, b = x, 1, 0
|
||||
elif h < 180:
|
||||
r, g, b = 0, 1, x
|
||||
elif h < 240:
|
||||
r, g, b = 0, x, 1
|
||||
elif h < 300:
|
||||
r, g, b = x, 0, 1
|
||||
else:
|
||||
r, g, b = 1, 0, x
|
||||
return (int(r * 255), int(g * 255), int(b * 255))
|
||||
presets = Presets()
|
||||
presets.load()
|
||||
|
||||
print(presets.presets.keys())
|
||||
|
||||
def make_rainbow_double(num_leds, brightness=1.0):
|
||||
"""Build 2 full rainbow cycles (2*num_leds pixels, GRB). Returns (double_buf, strip_len).
|
||||
head must be in 0..strip_len-1 so DMA reads double_buf[head:head+strip_len] with no copy."""
|
||||
n = 2 * num_leds
|
||||
double_buf = bytearray(n * 3)
|
||||
for i in range(n):
|
||||
hue = (i / n) * 360 * 2
|
||||
r, g, b = hue_to_rgb(hue)
|
||||
g = int(g * brightness) & 0xFF
|
||||
r = int(r * brightness) & 0xFF
|
||||
b = int(b * brightness) & 0xFF
|
||||
o = i * 3
|
||||
double_buf[o] = g
|
||||
double_buf[o + 1] = r
|
||||
double_buf[o + 2] = b
|
||||
strip_len = num_leds * 3
|
||||
return (double_buf, strip_len)
|
||||
presets.select("off")
|
||||
|
||||
#print memory usage
|
||||
print(f"Memory usage: {gc.mem_free()/1024} kB free")
|
||||
|
||||
def show_rainbow(strip, double_buf, strip_len, head):
|
||||
"""DMA reads directly from double_buf at head; no copy. head in 0..strip_len-1."""
|
||||
strip.show(double_buf, head)
|
||||
|
||||
|
||||
# --- Strips + rainbow buffers per strip ---
|
||||
# Each strip can have a different length; buffers and phase are per-strip.
|
||||
# Strip config must match pico/src/main.py pins.
|
||||
STRIP_CONFIG = (
|
||||
(7, 291),
|
||||
(3, 290),
|
||||
(6, 283),
|
||||
(28, 278),
|
||||
(29, 275),
|
||||
(4, 270),
|
||||
(0, 283),
|
||||
(2, 290),
|
||||
)
|
||||
|
||||
strips = []
|
||||
sm = 0
|
||||
for pin, num_leds in STRIP_CONFIG:
|
||||
print(pin, num_leds)
|
||||
ws = WS2812B(num_leds, pin, sm, brightness=0.2) # 1.0 so fill() is visible
|
||||
strips.append(ws)
|
||||
sm += 1
|
||||
|
||||
# Cumulative LED count before each strip; total ring size
|
||||
cumulative_leds = [0]
|
||||
for ws in strips[:-1]:
|
||||
cumulative_leds.append(cumulative_leds[-1] + ws.num_leds)
|
||||
total_ring_leds = cumulative_leds[-1] + strips[-1].num_leds
|
||||
bytes_per_cycle = total_ring_leds * 3
|
||||
|
||||
# One rainbow double buffer per strip (length = 2 * num_leds for that strip)
|
||||
now = time.ticks_ms()
|
||||
rainbow_data = [make_rainbow_double(ws.num_leds, ws.brightness) for ws in strips]
|
||||
# Global phase in bytes; each strip: head = (phase + cumulative_leds[i]*3) % strip_len[i]
|
||||
print(time.ticks_diff(time.ticks_ms(), now), "ms")
|
||||
rainbow_head = 0
|
||||
step = 3
|
||||
|
||||
i = 0
|
||||
while True:
|
||||
now = time.ticks_ms()
|
||||
for i, (strip, (double_buf, strip_len)) in enumerate(zip(strips, rainbow_data)):
|
||||
head = (rainbow_head + cumulative_leds[i] * 3) % strip_len
|
||||
show_rainbow(strip, double_buf, strip_len, head)
|
||||
rainbow_head = (rainbow_head + step) % bytes_per_cycle
|
||||
#print(time.ticks_diff(time.ticks_ms(), now), "ms")
|
||||
time.sleep_ms(10)
|
||||
presets.tick()
|
||||
if uart.any():
|
||||
data = uart.readline()
|
||||
try:
|
||||
data = json.loads(data)
|
||||
except:
|
||||
# Ignore malformed JSON lines
|
||||
continue
|
||||
|
||||
# Select a preset by name (existing behaviour)
|
||||
preset_name = data.get("select")
|
||||
if preset_name is not None:
|
||||
presets.select(preset_name)
|
||||
presets.tick()
|
||||
|
||||
# Create or update a preset:
|
||||
# {"preset_edit": {"name": "<name>", "data": {<preset_dict>}}}
|
||||
edit_payload = data.get("preset_edit")
|
||||
if isinstance(edit_payload, dict):
|
||||
name = edit_payload.get("name")
|
||||
preset_data = edit_payload.get("data") or {}
|
||||
if isinstance(name, str) and isinstance(preset_data, dict):
|
||||
# Log the incoming preset payload for debugging
|
||||
print("PRESET_EDIT", name, preset_data)
|
||||
presets.edit(name, preset_data)
|
||||
|
||||
# Delete a preset:
|
||||
# {"preset_delete": "<name>"}
|
||||
delete_name = data.get("preset_delete")
|
||||
if isinstance(delete_name, str):
|
||||
print("PRESET_DELETE", delete_name)
|
||||
presets.delete(delete_name)
|
||||
|
||||
# Persist all presets to flash:
|
||||
# {"preset_save": true}
|
||||
if data.get("preset_save"):
|
||||
print("PRESET_SAVE")
|
||||
presets.save()
|
||||
|
||||
print(data)
|
||||
gc.collect()
|
||||
#print used and free memory
|
||||
print(f"Memory usage: {gc.mem_alloc()/1024} kB used, {gc.mem_free()/1024} kB free")
|
||||
|
||||
@@ -1,16 +0,0 @@
|
||||
import asyncio
|
||||
import aioespnow
|
||||
import json
|
||||
|
||||
async def p2p(settings, patterns):
|
||||
e = aioespnow.AIOESPNow() # Returns AIOESPNow enhanced with async support
|
||||
e.active(True)
|
||||
async for mac, msg in e:
|
||||
try:
|
||||
data = json.loads(msg)
|
||||
except:
|
||||
print(f"Failed to load espnow data {msg}")
|
||||
continue
|
||||
|
||||
if "names" not in data or settings.get("name") in data.get("names", []):
|
||||
await settings.set_settings(data.get("settings", {}), patterns, data.get("save", False))
|
||||
@@ -4,3 +4,14 @@ from .pulse import Pulse
|
||||
from .transition import Transition
|
||||
from .chase import Chase
|
||||
from .circle import Circle
|
||||
from .roll import Roll
|
||||
from .calibration import Calibration
|
||||
from .test import Test
|
||||
from .scale_test import ScaleTest
|
||||
from .grab import Grab
|
||||
from .spin import Spin
|
||||
from .lift import Lift
|
||||
from .flare import Flare
|
||||
from .hook import Hook
|
||||
from .pose import Pose
|
||||
from .point import Point
|
||||
@@ -0,0 +1,38 @@
|
||||
"""Calibration: strips 2 and 6 only. First 10 green, then alternating 10 blue / 10 red. 10% brightness."""
|
||||
|
||||
BRIGHTNESS = 0.10
|
||||
BLOCK = 10
|
||||
STRIPS_ON = (2, 6) # 0-based: 3rd and 7th strip only
|
||||
|
||||
GREEN = (0, 255, 0)
|
||||
RED = (255, 0, 0)
|
||||
BLUE = (0, 0, 255)
|
||||
|
||||
|
||||
def _scale(color, factor):
|
||||
return tuple(int(c * factor) for c in color)
|
||||
|
||||
|
||||
class Calibration:
|
||||
def __init__(self, driver):
|
||||
self.driver = driver
|
||||
|
||||
def run(self, preset):
|
||||
strips = self.driver.strips
|
||||
green = _scale(GREEN, BRIGHTNESS)
|
||||
red = _scale(RED, BRIGHTNESS)
|
||||
blue = _scale(BLUE, BRIGHTNESS)
|
||||
on_set = set(STRIPS_ON)
|
||||
for strip_idx, strip in enumerate(strips):
|
||||
n = strip.num_leds
|
||||
if strip_idx not in on_set:
|
||||
strip.fill((0, 0, 0))
|
||||
strip.show()
|
||||
continue
|
||||
for i in range(n):
|
||||
if i < BLOCK:
|
||||
strip.set(i, green)
|
||||
else:
|
||||
block = (i - BLOCK) // BLOCK
|
||||
strip.set(i, blue if block % 2 == 0 else red)
|
||||
strip.show()
|
||||
@@ -0,0 +1,63 @@
|
||||
import utime
|
||||
|
||||
|
||||
class Flare:
|
||||
def __init__(self, driver):
|
||||
self.driver = driver
|
||||
|
||||
def run(self, preset):
|
||||
"""
|
||||
Flare: on the strip used by the first roll head,
|
||||
make the strip fade up to brightness over the delay time.
|
||||
|
||||
- c[0]: color1 for the first n1 LEDs
|
||||
- c[1]: color2 for the rest of the strip
|
||||
- n1: number of LEDs from the start of the strip that use color1
|
||||
- d: fade-in duration in ms (time to reach full preset brightness b)
|
||||
"""
|
||||
strips = self.driver.strips
|
||||
|
||||
# Which strip to flare: last roll head, clamped to valid range
|
||||
strip_idx = getattr(self.driver, "last_roll_head", 0)
|
||||
if strip_idx < 0 or strip_idx >= len(strips):
|
||||
strip_idx = 0
|
||||
|
||||
strip = strips[strip_idx]
|
||||
n = strip.num_leds
|
||||
|
||||
colors = preset.c
|
||||
base_c1 = colors[0] if len(colors) > 0 else (255, 255, 255)
|
||||
base_c2 = colors[1] if len(colors) > 1 else (0, 0, 0)
|
||||
|
||||
count_c1 = max(0, min(int(preset.n1), n))
|
||||
fade_ms = max(1, int(preset.d) or 1)
|
||||
target_b = int(preset.b) if hasattr(preset, "b") else 255
|
||||
|
||||
start_time = utime.ticks_ms()
|
||||
done = False
|
||||
|
||||
while True:
|
||||
now = utime.ticks_ms()
|
||||
elapsed = utime.ticks_diff(now, start_time)
|
||||
|
||||
if not done:
|
||||
if elapsed >= fade_ms:
|
||||
factor = 1.0
|
||||
done = True
|
||||
else:
|
||||
factor = elapsed / fade_ms if fade_ms > 0 else 1.0
|
||||
else:
|
||||
factor = 1.0
|
||||
|
||||
# Effective per-preset brightness scaled over time
|
||||
current_b = int(target_b * factor)
|
||||
|
||||
# Apply global + local brightness to both colors
|
||||
c1 = self.driver.apply_brightness(base_c1, current_b)
|
||||
c2 = self.driver.apply_brightness(base_c2, current_b)
|
||||
|
||||
for i in range(n):
|
||||
strip.set(i, c1 if i < count_c1 else c2)
|
||||
strip.show()
|
||||
|
||||
yield
|
||||
@@ -0,0 +1,26 @@
|
||||
"""Grab: from center of each strip, 10 LEDs each side (21 total) in purple."""
|
||||
|
||||
SPAN = 10 # LEDs on each side of center
|
||||
PURPLE = (180, 0, 255)
|
||||
|
||||
|
||||
class Grab:
|
||||
def __init__(self, driver):
|
||||
self.driver = driver
|
||||
|
||||
def run(self, preset):
|
||||
strips = self.driver.strips
|
||||
for strip_idx, strip in enumerate(strips):
|
||||
n = strip.num_leds
|
||||
mid = self.driver.strip_midpoints[strip_idx]
|
||||
strip.fill((0, 0, 0))
|
||||
start = max(0, mid - SPAN)
|
||||
end = min(n, mid + SPAN + 1)
|
||||
for i in range(start, end):
|
||||
strip.set(i, preset.c[0])
|
||||
|
||||
for strip in strips:
|
||||
strip.show()
|
||||
|
||||
while True:
|
||||
yield
|
||||
@@ -0,0 +1,31 @@
|
||||
"""Hook: light strips n1 to n2 with a segment span long, offset from dead center."""
|
||||
|
||||
class Hook:
|
||||
def __init__(self, driver):
|
||||
self.driver = driver
|
||||
|
||||
def run(self, preset):
|
||||
strips = self.driver.strips
|
||||
midpoints = self.driver.strip_midpoints
|
||||
n1 = max(0, int(preset.n1))
|
||||
n2 = max(n1, int(preset.n2))
|
||||
span = max(0, int(preset.n3))
|
||||
offset = int(preset.n4) # positive = toward one end
|
||||
color = preset.c[0] if preset.c else (0, 0, 0)
|
||||
|
||||
for strip_idx, strip in enumerate(strips):
|
||||
strip.fill((0, 0, 0))
|
||||
if n1 <= strip_idx <= n2:
|
||||
mid = midpoints[strip_idx]
|
||||
n = strip.num_leds
|
||||
center = mid + offset
|
||||
start = max(0, center - span)
|
||||
end = min(n, center + span + 1)
|
||||
for i in range(start, end):
|
||||
strip.set(i, color)
|
||||
|
||||
for strip in strips:
|
||||
strip.show()
|
||||
|
||||
while True:
|
||||
yield
|
||||
@@ -0,0 +1,116 @@
|
||||
"""Lift: opposite of Spin — arms contract from the ends toward the center. Preset color, n1 = rate."""
|
||||
|
||||
import utime
|
||||
|
||||
SPAN = 10 # LEDs on each side of center (match Grab)
|
||||
LUT_SIZE = 256
|
||||
|
||||
|
||||
class Lift:
|
||||
def __init__(self, driver):
|
||||
self.driver = driver
|
||||
|
||||
def run(self, preset):
|
||||
strips = self.driver.strips
|
||||
active_indices = (0, 4)
|
||||
c0 = preset.c[0] if preset.c else (0, 0, 0)
|
||||
c1 = preset.c[1] if len(preset.c) > 1 else c0
|
||||
|
||||
lut = []
|
||||
for k in range(LUT_SIZE):
|
||||
t = k / (LUT_SIZE - 1) if LUT_SIZE > 1 else 1
|
||||
r = int(c0[0] + (c1[0] - c0[0]) * t)
|
||||
g = int(c0[1] + (c1[1] - c0[1]) * t)
|
||||
b = int(c0[2] + (c1[2] - c0[2]) * t)
|
||||
lut.append((r, g, b))
|
||||
|
||||
midpoints = self.driver.strip_midpoints
|
||||
rate = max(1, int(preset.n1) or 1)
|
||||
delay_ms = max(1, int(preset.d) or 1)
|
||||
margin = max(0, int(preset.n2) or 0)
|
||||
|
||||
left = {}
|
||||
right = {}
|
||||
for idx in active_indices:
|
||||
if 0 <= idx < len(strips):
|
||||
strip = strips[idx]
|
||||
n = strip.num_leds
|
||||
mid = midpoints[idx]
|
||||
left[idx] = margin
|
||||
right[idx] = n - margin
|
||||
|
||||
last_update = utime.ticks_ms()
|
||||
|
||||
while True:
|
||||
now = utime.ticks_ms()
|
||||
if utime.ticks_diff(now, last_update) < delay_ms:
|
||||
yield
|
||||
continue
|
||||
last_update = now
|
||||
|
||||
for idx in active_indices:
|
||||
if idx < 0 or idx >= len(strips):
|
||||
continue
|
||||
strip = strips[idx]
|
||||
n = strip.num_leds
|
||||
mid = midpoints[idx]
|
||||
|
||||
step = max(1, rate // 2) if idx == 0 else rate
|
||||
new_left = min(mid - SPAN, left[idx] + step)
|
||||
new_right = max(mid + SPAN + 1, right[idx] - step)
|
||||
|
||||
left_len = max(0, (mid - SPAN) - new_left)
|
||||
right_len = max(0, new_right - (mid + SPAN + 1))
|
||||
bright = strip.brightness
|
||||
ar = strip.ar
|
||||
|
||||
# Clear arm regions to black so contracted pixels turn off
|
||||
for i in range(margin, mid - SPAN):
|
||||
if 0 <= i < n:
|
||||
base = i * 3
|
||||
ar[base] = ar[base + 1] = ar[base + 2] = 0
|
||||
for i in range(mid + SPAN + 1, n - margin):
|
||||
if 0 <= i < n:
|
||||
base = i * 3
|
||||
ar[base] = ar[base + 1] = ar[base + 2] = 0
|
||||
|
||||
for j, i in enumerate(range(new_left, mid - SPAN)):
|
||||
if 0 <= i < n:
|
||||
t = 1 - j / (left_len - 1) if left_len > 1 else 0
|
||||
lut_idx = min(int(t * (LUT_SIZE - 1)), LUT_SIZE - 1)
|
||||
r, g, b = lut[lut_idx]
|
||||
base = i * 3
|
||||
ar[base] = int(g * bright)
|
||||
ar[base + 1] = int(r * bright)
|
||||
ar[base + 2] = int(b * bright)
|
||||
|
||||
for j, i in enumerate(range(mid + SPAN + 1, new_right)):
|
||||
if 0 <= i < n:
|
||||
t = j / (right_len - 1) if right_len > 1 else 0
|
||||
lut_idx = min(int(t * (LUT_SIZE - 1)), LUT_SIZE - 1)
|
||||
r, g, b = lut[lut_idx]
|
||||
base = i * 3
|
||||
ar[base] = int(g * bright)
|
||||
ar[base + 1] = int(r * bright)
|
||||
ar[base + 2] = int(b * bright)
|
||||
|
||||
left[idx] = new_left
|
||||
right[idx] = new_right
|
||||
|
||||
strip.show()
|
||||
|
||||
# Check if all arms have contracted to center - run once, then hold
|
||||
all_done = True
|
||||
for idx in active_indices:
|
||||
if idx < 0 or idx >= len(strips):
|
||||
continue
|
||||
mid = midpoints[idx]
|
||||
if left[idx] < mid - SPAN or right[idx] > mid + SPAN + 1:
|
||||
all_done = False
|
||||
break
|
||||
if all_done:
|
||||
while True:
|
||||
yield
|
||||
return
|
||||
|
||||
yield
|
||||
@@ -0,0 +1,18 @@
|
||||
class Point:
|
||||
def __init__(self, driver):
|
||||
self.driver = driver
|
||||
|
||||
def run(self, preset):
|
||||
# Apply preset/global brightness once per color
|
||||
c1 = self.driver.apply_brightness(preset.c[0], preset.b)
|
||||
c2 = self.driver.apply_brightness(preset.c[1], preset.b)
|
||||
c3 = self.driver.apply_brightness(preset.c[2], preset.b)
|
||||
c4 = self.driver.apply_brightness(preset.c[3], preset.b)
|
||||
|
||||
# Helper to normalize and clamp a range
|
||||
self.driver.fill_n(c1, preset.n1, preset.n2)
|
||||
self.driver.fill_n(c2, preset.n3, preset.n4)
|
||||
self.driver.fill_n(c3, preset.n5, preset.n6)
|
||||
self.driver.fill_n(c4, preset.n7, preset.n8)
|
||||
self.driver.show_all()
|
||||
|
||||
@@ -0,0 +1,75 @@
|
||||
class Pose:
|
||||
def __init__(self, driver):
|
||||
self.driver = driver
|
||||
|
||||
def run(self, preset):
|
||||
"""
|
||||
Pose pattern: simple static bands that turn the hoop on
|
||||
within the specified n ranges, across ALL strips.
|
||||
|
||||
Uses the preset's n values as inclusive ranges over the
|
||||
logical ring (driver.n):
|
||||
|
||||
- n1–n2: color c[0]
|
||||
- n3–n4: color c[1]
|
||||
- n5–n6: color c[2]
|
||||
- n7–n8: color c[3]
|
||||
"""
|
||||
# Base colors (up to 4), missing ones default to black
|
||||
colors = list(preset.c) if getattr(preset, "c", None) else []
|
||||
while len(colors) < 4:
|
||||
colors.append((0, 0, 0))
|
||||
|
||||
# Apply preset/global brightness once per color
|
||||
c1 = self.driver.apply_brightness(colors[0], preset.b)
|
||||
c2 = self.driver.apply_brightness(colors[1], preset.b)
|
||||
c3 = self.driver.apply_brightness(colors[2], preset.b)
|
||||
c4 = self.driver.apply_brightness(colors[3], preset.b)
|
||||
|
||||
# Helper to normalize and clamp a range
|
||||
def norm_range(a, b, max_len):
|
||||
a = int(a)
|
||||
b = int(b)
|
||||
if a > b:
|
||||
a, b = b, a
|
||||
if b < 0 or a >= max_len:
|
||||
return None
|
||||
a = max(0, a)
|
||||
b = min(max_len - 1, b)
|
||||
if a > b:
|
||||
return None
|
||||
return a, b
|
||||
|
||||
# For Pose, apply the same ranges on EVERY strip:
|
||||
# each color band is repeated across all strips.
|
||||
for strip in self.driver.strips:
|
||||
strip_len = strip.num_leds
|
||||
|
||||
ranges = []
|
||||
r1 = norm_range(getattr(preset, "n1", 0), getattr(preset, "n2", -1), strip_len)
|
||||
if r1:
|
||||
ranges.append((r1[0], r1[1], c1))
|
||||
r2 = norm_range(getattr(preset, "n3", 0), getattr(preset, "n4", -1), strip_len)
|
||||
if r2:
|
||||
ranges.append((r2[0], r2[1], c2))
|
||||
r3 = norm_range(getattr(preset, "n5", 0), getattr(preset, "n6", -1), strip_len)
|
||||
if r3:
|
||||
ranges.append((r3[0], r3[1], c3))
|
||||
r4 = norm_range(getattr(preset, "n7", 0), getattr(preset, "n8", -1), strip_len)
|
||||
if r4:
|
||||
ranges.append((r4[0], r4[1], c4))
|
||||
|
||||
# Static draw on this strip: last range wins on overlaps
|
||||
for i in range(strip_len):
|
||||
color = (0, 0, 0)
|
||||
for start, end, c in ranges:
|
||||
if start <= i <= end:
|
||||
color = c
|
||||
strip.set(i, color)
|
||||
|
||||
# Flush all strips
|
||||
for strip in self.driver.strips:
|
||||
strip.show()
|
||||
|
||||
while True:
|
||||
yield
|
||||
@@ -1,51 +1,97 @@
|
||||
import utime
|
||||
|
||||
|
||||
def _hue_to_rgb(hue):
|
||||
"""Hue 0..360 -> (r, g, b). Simple HSV with S=V=1."""
|
||||
h = hue % 360
|
||||
x = 1 - abs((h / 60) % 2 - 1)
|
||||
if h < 60:
|
||||
r, g, b = 1, x, 0
|
||||
elif h < 120:
|
||||
r, g, b = x, 1, 0
|
||||
elif h < 180:
|
||||
r, g, b = 0, 1, x
|
||||
elif h < 240:
|
||||
r, g, b = 0, x, 1
|
||||
elif h < 300:
|
||||
r, g, b = x, 0, 1
|
||||
else:
|
||||
r, g, b = 1, 0, x
|
||||
return (int(r * 255), int(g * 255), int(b * 255))
|
||||
|
||||
|
||||
def _make_rainbow_double(num_leds, brightness=1.0):
|
||||
"""Build 2 full rainbow cycles (2*num_leds pixels, GRB). Returns (double_buf, strip_len_bytes).
|
||||
DMA reads double_buf[head:head+strip_len] with no copy."""
|
||||
n = 2 * num_leds
|
||||
double_buf = bytearray(n * 3)
|
||||
for i in range(n):
|
||||
hue = (i / n) * 360 * 2
|
||||
r, g, b = _hue_to_rgb(hue)
|
||||
double_buf[i * 3] = int(g * brightness) & 0xFF
|
||||
double_buf[i * 3 + 1] = int(r * brightness) & 0xFF
|
||||
double_buf[i * 3 + 2] = int(b * brightness) & 0xFF
|
||||
strip_len_bytes = num_leds * 3
|
||||
return (double_buf, strip_len_bytes)
|
||||
|
||||
|
||||
def _ensure_buffers(driver, preset, buffers_cache):
|
||||
"""Build or refresh per-strip double buffers with current brightness. Returns (rainbow_data, cumulative_bytes)."""
|
||||
effective = (preset.b * driver.b) / (255 * 255)
|
||||
key = (preset.b, driver.b)
|
||||
if buffers_cache.get("key") == key and buffers_cache.get("data"):
|
||||
return buffers_cache["data"], buffers_cache["cumulative_bytes"]
|
||||
strips = driver.strips
|
||||
rainbow_data = [_make_rainbow_double(s.num_leds, effective) for s in strips]
|
||||
cumulative_bytes = [0]
|
||||
for s in strips:
|
||||
cumulative_bytes.append(cumulative_bytes[-1] + s.num_leds * 3)
|
||||
buffers_cache["key"] = key
|
||||
buffers_cache["data"] = rainbow_data
|
||||
buffers_cache["cumulative_bytes"] = cumulative_bytes
|
||||
return rainbow_data, cumulative_bytes
|
||||
|
||||
|
||||
class Rainbow:
|
||||
def __init__(self, driver):
|
||||
self.driver = driver
|
||||
|
||||
def _wheel(self, pos):
|
||||
if pos < 85:
|
||||
return (pos * 3, 255 - pos * 3, 0)
|
||||
elif pos < 170:
|
||||
pos -= 85
|
||||
return (255 - pos * 3, 0, pos * 3)
|
||||
else:
|
||||
pos -= 170
|
||||
return (0, pos * 3, 255 - pos * 3)
|
||||
self._buffers_cache = {}
|
||||
|
||||
def run(self, preset):
|
||||
step = self.driver.step % 256
|
||||
step_amount = max(1, int(preset.n1)) # n1 controls step increment
|
||||
step_amount = max(1, int(preset.n1)) # n1 = bytes to advance per frame (speed)
|
||||
total_ring_bytes = self.driver.num_leds * 3
|
||||
# Phase in bytes; driver.step kept in 0..255 for compatibility
|
||||
phase = (self.driver.step * total_ring_bytes) // 256
|
||||
|
||||
# If auto is False, run a single step and then stop
|
||||
rainbow_data, cumulative_bytes = _ensure_buffers(
|
||||
self.driver, preset, self._buffers_cache
|
||||
)
|
||||
strips = self.driver.strips
|
||||
|
||||
def show_frame(phase):
|
||||
for i, (strip, (double_buf, strip_len_bytes)) in enumerate(zip(strips, rainbow_data)):
|
||||
head = (phase + cumulative_bytes[i]) % strip_len_bytes
|
||||
strip.show(double_buf, head)
|
||||
self.driver.step = (phase * 256) // total_ring_bytes
|
||||
|
||||
# Single step then stop
|
||||
if not preset.a:
|
||||
for i in range(self.driver.num_leds):
|
||||
rc_index = (i * 256 // self.driver.num_leds) + step
|
||||
self.driver.n[i] = self.driver.apply_brightness(self._wheel(rc_index & 255), preset.b)
|
||||
self.driver.n.write()
|
||||
# Increment step by n1 for next manual call
|
||||
self.driver.step = (step + step_amount) % 256
|
||||
# Allow tick() to advance the generator once
|
||||
show_frame(phase)
|
||||
phase = (phase + step_amount) % total_ring_bytes
|
||||
self.driver.step = (phase * 256) // total_ring_bytes
|
||||
yield
|
||||
return
|
||||
|
||||
last_update = utime.ticks_ms()
|
||||
sleep_ms = max(1, int(preset.d))
|
||||
|
||||
while True:
|
||||
current_time = utime.ticks_ms()
|
||||
sleep_ms = max(1, int(preset.d)) # Get delay from preset
|
||||
if utime.ticks_diff(current_time, last_update) >= sleep_ms:
|
||||
for i in range(self.driver.num_leds):
|
||||
rc_index = (i * 256 // self.driver.num_leds) + step
|
||||
self.driver.n[i] = self.driver.apply_brightness(
|
||||
self._wheel(rc_index & 255),
|
||||
preset.b,
|
||||
)
|
||||
self.driver.n.write()
|
||||
step = (step + step_amount) % 256
|
||||
self.driver.step = step
|
||||
rainbow_data, cumulative_bytes = _ensure_buffers(
|
||||
self.driver, preset, self._buffers_cache
|
||||
)
|
||||
show_frame(phase)
|
||||
phase = (phase + step_amount) % total_ring_bytes
|
||||
last_update = current_time
|
||||
# Yield once per tick so other logic can run
|
||||
yield
|
||||
@@ -0,0 +1,154 @@
|
||||
import utime
|
||||
|
||||
|
||||
class Roll:
|
||||
def __init__(self, driver):
|
||||
self.driver = driver
|
||||
|
||||
def run(self, preset):
|
||||
"""Roll: moving band with gradient from color1 to color2 over the strips.
|
||||
|
||||
- n1: offset from start of strip (effective start = start + n1)
|
||||
- n2: offset from end of strip (effective end = end - n2, inclusive)
|
||||
- n3: number of full rotations before stopping (0 = infinite)
|
||||
- n4: direction (0 = clockwise, 1 = anti-clockwise)
|
||||
- c[0]: color1 at the head strip
|
||||
- c[1]: color2 at the tail strip
|
||||
"""
|
||||
colors = preset.c
|
||||
color1_raw = colors[0] if colors else (255, 255, 255)
|
||||
color2_raw = colors[1] if len(colors) > 1 else (0, 0, 0)
|
||||
color1 = self.driver.apply_brightness(color1_raw, preset.b)
|
||||
color2 = self.driver.apply_brightness(color2_raw, preset.b)
|
||||
|
||||
n_segments = self.driver.n.num_strips if hasattr(self.driver.n, "num_strips") else 1
|
||||
# Margins from the start and end of each strip
|
||||
start_margin = max(0, int(getattr(preset, "n1", 0)))
|
||||
end_margin = max(0, int(getattr(preset, "n2", 0)))
|
||||
|
||||
# Debug info to see why roll might be black
|
||||
try:
|
||||
print(
|
||||
"ROLL preset",
|
||||
"p=", getattr(preset, "p", None),
|
||||
"b=", getattr(preset, "b", None),
|
||||
"colors_raw=", color1_raw, color2_raw,
|
||||
"colors_bright=", color1, color2,
|
||||
)
|
||||
print(
|
||||
"ROLL n1..n4",
|
||||
getattr(preset, "n1", None),
|
||||
getattr(preset, "n2", None),
|
||||
getattr(preset, "n3", None),
|
||||
getattr(preset, "n4", None),
|
||||
"n_segments=", n_segments,
|
||||
"start_margin=", start_margin,
|
||||
"end_margin=", end_margin,
|
||||
)
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
# n3: number of rotations (0 = infinite)
|
||||
max_rotations = int(getattr(preset, "n3", 0)) or 0
|
||||
# n4: direction (0=cw, 1=ccw); default clockwise if missing
|
||||
clockwise = int(getattr(preset, "n4", 0)) == 0
|
||||
|
||||
step = self.driver.step
|
||||
delay_ms = max(1, int(preset.d) or 1)
|
||||
last_update = utime.ticks_ms()
|
||||
rotations_done = 0
|
||||
|
||||
def scale_color(c, f):
|
||||
return tuple(int(x * f) for x in c)
|
||||
|
||||
def lerp_color(c1, c2, t):
|
||||
"""Linear gradient between two colors."""
|
||||
if t <= 0:
|
||||
return c1
|
||||
if t >= 1:
|
||||
return c2
|
||||
return (
|
||||
int(c1[0] + (c2[0] - c1[0]) * t),
|
||||
int(c1[1] + (c2[1] - c1[1]) * t),
|
||||
int(c1[2] + (c2[2] - c1[2]) * t),
|
||||
)
|
||||
|
||||
def draw(head):
|
||||
# Remember head strip for flare
|
||||
try:
|
||||
self.driver.last_roll_head = head
|
||||
except AttributeError:
|
||||
pass
|
||||
|
||||
strips_list = self.driver.strips
|
||||
|
||||
for strip_idx, strip in enumerate(strips_list):
|
||||
if strip_idx < 0 or strip_idx >= n_segments:
|
||||
continue
|
||||
|
||||
# Distance from head along direction, 0..n_segments-1
|
||||
if clockwise:
|
||||
dist = (head - strip_idx) % n_segments
|
||||
else:
|
||||
dist = (strip_idx - head) % n_segments
|
||||
|
||||
# Color gradient from color1 at the head strip to color2 at the tail strip
|
||||
if n_segments > 1:
|
||||
t = dist / (n_segments - 1)
|
||||
else:
|
||||
t = 0.0
|
||||
c_strip = lerp_color(color1, color2, t)
|
||||
|
||||
n = strip.num_leds
|
||||
# Effective segment per strip:
|
||||
# start = 0 + start_margin
|
||||
# end = (n - 1) - end_margin (inclusive)
|
||||
width = n - start_margin - end_margin
|
||||
if width <= 0:
|
||||
# If margins are too large, fall back to full strip
|
||||
seg_s = 0
|
||||
seg_e = n
|
||||
else:
|
||||
seg_s = max(0, min(n, start_margin))
|
||||
seg_e = min(n, n - end_margin)
|
||||
|
||||
# Debug for first strip/head to see segment
|
||||
try:
|
||||
if strip_idx == 0 and head == 0:
|
||||
print("ROLL seg strip0 n=", n, "seg_s=", seg_s, "seg_e=", seg_e)
|
||||
except Exception:
|
||||
pass
|
||||
for i in range(n):
|
||||
if seg_s <= i < seg_e:
|
||||
strip.set(i, c_strip)
|
||||
else:
|
||||
strip.set(i, (0, 0, 0))
|
||||
strip.show()
|
||||
|
||||
if not preset.a:
|
||||
head = step % n_segments if n_segments > 0 else 0
|
||||
draw(head)
|
||||
self.driver.step = step + 1
|
||||
yield
|
||||
return
|
||||
|
||||
while True:
|
||||
current_time = utime.ticks_ms()
|
||||
if utime.ticks_diff(current_time, last_update) >= delay_ms:
|
||||
head = step % n_segments if n_segments > 0 else 0
|
||||
if not clockwise and n_segments > 0:
|
||||
head = (n_segments - 1 - head)
|
||||
|
||||
draw(head)
|
||||
step += 1
|
||||
|
||||
if max_rotations > 0 and n_segments > 0 and (step % n_segments) == 0:
|
||||
rotations_done += 1
|
||||
if rotations_done >= max_rotations:
|
||||
self.driver.step = step
|
||||
last_update = current_time
|
||||
return
|
||||
|
||||
self.driver.step = step
|
||||
last_update = current_time
|
||||
yield
|
||||
@@ -0,0 +1,56 @@
|
||||
import utime
|
||||
|
||||
|
||||
RED = (255, 0, 0)
|
||||
|
||||
|
||||
class ScaleTest:
|
||||
"""
|
||||
Animated test for the scale() helper.
|
||||
|
||||
A single red pixel moves along the reference strip (strip 0). For each other
|
||||
strip, the position is mapped using:
|
||||
|
||||
n2 = scale(l1, l2, n1)
|
||||
|
||||
so that all lit pixels stay aligned by proportional position along the strips.
|
||||
"""
|
||||
|
||||
def __init__(self, driver):
|
||||
self.driver = driver
|
||||
|
||||
def run(self, preset):
|
||||
strips = self.driver.strips
|
||||
if not strips:
|
||||
return
|
||||
|
||||
src_strip_idx = 0
|
||||
l1 = self.driver.strip_length(src_strip_idx)
|
||||
if l1 <= 0:
|
||||
return
|
||||
|
||||
step = self.driver.step
|
||||
delay_ms = max(1, int(getattr(preset, "d", 30) or 30))
|
||||
last_update = utime.ticks_ms()
|
||||
color = self.driver.apply_brightness(RED, getattr(preset, "b", 255))
|
||||
|
||||
while True:
|
||||
now = utime.ticks_ms()
|
||||
if utime.ticks_diff(now, last_update) >= delay_ms:
|
||||
n1 = step % l1
|
||||
|
||||
# Clear all strips
|
||||
for strip in strips:
|
||||
strip.fill((0, 0, 0))
|
||||
|
||||
# Light mapped position on each strip using Presets.set/show
|
||||
for dst_strip_idx, _ in enumerate(strips):
|
||||
self.driver.set(dst_strip_idx, n1, color)
|
||||
self.driver.show(dst_strip_idx)
|
||||
|
||||
step += 1
|
||||
self.driver.step = step
|
||||
last_update = now
|
||||
|
||||
yield
|
||||
|
||||
@@ -0,0 +1,98 @@
|
||||
"""Spin: continues from Grab — segment (10 each side of center) moves slowly up to the top. Preset color, n1 = rate."""
|
||||
|
||||
import utime
|
||||
|
||||
SPAN = 10 # LEDs on each side of center (match Grab)
|
||||
LUT_SIZE = 256 # gradient lookup table entries
|
||||
|
||||
|
||||
class Spin:
|
||||
def __init__(self, driver):
|
||||
self.driver = driver
|
||||
|
||||
def run(self, preset):
|
||||
strips = self.driver.strips
|
||||
active_indices = (0, 4)
|
||||
c0 = preset.c[0]
|
||||
c1 = preset.c[1]
|
||||
|
||||
# Precompute gradient LUT: t in [0,1] maps to (r,g,b)
|
||||
lut = []
|
||||
for k in range(LUT_SIZE):
|
||||
t = k / (LUT_SIZE - 1) if LUT_SIZE > 1 else 1
|
||||
r = int(c0[0] + (c1[0] - c0[0]) * t)
|
||||
g = int(c0[1] + (c1[1] - c0[1]) * t)
|
||||
b = int(c0[2] + (c1[2] - c0[2]) * t)
|
||||
lut.append((r, g, b))
|
||||
|
||||
# For each active strip we expand from just outside the grab center
|
||||
# left: from (mid - SPAN) down to 0
|
||||
# right: from (mid + SPAN) up to end
|
||||
midpoints = self.driver.strip_midpoints
|
||||
rate = max(1, int(preset.n1) or 1)
|
||||
delay_ms = max(1, int(preset.d) or 1)
|
||||
margin = max(0, int(preset.n2) or 0)
|
||||
|
||||
# Track current extents of each arm
|
||||
left = {}
|
||||
right = {}
|
||||
for idx in active_indices:
|
||||
if 0 <= idx < len(strips):
|
||||
mid = midpoints[idx]
|
||||
left[idx] = mid - SPAN # inner edge of left arm
|
||||
right[idx] = mid + SPAN + 1 # inner edge of right arm
|
||||
|
||||
last_update = utime.ticks_ms()
|
||||
|
||||
while True:
|
||||
now = utime.ticks_ms()
|
||||
if utime.ticks_diff(now, last_update) < delay_ms:
|
||||
yield
|
||||
continue
|
||||
last_update = now
|
||||
|
||||
for idx in active_indices:
|
||||
if idx < 0 or idx >= len(strips):
|
||||
continue
|
||||
strip = strips[idx]
|
||||
n = strip.num_leds
|
||||
mid = midpoints[idx]
|
||||
|
||||
# Expand arms: inside (strip 1, idx 0) moves slower, outside (strip 5, idx 4) faster
|
||||
step = max(1, rate // 2) if idx == 0 else rate
|
||||
new_left = max(margin, left[idx] - step)
|
||||
new_right = min(n - margin, right[idx] + step)
|
||||
|
||||
# Left arm: c1 at outer, c0 at inner. Right arm: c0 at inner, c1 at outer.
|
||||
left_len = max(0, (mid - SPAN) - new_left)
|
||||
right_len = max(0, new_right - (mid + SPAN + 1))
|
||||
bright = strip.brightness
|
||||
ar = strip.ar
|
||||
|
||||
for j, i in enumerate(range(new_left, mid - SPAN)):
|
||||
if 0 <= i < n:
|
||||
t = 1 - j / (left_len - 1) if left_len > 1 else 0
|
||||
lut_idx = min(int(t * (LUT_SIZE - 1)), LUT_SIZE - 1)
|
||||
r, g, b = lut[lut_idx]
|
||||
base = i * 3
|
||||
ar[base] = int(g * bright)
|
||||
ar[base + 1] = int(r * bright)
|
||||
ar[base + 2] = int(b * bright)
|
||||
|
||||
for j, i in enumerate(range(mid + SPAN + 1, new_right)):
|
||||
if 0 <= i < n:
|
||||
t = j / (right_len - 1) if right_len > 1 else 0
|
||||
lut_idx = min(int(t * (LUT_SIZE - 1)), LUT_SIZE - 1)
|
||||
r, g, b = lut[lut_idx]
|
||||
base = i * 3
|
||||
ar[base] = int(g * bright)
|
||||
ar[base + 1] = int(r * bright)
|
||||
ar[base + 2] = int(b * bright)
|
||||
|
||||
left[idx] = new_left
|
||||
right[idx] = new_right
|
||||
|
||||
# Show only on this strip
|
||||
strip.show()
|
||||
|
||||
yield
|
||||
@@ -0,0 +1,28 @@
|
||||
"""Test pattern: strip i has (i+1) LEDs on at the start (indices 0..i) plus the midpoint LED on. 50% red."""
|
||||
|
||||
BRIGHTNESS = 0.50
|
||||
|
||||
RED = (255, 0, 0)
|
||||
|
||||
|
||||
def _scale(color, factor):
|
||||
return tuple(int(c * factor) for c in color)
|
||||
|
||||
|
||||
class Test:
|
||||
def __init__(self, driver):
|
||||
self.driver = driver
|
||||
|
||||
def run(self, preset):
|
||||
strips = self.driver.strips
|
||||
red = _scale(RED, BRIGHTNESS)
|
||||
for strip_idx, strip in enumerate(strips):
|
||||
n = strip.num_leds
|
||||
mid = self.driver.strip_midpoints[strip_idx] # from STRIP_CONFIG
|
||||
strip.fill((0, 0, 0))
|
||||
# First (strip_idx + 1) LEDs on: indices 0..strip_idx
|
||||
for i in range(min(strip_idx + 1, n)):
|
||||
strip.set(i, red)
|
||||
# Midpoint LED on
|
||||
strip.set(mid, red)
|
||||
strip.show()
|
||||
@@ -12,6 +12,8 @@ class Preset:
|
||||
self.n4 = 0
|
||||
self.n5 = 0
|
||||
self.n6 = 0
|
||||
self.n7 = 0
|
||||
self.n8 = 0
|
||||
|
||||
# Override defaults with provided data
|
||||
self.edit(data)
|
||||
@@ -76,4 +78,6 @@ class Preset:
|
||||
"n4": self.n4,
|
||||
"n5": self.n5,
|
||||
"n6": self.n6,
|
||||
"n7": self.n7,
|
||||
"n8": self.n8,
|
||||
}
|
||||
@@ -0,0 +1,618 @@
|
||||
{
|
||||
"start": {
|
||||
"p": "off",
|
||||
"d": 0,
|
||||
"b": 0,
|
||||
"c": [
|
||||
[0,0,0]
|
||||
],
|
||||
"n1": 0,
|
||||
"n2": 0,
|
||||
"n3": 0,
|
||||
"n4": 0
|
||||
},
|
||||
"grab": {
|
||||
"p": "grab",
|
||||
"d": 0,
|
||||
"b": 0,
|
||||
"c": [
|
||||
[64,0,255]
|
||||
],
|
||||
"n1": 0,
|
||||
"n2": 0,
|
||||
"n3": 0,
|
||||
"n4": 0
|
||||
},
|
||||
"spin1": {
|
||||
"p": "spin",
|
||||
"d": 0,
|
||||
"b": 100,
|
||||
"c": [
|
||||
[64,0,255],
|
||||
[255,105,180]
|
||||
],
|
||||
"n1": 1,
|
||||
"n2": 20,
|
||||
"n3": 0,
|
||||
"n4": 0
|
||||
},
|
||||
"lift": {
|
||||
"p": "lift",
|
||||
"d": 0,
|
||||
"b": 100,
|
||||
"c": [
|
||||
[64,0,255],
|
||||
[255,105,180]
|
||||
],
|
||||
"n1": 1,
|
||||
"n2": 20,
|
||||
"n3": 0,
|
||||
"n4": 0
|
||||
},
|
||||
"flare": {
|
||||
"p": "flare",
|
||||
"d": 0,
|
||||
"b": 0,
|
||||
"c": [
|
||||
[0,0,0]
|
||||
],
|
||||
"n1": 0,
|
||||
"n2": 0,
|
||||
"n3": 0,
|
||||
"n4": 0
|
||||
},
|
||||
"hook": {
|
||||
"p": "hook",
|
||||
"d": 0,
|
||||
"b": 0,
|
||||
"c": [
|
||||
[0,0,0]
|
||||
],
|
||||
"n1": 0,
|
||||
"n2": 7,
|
||||
"n3": 15,
|
||||
"n4": 15
|
||||
},
|
||||
"roll1": {
|
||||
"p": "roll",
|
||||
"d": 200,
|
||||
"b": 100,
|
||||
"c": [
|
||||
[64,0,255],
|
||||
[20,20,40]
|
||||
],
|
||||
"n1": 50,
|
||||
"n2": 160,
|
||||
"n3": 1,
|
||||
"n4": 0
|
||||
},
|
||||
"invertsplit": {
|
||||
"p": "invertsplit",
|
||||
"d": 0,
|
||||
"b": 0,
|
||||
"c": [
|
||||
[0,0,0]
|
||||
],
|
||||
"n1": 0,
|
||||
"n2": 0,
|
||||
"n3": 0,
|
||||
"n4": 0
|
||||
},
|
||||
"pose1": {
|
||||
"p": "point",
|
||||
"d": 0,
|
||||
"b": 220,
|
||||
"c": [
|
||||
[255,0,0],
|
||||
[0,255,0],
|
||||
[0,0,255],
|
||||
[255,255,255]
|
||||
],
|
||||
"n1": 100,
|
||||
"n2": 150,
|
||||
"n3": 650,
|
||||
"n4": 700,
|
||||
"n5": 1200,
|
||||
"n6": 1250,
|
||||
"n7": 1750,
|
||||
"n8": 1800
|
||||
},
|
||||
"pose2": {
|
||||
"p": "point",
|
||||
"d": 0,
|
||||
"b": 220,
|
||||
"c": [
|
||||
[255,105,180],
|
||||
[64,0,255],
|
||||
[255,165,0],
|
||||
[0,255,255]
|
||||
],
|
||||
"n1": 150,
|
||||
"n2": 200,
|
||||
"n3": 700,
|
||||
"n4": 750,
|
||||
"n5": 1250,
|
||||
"n6": 1300,
|
||||
"n7": 1800,
|
||||
"n8": 1850
|
||||
},
|
||||
"roll2": {
|
||||
"p": "roll",
|
||||
"d": 0,
|
||||
"b": 0,
|
||||
"c": [
|
||||
[0,0,0]
|
||||
],
|
||||
"n1": 0,
|
||||
"n2": 0,
|
||||
"n3": 0,
|
||||
"n4": 0
|
||||
},
|
||||
"backbalance1": {
|
||||
"p": "backbalance",
|
||||
"d": 0,
|
||||
"b": 0,
|
||||
"c": [
|
||||
[0,0,0]
|
||||
],
|
||||
"n1": 0,
|
||||
"n2": 0,
|
||||
"n3": 0,
|
||||
"n4": 0
|
||||
},
|
||||
"beat1": {
|
||||
"p": "beat",
|
||||
"d": 0,
|
||||
"b": 0,
|
||||
"c": [
|
||||
[0,0,0]
|
||||
],
|
||||
"n1": 0,
|
||||
"n2": 0,
|
||||
"n3": 0,
|
||||
"n4": 0
|
||||
},
|
||||
"pose3": {
|
||||
"p": "point",
|
||||
"d": 0,
|
||||
"b": 220,
|
||||
"c": [
|
||||
[255,255,0],
|
||||
[255,0,255],
|
||||
[0,255,255],
|
||||
[255,255,255]
|
||||
],
|
||||
"n1": 200,
|
||||
"n2": 250,
|
||||
"n3": 750,
|
||||
"n4": 800,
|
||||
"n5": 1300,
|
||||
"n6": 1350,
|
||||
"n7": 1850,
|
||||
"n8": 1900
|
||||
},
|
||||
"roll3": {
|
||||
"p": "roll",
|
||||
"d": 0,
|
||||
"b": 0,
|
||||
"c": [
|
||||
[0,0,0]
|
||||
],
|
||||
"n1": 0,
|
||||
"n2": 0,
|
||||
"n3": 0,
|
||||
"n4": 0
|
||||
},
|
||||
"crouch": {
|
||||
"p": "crouch",
|
||||
"d": 0,
|
||||
"b": 0,
|
||||
"c": [
|
||||
[0,0,0]
|
||||
],
|
||||
"n1": 0,
|
||||
"n2": 0,
|
||||
"n3": 0,
|
||||
"n4": 0
|
||||
},
|
||||
"pose4": {
|
||||
"p": "point",
|
||||
"d": 0,
|
||||
"b": 220,
|
||||
"c": [
|
||||
[64,0,255],
|
||||
[255,105,180],
|
||||
[255,255,255],
|
||||
[255,140,0]
|
||||
],
|
||||
"n1": 250,
|
||||
"n2": 300,
|
||||
"n3": 800,
|
||||
"n4": 850,
|
||||
"n5": 1350,
|
||||
"n6": 1400,
|
||||
"n7": 1900,
|
||||
"n8": 1950
|
||||
},
|
||||
"roll4": {
|
||||
"p": "roll",
|
||||
"d": 0,
|
||||
"b": 0,
|
||||
"c": [
|
||||
[0,0,0]
|
||||
],
|
||||
"n1": 0,
|
||||
"n2": 0,
|
||||
"n3": 0,
|
||||
"n4": 0
|
||||
},
|
||||
"backbendsplit": {
|
||||
"p": "backbendsplit",
|
||||
"d": 0,
|
||||
"b": 0,
|
||||
"c": [
|
||||
[0,0,0]
|
||||
],
|
||||
"n1": 0,
|
||||
"n2": 0,
|
||||
"n3": 0,
|
||||
"n4": 0
|
||||
},
|
||||
"backbalance2": {
|
||||
"p": "backbalance",
|
||||
"d": 0,
|
||||
"b": 0,
|
||||
"c": [
|
||||
[0,0,0]
|
||||
],
|
||||
"n1": 0,
|
||||
"n2": 0,
|
||||
"n3": 0,
|
||||
"n4": 0
|
||||
},
|
||||
"backbalance3": {
|
||||
"p": "backbalance",
|
||||
"d": 0,
|
||||
"b": 0,
|
||||
"c": [
|
||||
[0,0,0]
|
||||
],
|
||||
"n1": 0,
|
||||
"n2": 0,
|
||||
"n3": 0,
|
||||
"n4": 0
|
||||
},
|
||||
"beat2": {
|
||||
"p": "beat",
|
||||
"d": 0,
|
||||
"b": 0,
|
||||
"c": [
|
||||
[0,0,0]
|
||||
],
|
||||
"n1": 0,
|
||||
"n2": 0,
|
||||
"n3": 0,
|
||||
"n4": 0
|
||||
},
|
||||
"straddle": {
|
||||
"p": "straddle",
|
||||
"d": 0,
|
||||
"b": 0,
|
||||
"c": [
|
||||
[0,0,0]
|
||||
],
|
||||
"n1": 0,
|
||||
"n2": 0,
|
||||
"n3": 0,
|
||||
"n4": 0
|
||||
},
|
||||
"beat3": {
|
||||
"p": "beat",
|
||||
"d": 0,
|
||||
"b": 0,
|
||||
"c": [
|
||||
[0,0,0]
|
||||
],
|
||||
"n1": 0,
|
||||
"n2": 0,
|
||||
"n3": 0,
|
||||
"n4": 0
|
||||
},
|
||||
"frontbalance1": {
|
||||
"p": "frontbalance",
|
||||
"d": 0,
|
||||
"b": 0,
|
||||
"c": [
|
||||
[0,0,0]
|
||||
],
|
||||
"n1": 0,
|
||||
"n2": 0,
|
||||
"n3": 0,
|
||||
"n4": 0
|
||||
},
|
||||
"pose5": {
|
||||
"p": "point",
|
||||
"d": 0,
|
||||
"b": 220,
|
||||
"c": [
|
||||
[255,0,127],
|
||||
[0,127,255],
|
||||
[127,255,0],
|
||||
[255,255,255]
|
||||
],
|
||||
"n1": 300,
|
||||
"n2": 350,
|
||||
"n3": 850,
|
||||
"n4": 900,
|
||||
"n5": 1400,
|
||||
"n6": 1450,
|
||||
"n7": 1950,
|
||||
"n8": 2000
|
||||
},
|
||||
"pose6": {
|
||||
"p": "point",
|
||||
"d": 0,
|
||||
"b": 220,
|
||||
"c": [
|
||||
[255,80,0],
|
||||
[0,200,120],
|
||||
[80,0,255],
|
||||
[255,255,255]
|
||||
],
|
||||
"n1": 350,
|
||||
"n2": 400,
|
||||
"n3": 900,
|
||||
"n4": 950,
|
||||
"n5": 1450,
|
||||
"n6": 1500,
|
||||
"n7": 2000,
|
||||
"n8": 2050
|
||||
},
|
||||
"elbowhang": {
|
||||
"p": "elbowhang",
|
||||
"d": 0,
|
||||
"b": 0,
|
||||
"c": [
|
||||
[0,0,0]
|
||||
],
|
||||
"n1": 0,
|
||||
"n2": 0,
|
||||
"n3": 0,
|
||||
"n4": 0
|
||||
},
|
||||
"elbowhangspin": {
|
||||
"p": "elbowhangspin",
|
||||
"d": 0,
|
||||
"b": 0,
|
||||
"c": [
|
||||
[0,0,0]
|
||||
],
|
||||
"n1": 0,
|
||||
"n2": 0,
|
||||
"n3": 0,
|
||||
"n4": 0
|
||||
},
|
||||
"spin2": {
|
||||
"p": "spin",
|
||||
"d": 0,
|
||||
"b": 0,
|
||||
"c": [
|
||||
[0,0,0]
|
||||
],
|
||||
"n1": 0,
|
||||
"n2": 0,
|
||||
"n3": 0,
|
||||
"n4": 0
|
||||
},
|
||||
"dismount": {
|
||||
"p": "dismount",
|
||||
"d": 0,
|
||||
"b": 0,
|
||||
"c": [
|
||||
[0,0,0]
|
||||
],
|
||||
"n1": 0,
|
||||
"n2": 0,
|
||||
"n3": 0,
|
||||
"n4": 0
|
||||
},
|
||||
"spin3": {
|
||||
"p": "spin",
|
||||
"d": 0,
|
||||
"b": 0,
|
||||
"c": [
|
||||
[0,0,0]
|
||||
],
|
||||
"n1": 0,
|
||||
"n2": 0,
|
||||
"n3": 0,
|
||||
"n4": 0
|
||||
},
|
||||
"fluff": {
|
||||
"p": "fluff",
|
||||
"d": 0,
|
||||
"b": 0,
|
||||
"c": [
|
||||
[0,0,0]
|
||||
],
|
||||
"n1": 0,
|
||||
"n2": 0,
|
||||
"n3": 0,
|
||||
"n4": 0
|
||||
},
|
||||
"spin4": {
|
||||
"p": "spin",
|
||||
"d": 0,
|
||||
"b": 0,
|
||||
"c": [
|
||||
[0,0,0]
|
||||
],
|
||||
"n1": 0,
|
||||
"n2": 0,
|
||||
"n3": 0,
|
||||
"n4": 0
|
||||
},
|
||||
"flare2": {
|
||||
"p": "flare",
|
||||
"d": 0,
|
||||
"b": 0,
|
||||
"c": [
|
||||
[0,0,0]
|
||||
],
|
||||
"n1": 0,
|
||||
"n2": 0,
|
||||
"n3": 0,
|
||||
"n4": 0
|
||||
},
|
||||
"elbowhangsplit2": {
|
||||
"p": "elbowhangsplit",
|
||||
"d": 0,
|
||||
"b": 0,
|
||||
"c": [
|
||||
[0,0,0]
|
||||
],
|
||||
"n1": 0,
|
||||
"n2": 0,
|
||||
"n3": 0,
|
||||
"n4": 0
|
||||
},
|
||||
"invert": {
|
||||
"p": "invert",
|
||||
"d": 0,
|
||||
"b": 0,
|
||||
"c": [
|
||||
[0,0,0]
|
||||
],
|
||||
"n1": 0,
|
||||
"n2": 0,
|
||||
"n3": 0,
|
||||
"n4": 0
|
||||
},
|
||||
"roll5": {
|
||||
"p": "roll",
|
||||
"d": 0,
|
||||
"b": 0,
|
||||
"c": [
|
||||
[0,0,0]
|
||||
],
|
||||
"n1": 0,
|
||||
"n2": 0,
|
||||
"n3": 0,
|
||||
"n4": 0
|
||||
},
|
||||
"backbend": {
|
||||
"p": "backbend",
|
||||
"d": 0,
|
||||
"b": 0,
|
||||
"c": [
|
||||
[0,0,0]
|
||||
],
|
||||
"n1": 0,
|
||||
"n2": 0,
|
||||
"n3": 0,
|
||||
"n4": 0
|
||||
},
|
||||
"pose7": {
|
||||
"p": "point",
|
||||
"d": 0,
|
||||
"b": 220,
|
||||
"c": [
|
||||
[255,0,0],
|
||||
[255,165,0],
|
||||
[255,255,0],
|
||||
[255,255,255]
|
||||
],
|
||||
"n1": 400,
|
||||
"n2": 450,
|
||||
"n3": 950,
|
||||
"n4": 1000,
|
||||
"n5": 1500,
|
||||
"n6": 1550,
|
||||
"n7": 2050,
|
||||
"n8": 2100
|
||||
},
|
||||
"roll6": {
|
||||
"p": "roll",
|
||||
"d": 0,
|
||||
"b": 0,
|
||||
"c": [
|
||||
[0,0,0]
|
||||
],
|
||||
"n1": 0,
|
||||
"n2": 0,
|
||||
"n3": 0,
|
||||
"n4": 0
|
||||
},
|
||||
"seat": {
|
||||
"p": "seat",
|
||||
"d": 0,
|
||||
"b": 0,
|
||||
"c": [
|
||||
[0,0,0]
|
||||
],
|
||||
"n1": 0,
|
||||
"n2": 0,
|
||||
"n3": 0,
|
||||
"n4": 0
|
||||
},
|
||||
"kneehang": {
|
||||
"p": "kneehang",
|
||||
"d": 0,
|
||||
"b": 0,
|
||||
"c": [
|
||||
[0,0,0]
|
||||
],
|
||||
"n1": 0,
|
||||
"n2": 0,
|
||||
"n3": 0,
|
||||
"n4": 0
|
||||
},
|
||||
"legswoop": {
|
||||
"p": "legswoop",
|
||||
"d": 0,
|
||||
"b": 0,
|
||||
"c": [
|
||||
[0,0,0]
|
||||
],
|
||||
"n1": 0,
|
||||
"n2": 0,
|
||||
"n3": 0,
|
||||
"n4": 0
|
||||
},
|
||||
"split": {
|
||||
"p": "split",
|
||||
"d": 0,
|
||||
"b": 0,
|
||||
"c": [
|
||||
[0,0,0]
|
||||
],
|
||||
"n1": 0,
|
||||
"n2": 0,
|
||||
"n3": 0,
|
||||
"n4": 0
|
||||
},
|
||||
"foothang": {
|
||||
"p": "foothang",
|
||||
"d": 0,
|
||||
"b": 0,
|
||||
"c": [
|
||||
[0,0,0]
|
||||
],
|
||||
"n1": 0,
|
||||
"n2": 0,
|
||||
"n3": 0,
|
||||
"n4": 0
|
||||
},
|
||||
"end": {
|
||||
"p": "off",
|
||||
"d": 0,
|
||||
"b": 0,
|
||||
"c": [
|
||||
[0,0,0]
|
||||
],
|
||||
"n1": 0,
|
||||
"n2": 0,
|
||||
"n3": 0,
|
||||
"n4": 0
|
||||
}
|
||||
}
|
||||
+109
-33
@@ -1,20 +1,45 @@
|
||||
from machine import Pin
|
||||
from ws2812 import WS2812B
|
||||
import dma
|
||||
from preset import Preset
|
||||
from patterns import Blink, Rainbow, Pulse, Transition, Chase, Circle
|
||||
from patterns import (
|
||||
Blink, Rainbow, Pulse, Transition, Chase, Circle, Roll, Calibration, Test,
|
||||
Grab, Spin, Lift, Flare, Hook, Pose, Point,
|
||||
)
|
||||
import json
|
||||
|
||||
# Order: strips[0]=physical 1 … strips[7]=physical 8. (pin, num_leds, midpoint_index).
|
||||
STRIP_CONFIG = (
|
||||
(6, 291, 291 // 2), # 1
|
||||
(29, 290, 290 // 2-1), # 2
|
||||
(3, 283, 283 // 2), # 3
|
||||
(28, 278, 278 // 2-1), # 4
|
||||
(2, 278, 275 // 2), # 5 (bottom of hoop)
|
||||
(0, 283, 278 // 2-1), # 6
|
||||
(4, 290, 283 // 2), # 7
|
||||
(7, 291, 290 // 2-1), # 8
|
||||
)
|
||||
|
||||
class Presets:
|
||||
def __init__(self, pin, num_leds, state_machine=0):
|
||||
def __init__(self):
|
||||
self.scale_map = []
|
||||
self.strips = []
|
||||
self.strip_midpoints = [] # midpoint LED index per strip (from STRIP_CONFIG)
|
||||
|
||||
state_machine = 0
|
||||
for entry in STRIP_CONFIG:
|
||||
pin, num_leds = entry[0], entry[1]
|
||||
mid = entry[2] if len(entry) >= 3 else num_leds // 2
|
||||
self.strip_midpoints.append(mid)
|
||||
self.strips.append(WS2812B(num_leds, pin, state_machine, brightness=1.0))
|
||||
state_machine += 1
|
||||
self.scale_map.append(self.create_scale_map(num_leds))
|
||||
|
||||
# Single logical strip over all 8 strips for patterns (n[i], .fill(), .write())
|
||||
# WS2812B with brightness=1.0 so Presets.apply_brightness() does all scaling (NeoPixel drop-in)
|
||||
num_leds = int(num_leds)
|
||||
if isinstance(pin, Pin):
|
||||
self.n = WS2812B(pin, num_leds) # NeoPixel-style (Pin, n)
|
||||
else:
|
||||
self.n = WS2812B(num_leds, int(pin), state_machine, brightness=1.0)
|
||||
self.num_leds = num_leds
|
||||
self.step = 0
|
||||
# Remember which strip was last used as the roll head (for flare, etc.)
|
||||
self.last_roll_head = 0
|
||||
# Global brightness (0–255), controlled via UART/JSON {"b": <value>}
|
||||
self.b = 255
|
||||
|
||||
@@ -32,8 +57,26 @@ class Presets:
|
||||
"transition": Transition(self).run,
|
||||
"chase": Chase(self).run,
|
||||
"circle": Circle(self).run,
|
||||
"roll": Roll(self).run,
|
||||
"calibration": Calibration(self).run,
|
||||
"test": Test(self).run,
|
||||
"grab": Grab(self).run,
|
||||
"spin": Spin(self).run,
|
||||
"lift": Lift(self).run,
|
||||
"flare": Flare(self).run,
|
||||
"hook": Hook(self).run,
|
||||
"pose": Pose(self).run,
|
||||
"point": Point(self).run,
|
||||
}
|
||||
|
||||
# --- Strip geometry utilities -------------------------------------------------
|
||||
|
||||
def strip_length(self, strip_idx):
|
||||
"""Return number of LEDs for a physical strip index."""
|
||||
if 0 <= strip_idx < len(self.strips):
|
||||
return self.strips[strip_idx].num_leds
|
||||
return 0
|
||||
|
||||
def save(self):
|
||||
"""Save the presets to a file."""
|
||||
with open("presets.json", "w") as f:
|
||||
@@ -87,27 +130,26 @@ class Presets:
|
||||
self.generator = None
|
||||
|
||||
def select(self, preset_name, step=None):
|
||||
if preset_name is None:
|
||||
return False
|
||||
print(f"Selecting preset: {preset_name}")
|
||||
preset = None
|
||||
pattern_key = preset_name
|
||||
if preset_name in self.presets:
|
||||
preset = self.presets[preset_name]
|
||||
if preset.p in self.patterns:
|
||||
# Set step value if explicitly provided
|
||||
if step is not None:
|
||||
self.step = step
|
||||
elif preset.p == "off" or self.selected != preset_name:
|
||||
self.step = 0
|
||||
self.generator = self.patterns[preset.p](preset)
|
||||
self.selected = preset_name # Store the preset name, not the object
|
||||
return True
|
||||
# If preset doesn't exist or pattern not found, default to "off"
|
||||
return False
|
||||
|
||||
def update_num_leds(self, pin, num_leds):
|
||||
num_leds = int(num_leds)
|
||||
if isinstance(pin, Pin):
|
||||
self.n = WS2812B(pin, num_leds)
|
||||
else:
|
||||
self.n = WS2812B(num_leds, int(pin), 0, brightness=1.0)
|
||||
self.num_leds = num_leds
|
||||
pattern_key = preset.p
|
||||
if pattern_key not in self.patterns:
|
||||
return False
|
||||
# Run by pattern name (works for saved presets and built-ins like calibration, off, test)
|
||||
if preset is None:
|
||||
preset = Preset({"p": pattern_key}) if pattern_key != "off" else None
|
||||
if step is not None:
|
||||
self.step = step
|
||||
elif pattern_key == "off" or self.selected != preset_name:
|
||||
self.step = 0
|
||||
self.generator = self.patterns[pattern_key](preset)
|
||||
self.selected = preset_name
|
||||
return True
|
||||
|
||||
def apply_brightness(self, color, brightness_override=None):
|
||||
# Combine per-preset brightness (override) with global brightness self.b
|
||||
@@ -116,12 +158,6 @@ class Presets:
|
||||
effective_brightness = int(local * self.b / 255)
|
||||
return tuple(int(c * effective_brightness / 255) for c in color)
|
||||
|
||||
def fill(self, color=None):
|
||||
fill_color = color if color is not None else (0, 0, 0)
|
||||
for i in range(self.num_leds):
|
||||
self.n[i] = fill_color
|
||||
self.n.write()
|
||||
|
||||
def off(self, preset=None):
|
||||
self.fill((0, 0, 0))
|
||||
|
||||
@@ -129,3 +165,43 @@ class Presets:
|
||||
colors = preset.c
|
||||
color = colors[0] if colors else (255, 255, 255)
|
||||
self.fill(self.apply_brightness(color, preset.b))
|
||||
|
||||
def fill(self, color):
|
||||
for strip in self.strips:
|
||||
strip.fill(color)
|
||||
|
||||
def fill_n(self, color, n1, n2):
|
||||
for i in range(n1, n2):
|
||||
for strip_idx in range(8):
|
||||
self.set(strip_idx, i, color)
|
||||
|
||||
|
||||
def set(self, strip, index, color):
|
||||
if index >= self.strips[0].num_leds:
|
||||
return False
|
||||
self.strips[strip].set(self.scale_map[strip][index], color)
|
||||
return True
|
||||
|
||||
def create_scale_map(self, num_leds):
|
||||
ref_len = STRIP_CONFIG[0][1]
|
||||
return [int(i * num_leds / ref_len) for i in range(ref_len)]
|
||||
|
||||
def show_all(self):
|
||||
for strip in self.strips:
|
||||
strip.show()
|
||||
|
||||
def show_all_parallel(self):
|
||||
"""Drive all 8 strips at once: PIO+DMA, trigger all channels in quick succession."""
|
||||
for strip in self.strips:
|
||||
strip.prepare_show(None, 0) # use strip's own buffer
|
||||
dma.trigger_channels([s.pio_dma for s in self.strips])
|
||||
|
||||
def show_all_parallel_from_flash(self, flash_base_address):
|
||||
"""Drive all 8 strips from flash at once. flash_base_address = start of contiguous pixel data.
|
||||
Layout in flash: strip0 pixels (n0*3 bytes), strip1 (n1*3), ... in order.
|
||||
In MicroPython you can use uctypes.addressof(bytes_obj) if the bytes live in flash (e.g. const)."""
|
||||
offset = 0
|
||||
for strip in self.strips:
|
||||
strip.prepare_show(flash_base_address, offset)
|
||||
offset += strip.num_leds * 3
|
||||
dma.trigger_channels([s.pio_dma for s in self.strips])
|
||||
@@ -1,94 +0,0 @@
|
||||
import json
|
||||
import ubinascii
|
||||
import machine
|
||||
|
||||
class Settings(dict):
|
||||
SETTINGS_FILE = "/settings.json"
|
||||
|
||||
def __init__(self):
|
||||
super().__init__()
|
||||
self.load() # Load settings from file during initialization
|
||||
self.color_order = self.get_color_order(self["color_order"])
|
||||
|
||||
def _default_name(self):
|
||||
"""Device name: use unique_id on Pico (no WiFi); use AP MAC on ESP32."""
|
||||
try:
|
||||
import network
|
||||
mac = network.WLAN(network.AP_IF).config("mac")
|
||||
return "led-%s" % ubinascii.hexlify(mac).decode()
|
||||
except Exception:
|
||||
return "led-%s" % ubinascii.hexlify(machine.unique_id()).decode()
|
||||
|
||||
def set_defaults(self):
|
||||
self["led_pin"] = 10
|
||||
self["num_leds"] = 50
|
||||
self["color_order"] = "rgb"
|
||||
self["name"] = self._default_name()
|
||||
self["debug"] = False
|
||||
self["startup_preset"] = None
|
||||
self["brightness"] = 255
|
||||
|
||||
def save(self):
|
||||
try:
|
||||
j = json.dumps(self)
|
||||
with open(self.SETTINGS_FILE, 'w') as file:
|
||||
file.write(j)
|
||||
print("Settings saved successfully.")
|
||||
except Exception as e:
|
||||
print(f"Error saving settings: {e}")
|
||||
|
||||
def load(self):
|
||||
try:
|
||||
with open(self.SETTINGS_FILE, 'r') as file:
|
||||
loaded_settings = json.load(file)
|
||||
self.update(loaded_settings)
|
||||
print("Settings loaded successfully.")
|
||||
except Exception as e:
|
||||
print(f"Error loading settings")
|
||||
self.set_defaults()
|
||||
self.save()
|
||||
|
||||
|
||||
def get_color_order(self, color_order):
|
||||
"""Convert color order string to tuple of hex string indices."""
|
||||
color_orders = {
|
||||
"rgb": (1, 3, 5),
|
||||
"rbg": (1, 5, 3),
|
||||
"grb": (3, 1, 5),
|
||||
"gbr": (3, 5, 1),
|
||||
"brg": (5, 1, 3),
|
||||
"bgr": (5, 3, 1)
|
||||
}
|
||||
return color_orders.get(color_order.lower(), (1, 3, 5)) # Default to RGB
|
||||
|
||||
def get_rgb_channel_order(self, color_order=None):
|
||||
"""Convert color order string to RGB channel indices for reordering tuples.
|
||||
Returns tuple of channel indices: (r_channel, g_channel, b_channel)
|
||||
Example: 'grb' -> (1, 0, 2) means (G, R, B)"""
|
||||
if color_order is None:
|
||||
color_order = self.get("color_order", "rgb")
|
||||
color_order = color_order.lower()
|
||||
# Map hex string positions to RGB channel indices
|
||||
# Position 1 (R in hex) -> channel 0, Position 3 (G) -> channel 1, Position 5 (B) -> channel 2
|
||||
hex_to_channel = {1: 0, 3: 1, 5: 2}
|
||||
hex_indices = self.get_color_order(color_order)
|
||||
return tuple(hex_to_channel[pos] for pos in hex_indices)
|
||||
|
||||
# Example usage
|
||||
def main():
|
||||
settings = Settings()
|
||||
print(f"Number of LEDs: {settings['num_leds']}")
|
||||
settings['num_leds'] = 100
|
||||
print(f"Updated number of LEDs: {settings['num_leds']}")
|
||||
settings.save()
|
||||
|
||||
# Create a new Settings object to test loading
|
||||
new_settings = Settings()
|
||||
print(f"Loaded number of LEDs: {new_settings['num_leds']}")
|
||||
print(settings)
|
||||
|
||||
|
||||
|
||||
# Run the example
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,78 @@
|
||||
import sys
|
||||
if "lib" not in sys.path:
|
||||
sys.path.insert(0, "lib")
|
||||
if "../lib" not in sys.path:
|
||||
sys.path.insert(0, "../lib")
|
||||
from ws2812 import WS2812B
|
||||
import time
|
||||
|
||||
# --- Chase test: pregenerated double buffer per strip, show via head offset (same as rainbow) ---
|
||||
|
||||
# (pin, num_leds) per strip — same config as rainbow
|
||||
STRIP_CONFIG = (
|
||||
(2, 291),
|
||||
(3, 290),
|
||||
(4, 283),
|
||||
(7, 278),
|
||||
(0, 275),
|
||||
(28, 278),
|
||||
(29, 283),
|
||||
(6, 290),
|
||||
)
|
||||
|
||||
strips = []
|
||||
sm = 0
|
||||
for pin, num_leds in STRIP_CONFIG:
|
||||
print(pin, num_leds)
|
||||
ws = WS2812B(num_leds, pin, sm, brightness=1.0)
|
||||
strips.append(ws)
|
||||
sm += 1
|
||||
|
||||
cumulative_leds = [0]
|
||||
for ws in strips[:-1]:
|
||||
cumulative_leds.append(cumulative_leds[-1] + ws.num_leds)
|
||||
total_ring_leds = cumulative_leds[-1] + strips[-1].num_leds
|
||||
|
||||
# Chase: trail length (0 = single LED), color (R,G,B)
|
||||
TRAIL_LEN = 8
|
||||
CHASE_COLOR = (0, 255, 100) # cyan-green
|
||||
|
||||
|
||||
def make_chase_double(num_leds, cumulative_leds, total_ring_leds, color, trail_len=0):
|
||||
"""Pregenerate strip double buffer: when head shows index b first, that pixel is at
|
||||
distance (2*cumulative_leds - b) % total_ring_leds from chase head. GRB order."""
|
||||
n = 2 * num_leds
|
||||
buf = bytearray(n * 3)
|
||||
for b in range(n):
|
||||
dist = (2 * cumulative_leds - b) % total_ring_leds
|
||||
if dist == 0:
|
||||
r, grn, b_ = color[0], color[1], color[2]
|
||||
elif trail_len and 0 < dist <= trail_len:
|
||||
fade = 1.0 - (dist / (trail_len + 1))
|
||||
r = int(color[0] * fade)
|
||||
grn = int(color[1] * fade)
|
||||
b_ = int(color[2] * fade)
|
||||
else:
|
||||
r = grn = b_ = 0
|
||||
o = b * 3
|
||||
buf[o] = grn
|
||||
buf[o + 1] = r
|
||||
buf[o + 2] = b_
|
||||
return buf
|
||||
|
||||
|
||||
# Pregenerate one double buffer per strip
|
||||
chase_buffers = [
|
||||
make_chase_double(ws.num_leds, cumulative_leds[i], total_ring_leds, CHASE_COLOR, TRAIL_LEN)
|
||||
for i, ws in enumerate(strips)
|
||||
]
|
||||
|
||||
chase_pos = 0
|
||||
while True:
|
||||
for i, strip in enumerate(strips):
|
||||
# head in [0, strip_len) so DMA read head..head+num_leds*3 stays in double buffer (same as rainbow)
|
||||
strip_len = strip.num_leds * 3
|
||||
head = (chase_pos + cumulative_leds[i]) * 3 % strip_len
|
||||
strip.show(chase_buffers[i], head)
|
||||
chase_pos = (chase_pos + 1) % total_ring_leds
|
||||
time.sleep_ms(20)
|
||||
+25
-51
@@ -28,13 +28,13 @@ def hue_to_rgb(hue):
|
||||
return (int(r * 255), int(g * 255), int(b * 255))
|
||||
|
||||
|
||||
def make_rainbow_ring(total_leds, brightness=1.0):
|
||||
"""Build one rainbow over the whole ring: 2 full hue cycles over total_leds (GRB).
|
||||
Returns (double_buf, ring_len_bytes). All strips sample from this so phase is continuous."""
|
||||
n = 2 * total_leds
|
||||
def make_rainbow_double(num_leds, brightness=1.0):
|
||||
"""Build 2 full rainbow cycles (2*num_leds pixels, GRB). Returns (double_buf, strip_len).
|
||||
head must be in 0..strip_len-1 so DMA reads double_buf[head:head+strip_len] with no copy."""
|
||||
n = 2 * num_leds
|
||||
double_buf = bytearray(n * 3)
|
||||
for i in range(n):
|
||||
hue = ((i % total_leds) / total_leds) * 360 * 2
|
||||
hue = (i / n) * 360 * 2
|
||||
r, g, b = hue_to_rgb(hue)
|
||||
g = int(g * brightness) & 0xFF
|
||||
r = int(r * brightness) & 0xFF
|
||||
@@ -43,48 +43,27 @@ def make_rainbow_ring(total_leds, brightness=1.0):
|
||||
double_buf[o] = g
|
||||
double_buf[o + 1] = r
|
||||
double_buf[o + 2] = b
|
||||
ring_len_bytes = total_leds * 3
|
||||
return (double_buf, ring_len_bytes)
|
||||
strip_len = num_leds * 3
|
||||
return (double_buf, strip_len)
|
||||
|
||||
|
||||
def make_strip_rainbow(num_leds, cumulative_leds, total_ring_leds, brightness=1.0):
|
||||
"""Per-strip double buffer: pixel j has hue at global position (cumulative_leds + j) % total_ring_leds.
|
||||
Use same head for all strips: head = rainbow_head % (2*num_leds*3)."""
|
||||
n = 2 * num_leds
|
||||
buf = bytearray(n * 3)
|
||||
for j in range(n):
|
||||
global_pos = (cumulative_leds + j) % total_ring_leds
|
||||
hue = (global_pos / total_ring_leds) * 360 * 2
|
||||
r, g, b = hue_to_rgb(hue)
|
||||
g = int(g * brightness) & 0xFF
|
||||
r = int(r * brightness) & 0xFF
|
||||
b = int(b * brightness) & 0xFF
|
||||
o = j * 3
|
||||
buf[o] = g
|
||||
buf[o + 1] = r
|
||||
buf[o + 2] = b
|
||||
strip_len_bytes = num_leds * 3
|
||||
return (buf, strip_len_bytes)
|
||||
def show_rainbow(strip, double_buf, strip_len, head):
|
||||
"""DMA reads directly from double_buf at head; no copy. head in 0..strip_len-1."""
|
||||
strip.show(double_buf, head)
|
||||
|
||||
|
||||
def show_rainbow_segment(strip, buf, strip_len_bytes, head):
|
||||
"""DMA reads strip's segment from buf at head."""
|
||||
strip.show(buf, head)
|
||||
|
||||
|
||||
# --- Strips + one global ring rainbow (all strips in phase) ---
|
||||
# Each strip can have a different length; one rainbow spans total_ring_leds so hue is continuous.
|
||||
|
||||
# (pin, num_leds) per strip — lengths differ per segment
|
||||
# --- Strips + rainbow buffers per strip ---
|
||||
# Each strip can have a different length; buffers and phase are per-strip.
|
||||
# Strip config must match pico/src/main.py pins.
|
||||
STRIP_CONFIG = (
|
||||
(2, 291),
|
||||
(7, 291),
|
||||
(3, 290),
|
||||
(4, 283),
|
||||
(7, 278),
|
||||
(0, 275),
|
||||
(6, 283),
|
||||
(28, 278),
|
||||
(29, 283),
|
||||
(6, 290),
|
||||
(29, 275),
|
||||
(4, 278),
|
||||
(0, 283),
|
||||
(2, 290),
|
||||
)
|
||||
|
||||
strips = []
|
||||
@@ -102,24 +81,19 @@ for ws in strips[:-1]:
|
||||
total_ring_leds = cumulative_leds[-1] + strips[-1].num_leds
|
||||
bytes_per_cycle = total_ring_leds * 3
|
||||
|
||||
# Per-strip rainbow buffers: each strip's segment of the ring (same phase, no shared-buffer DMA)
|
||||
# One rainbow double buffer per strip (length = 2 * num_leds for that strip)
|
||||
now = time.ticks_ms()
|
||||
rainbow_data = [
|
||||
make_strip_rainbow(ws.num_leds, cumulative_leds[i], total_ring_leds, ws.brightness)
|
||||
for i, ws in enumerate(strips)
|
||||
]
|
||||
rainbow_data = [make_rainbow_double(ws.num_leds, ws.brightness) for ws in strips]
|
||||
# Global phase in bytes; each strip: head = (phase + cumulative_leds[i]*3) % strip_len[i]
|
||||
print(time.ticks_diff(time.ticks_ms(), now), "ms")
|
||||
|
||||
rainbow_head = 0
|
||||
step = 3
|
||||
|
||||
while True:
|
||||
now = time.ticks_ms()
|
||||
for i, (strip, (buf, strip_len_bytes)) in enumerate(zip(strips, rainbow_data)):
|
||||
# Same head for all: each strip's buffer is already offset by cumulative_leds[i]
|
||||
double_len_bytes = 2 * strip.num_leds * 3
|
||||
head = rainbow_head % double_len_bytes
|
||||
show_rainbow_segment(strip, buf, strip_len_bytes, head)
|
||||
for i, (strip, (double_buf, strip_len)) in enumerate(zip(strips, rainbow_data)):
|
||||
head = (rainbow_head + cumulative_leds[i] * 3) % strip_len
|
||||
show_rainbow(strip, double_buf, strip_len, head)
|
||||
rainbow_head = (rainbow_head + step) % bytes_per_cycle
|
||||
#print(time.ticks_diff(time.ticks_ms(), now), "ms")
|
||||
time.sleep_ms(10)
|
||||
@@ -0,0 +1,81 @@
|
||||
import math
|
||||
import sys
|
||||
if "lib" not in sys.path:
|
||||
sys.path.insert(0, "lib")
|
||||
if "../lib" not in sys.path:
|
||||
sys.path.insert(0, "../lib")
|
||||
from ws2812 import WS2812B
|
||||
import time
|
||||
|
||||
# --- Roll: N buffers (length = max strip), gradient full -> off; sequence through strips ---
|
||||
N_BUFFERS = 32 # more buffers = smoother transition
|
||||
|
||||
STRIP_CONFIG = (
|
||||
(2, 291),
|
||||
(3, 290),
|
||||
(4, 283),
|
||||
(7, 278),
|
||||
(0, 275),
|
||||
(28, 278),
|
||||
(29, 283),
|
||||
(6, 290),
|
||||
)
|
||||
|
||||
strips = []
|
||||
sm = 0
|
||||
for pin, num_leds in STRIP_CONFIG:
|
||||
print(pin, num_leds)
|
||||
ws = WS2812B(num_leds, pin, sm, brightness=1.0)
|
||||
strips.append(ws)
|
||||
sm += 1
|
||||
|
||||
num_strips = len(strips)
|
||||
max_leds = max(ws.num_leds for ws in strips)
|
||||
# Color when "on" (R, G, B); GRB order in buffer
|
||||
ROLL_COLOR = (0, 255, 120) # cyan-green
|
||||
|
||||
|
||||
def make_gradient_buffers(n_buffers, max_leds, color):
|
||||
"""Create n_buffers buffers, each max_leds long. Buffer 0 = full brightness, last = off.
|
||||
Gradient is logarithmic (perceptually smoother: more steps near full, fewer near off). GRB order."""
|
||||
out = []
|
||||
for j in range(n_buffers):
|
||||
# log gradient: scale = 255 * log(1 + (n - 1 - j)) / log(n) so 255 at j=0, 0 at j=n-1
|
||||
if n_buffers <= 1:
|
||||
scale = 255
|
||||
elif j >= n_buffers - 1:
|
||||
scale = 0
|
||||
else:
|
||||
# 1 + (n_buffers - 1 - j) runs from n_buffers down to 1
|
||||
scale = int(255 * math.log(1 + (n_buffers - 1 - j)) / math.log(n_buffers))
|
||||
scale = min(255, scale)
|
||||
buf = bytearray(max_leds * 3)
|
||||
r = (color[0] * scale) // 255
|
||||
g = (color[1] * scale) // 255
|
||||
b = (color[2] * scale) // 255
|
||||
for i in range(max_leds):
|
||||
o = i * 3
|
||||
buf[o] = g & 0xFF
|
||||
buf[o + 1] = r & 0xFF
|
||||
buf[o + 2] = b & 0xFF
|
||||
out.append(buf)
|
||||
return out
|
||||
|
||||
|
||||
# N buffers: first full, last off, gradient between
|
||||
buffers = make_gradient_buffers(N_BUFFERS, max_leds, ROLL_COLOR)
|
||||
|
||||
step = 0
|
||||
delay_ms = 50
|
||||
# Deadline-based loop: no extra pause at rotation wrap, smooth continuous roll
|
||||
next_ms = time.ticks_ms()
|
||||
|
||||
while True:
|
||||
for i, strip in enumerate(strips):
|
||||
buf_index = (step + i) % N_BUFFERS
|
||||
strip.show(buffers[buf_index], 0)
|
||||
step += 1 # unbounded; wrap only in index so no hitch at cycle end
|
||||
next_ms += delay_ms
|
||||
# Sleep until next frame time (handles drift, no pause at wrap)
|
||||
while time.ticks_diff(next_ms, time.ticks_ms()) > 0:
|
||||
time.sleep_ms(1)
|
||||
@@ -0,0 +1,52 @@
|
||||
"""
|
||||
On-device test for Presets.fill_n() using mpremote.
|
||||
|
||||
Usage (from pico/ dir or project root with adjusted paths):
|
||||
|
||||
mpremote connect <device> cp src/*.py :
|
||||
mpremote connect <device> cp src/patterns/*.py :patterns
|
||||
mpremote connect <device> cp lib/*.py :
|
||||
mpremote connect <device> cp test/test_fill_n.py :
|
||||
mpremote connect <device> run test_fill_n.py
|
||||
|
||||
This script:
|
||||
- Instantiates Presets
|
||||
- Calls fill_n() with a simple range
|
||||
- Lets you visually confirm that all strips show the same proportional segment
|
||||
and that equal-length strip pairs have identical lit indices.
|
||||
"""
|
||||
|
||||
from presets import Presets
|
||||
|
||||
|
||||
def main():
|
||||
presets = Presets()
|
||||
presets.load()
|
||||
|
||||
# Choose a simple test range on the reference strip (strip 0).
|
||||
ref_len = presets.strip_length(0)
|
||||
if ref_len <= 0:
|
||||
print("No strips or invalid length; aborting fill_n test.")
|
||||
return
|
||||
|
||||
# Use a central segment so it's easy to see.
|
||||
start = ref_len // 4
|
||||
end = 3 * ref_len // 4
|
||||
print("Running fill_n test from", start, "to", end, "on reference strip 0.")
|
||||
|
||||
color = (0, 50, 0) # dim green
|
||||
|
||||
# First, clear everything
|
||||
for strip in presets.strips:
|
||||
strip.fill((0, 0, 0))
|
||||
strip.show()
|
||||
|
||||
# Apply fill_n, which will use scale() internally.
|
||||
presets.fill_n(color, start, end)
|
||||
|
||||
print("fill_n test applied; visually inspect strips.")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
|
||||
@@ -0,0 +1,130 @@
|
||||
"""
|
||||
On-device test for the Point pattern using mpremote.
|
||||
|
||||
Usage (from pico/ dir or project root with adjusted paths):
|
||||
|
||||
mpremote connect <device> cp src/*.py :
|
||||
mpremote connect <device> cp src/patterns/*.py :patterns
|
||||
mpremote connect <device> cp lib/*.py :
|
||||
mpremote connect <device> cp test/test_point.py :
|
||||
mpremote connect <device> run test_point.py
|
||||
|
||||
This script:
|
||||
- Instantiates Presets
|
||||
- Creates a few in-memory 'point' presets with different ranges/colors
|
||||
- Selects each one so you can visually confirm the segments
|
||||
"""
|
||||
|
||||
from presets import Presets, Preset
|
||||
|
||||
|
||||
def make_point_preset(name, colors, n_values, brightness=255):
|
||||
"""
|
||||
Helper to build a Preset for the 'point' pattern.
|
||||
|
||||
colors: list of up to 4 (r,g,b) tuples
|
||||
n_values: list/tuple of 8 ints [n1..n8]
|
||||
"""
|
||||
# Pad or trim colors to 4 entries
|
||||
cs = list(colors)[:4]
|
||||
while len(cs) < 4:
|
||||
cs.append((0, 0, 0))
|
||||
|
||||
n1, n2, n3, n4, n5, n6, n7, n8 = n_values
|
||||
data = {
|
||||
"p": "point",
|
||||
"c": cs,
|
||||
"b": brightness,
|
||||
"n1": n1,
|
||||
"n2": n2,
|
||||
"n3": n3,
|
||||
"n4": n4,
|
||||
"n5": n5,
|
||||
"n6": n6,
|
||||
"n7": n7,
|
||||
"n8": n8,
|
||||
# 'a' is not used by point; it's static
|
||||
}
|
||||
return name, Preset(data)
|
||||
|
||||
|
||||
def show_and_wait(presets, name, preset_obj, wait_ms):
|
||||
"""Select a static 'point' preset and hold it for wait_ms."""
|
||||
presets.presets[name] = preset_obj
|
||||
presets.select(name)
|
||||
# Point draws immediately in run(), then just yields; one tick is enough.
|
||||
presets.tick()
|
||||
|
||||
import utime
|
||||
|
||||
start = utime.ticks_ms()
|
||||
while utime.ticks_diff(utime.ticks_ms(), start) < wait_ms:
|
||||
# Keep ticking in case other logic ever depends on it
|
||||
presets.tick()
|
||||
|
||||
|
||||
def main():
|
||||
presets = Presets()
|
||||
presets.load()
|
||||
|
||||
num_leds = presets.strip_length(0)
|
||||
if num_leds <= 0:
|
||||
print("No strips; aborting point test.")
|
||||
return
|
||||
|
||||
print("Starting point pattern test...")
|
||||
|
||||
quarter = num_leds // 4
|
||||
half = num_leds // 2
|
||||
|
||||
point_presets = []
|
||||
|
||||
# 1. Single band: first quarter, red
|
||||
point_presets.append(
|
||||
make_point_preset(
|
||||
"point_red_q1",
|
||||
colors=[(255, 0, 0)],
|
||||
n_values=[0, quarter - 1, 0, -1, 0, -1, 0, -1],
|
||||
)
|
||||
)
|
||||
|
||||
# 2. Two bands: red first half, green second half
|
||||
point_presets.append(
|
||||
make_point_preset(
|
||||
"point_red_green_halves",
|
||||
colors=[(255, 0, 0), (0, 255, 0)],
|
||||
n_values=[0, half - 1, half, num_leds - 1, 0, -1, 0, -1],
|
||||
)
|
||||
)
|
||||
|
||||
# 3. Three bands: R, G, B quarters
|
||||
point_presets.append(
|
||||
make_point_preset(
|
||||
"point_rgb_quarters",
|
||||
colors=[(255, 0, 0), (0, 255, 0), (0, 0, 255)],
|
||||
n_values=[
|
||||
0,
|
||||
quarter - 1, # red
|
||||
quarter,
|
||||
2 * quarter - 1, # green
|
||||
2 * quarter,
|
||||
3 * quarter - 1, # blue
|
||||
0,
|
||||
-1,
|
||||
],
|
||||
)
|
||||
)
|
||||
|
||||
# Show each for ~4 seconds
|
||||
for name, preset_obj in point_presets:
|
||||
print("Showing point preset:", name)
|
||||
show_and_wait(presets, name, preset_obj, wait_ms=4000)
|
||||
|
||||
print("Point pattern test finished. Turning off LEDs.")
|
||||
presets.select("off")
|
||||
presets.tick()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
|
||||
@@ -0,0 +1,118 @@
|
||||
"""
|
||||
On-device test for the Roll pattern using mpremote.
|
||||
|
||||
Usage (from pico/ dir or project root with adjusted paths):
|
||||
|
||||
mpremote connect <device> cp src/*.py :
|
||||
mpremote connect <device> cp src/patterns/*.py :patterns
|
||||
mpremote connect <device> cp lib/*.py :
|
||||
mpremote connect <device> cp test/test_roll.py :
|
||||
mpremote connect <device> run test_roll.py
|
||||
|
||||
This script:
|
||||
- Instantiates Presets
|
||||
- Creates a few in-memory roll presets with different parameters
|
||||
- Runs each one for a short time so you can visually compare behaviour
|
||||
"""
|
||||
|
||||
import utime
|
||||
from presets import Presets, Preset
|
||||
|
||||
|
||||
def make_roll_preset(name, color1, color2, n1=0, n2=0, n3=0, n4=0, delay_ms=50, brightness=255):
|
||||
"""Helper to build a Preset dict for the roll pattern."""
|
||||
data = {
|
||||
"p": "roll",
|
||||
"c": [color1, color2],
|
||||
"b": brightness,
|
||||
"d": delay_ms,
|
||||
"n1": n1,
|
||||
"n2": n2,
|
||||
"n3": n3,
|
||||
"n4": n4,
|
||||
"a": True, # animated
|
||||
}
|
||||
return name, Preset(data)
|
||||
|
||||
|
||||
def run_preset(presets, name, preset_obj, duration_ms):
|
||||
"""Run a given roll preset for duration_ms using the existing tick loop."""
|
||||
presets.presets[name] = preset_obj
|
||||
presets.select(name)
|
||||
|
||||
start = utime.ticks_ms()
|
||||
while utime.ticks_diff(utime.ticks_ms(), start) < duration_ms:
|
||||
presets.tick()
|
||||
|
||||
|
||||
def main():
|
||||
presets = Presets()
|
||||
presets.load()
|
||||
|
||||
print("Starting roll pattern test...")
|
||||
|
||||
ref_len = presets.strip_length(0)
|
||||
# Use some margins based on strip length to show different bands.
|
||||
quarter = ref_len // 4
|
||||
|
||||
# Define a few different roll presets:
|
||||
roll_presets = []
|
||||
|
||||
# 1. Full-strip, white -> off, clockwise, medium speed
|
||||
roll_presets.append(
|
||||
make_roll_preset(
|
||||
"roll_full_cw",
|
||||
color1=(255, 255, 255),
|
||||
color2=(0, 0, 0),
|
||||
n1=0,
|
||||
n2=0,
|
||||
n3=2, # 2 rotations then stop
|
||||
n4=0, # clockwise
|
||||
delay_ms=40,
|
||||
brightness=255,
|
||||
)
|
||||
)
|
||||
|
||||
# 2. Inner band only, red -> blue, clockwise, slower
|
||||
roll_presets.append(
|
||||
make_roll_preset(
|
||||
"roll_inner_band",
|
||||
color1=(255, 0, 0),
|
||||
color2=(0, 0, 255),
|
||||
n1=quarter, # start margin
|
||||
n2=quarter, # end margin
|
||||
n3=2,
|
||||
n4=0,
|
||||
delay_ms=60,
|
||||
brightness=255,
|
||||
)
|
||||
)
|
||||
|
||||
# 3. Full-strip, green -> off, counter-clockwise, faster
|
||||
roll_presets.append(
|
||||
make_roll_preset(
|
||||
"roll_full_ccw",
|
||||
color1=(0, 255, 0),
|
||||
color2=(0, 0, 0),
|
||||
n1=0,
|
||||
n2=0,
|
||||
n3=2,
|
||||
n4=1, # counter-clockwise
|
||||
delay_ms=30,
|
||||
brightness=255,
|
||||
)
|
||||
)
|
||||
|
||||
# Run each roll preset for about 5 seconds
|
||||
for name, preset_obj in roll_presets:
|
||||
print("Running roll preset:", name)
|
||||
run_preset(presets, name, preset_obj, duration_ms=5000)
|
||||
|
||||
print("Roll pattern test finished. Turning off LEDs.")
|
||||
presets.select("off")
|
||||
presets.tick()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
|
||||
@@ -0,0 +1,100 @@
|
||||
"""
|
||||
Test the Presets.scale() helper on-device with mpremote.
|
||||
|
||||
Usage (from project root):
|
||||
|
||||
mpremote connect <device> cp pico/src/*.py : &&
|
||||
mpremote connect <device> cp pico/src/patterns/*.py :patterns &&
|
||||
mpremote connect <device> cp pico/lib/*.py : &&
|
||||
mpremote connect <device> cp tests/test_scale.py : &&
|
||||
mpremote connect <device> run test_scale.py
|
||||
|
||||
This script:
|
||||
- Creates a minimal Presets instance
|
||||
- Runs a few numeric test cases for scale()
|
||||
- Optionally displays a short visual check on the LEDs
|
||||
"""
|
||||
|
||||
from presets import Presets
|
||||
|
||||
|
||||
def numeric_tests(presets):
|
||||
"""
|
||||
Numeric sanity checks for scale() using the actual strip config.
|
||||
|
||||
We treat strip 0 as the reference and print the mapped indices for
|
||||
a few positions on each other strip.
|
||||
"""
|
||||
print("Numeric scale() tests (from strip 0):")
|
||||
ref_len = presets.strip_length(0)
|
||||
if ref_len <= 0:
|
||||
print(" strip 0 length <= 0; skipping numeric tests.")
|
||||
return
|
||||
|
||||
test_positions = [0, ref_len // 2, ref_len - 1]
|
||||
for pos in test_positions:
|
||||
print(" pos on strip 0:", pos)
|
||||
for dst_idx in range(len(presets.strips)):
|
||||
dst_len = presets.strip_length(dst_idx)
|
||||
if dst_len <= 0:
|
||||
continue
|
||||
n2 = presets.scale(dst_idx, pos)
|
||||
print(" -> strip", dst_idx, "len", dst_len, "pos", n2)
|
||||
|
||||
|
||||
def visual_test(presets):
|
||||
"""
|
||||
Simple visual test:
|
||||
- Use strip 0 as reference
|
||||
- Move a pixel along strip 0
|
||||
- Map position to all other strips with scale()
|
||||
"""
|
||||
import utime
|
||||
|
||||
strips = presets.strips
|
||||
if not strips:
|
||||
print("No strips available for visual test.")
|
||||
return
|
||||
|
||||
src_strip_idx = 0
|
||||
l1 = presets.strip_length(src_strip_idx)
|
||||
if l1 <= 0:
|
||||
print("strip_length(0) <= 0; aborting visual test.")
|
||||
return
|
||||
|
||||
color = (50, 0, 0) # dim red so it doesn't blind you
|
||||
|
||||
# Run once across the full length of the reference strip,
|
||||
# jumping 10 LEDs at a time.
|
||||
step_size = 10
|
||||
steps = (l1 + step_size - 1) // step_size
|
||||
print("Starting visual scale() test with 10-LED jumps:", steps, "steps...")
|
||||
for step in range(steps):
|
||||
n1 = (step * step_size) % l1
|
||||
|
||||
# Clear all strips
|
||||
for strip in strips:
|
||||
strip.fill((0, 0, 0))
|
||||
|
||||
# Light mapped position on each strip using Presets.set/show
|
||||
for dst_strip_idx, _ in enumerate(strips):
|
||||
presets.set(dst_strip_idx, n1, color)
|
||||
presets.show(dst_strip_idx)
|
||||
|
||||
print("Visual test finished.")
|
||||
|
||||
|
||||
def main():
|
||||
presets = Presets()
|
||||
presets.load()
|
||||
numeric_tests(presets)
|
||||
# Comment this in/out depending on whether you want the LEDs to run:
|
||||
try:
|
||||
visual_test(presets)
|
||||
except Exception as e:
|
||||
print("Visual test error:", e)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
|
||||
@@ -0,0 +1,45 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Serial loopback test – single file, runs on Pico and ESP32.
|
||||
Wire TX to RX (Pico: GP0–GP1, ESP32: 17–18), then:
|
||||
mpremote run pico/test/test_serial.py
|
||||
|
||||
For ESP32→Pico: run test_serial_send.py on ESP32, test_serial_receive.py on Pico; wire ESP32 TX (17) to Pico RX (1).
|
||||
"""
|
||||
import time
|
||||
import sys
|
||||
from machine import UART, Pin
|
||||
|
||||
if "esp32" in sys.platform:
|
||||
UART_ID, TX_PIN, RX_PIN, BAUD = 1, 17, 18, 115200
|
||||
else:
|
||||
UART_ID, TX_PIN, RX_PIN, BAUD = 0, 0, 1, 115200
|
||||
|
||||
READ_TIMEOUT_MS = 100
|
||||
LINE_TERM = b"\n"
|
||||
|
||||
print("UART loopback: %s UART%d TX=%s RX=%s %d baud" % (sys.platform, UART_ID, TX_PIN, RX_PIN, BAUD))
|
||||
uart = UART(UART_ID, baudrate=BAUD, tx=Pin(TX_PIN, Pin.OUT), rx=Pin(RX_PIN, Pin.IN))
|
||||
uart.read()
|
||||
to_send = [b"hello", b"123", b"{\"v\":\"1\"}"]
|
||||
errors = []
|
||||
for msg in to_send:
|
||||
uart.write(msg + LINE_TERM)
|
||||
time.sleep_ms(20)
|
||||
buf = bytearray()
|
||||
deadline = time.ticks_add(time.ticks_ms(), READ_TIMEOUT_MS)
|
||||
while time.ticks_diff(deadline, time.ticks_ms()) > 0:
|
||||
n = uart.any()
|
||||
if n:
|
||||
buf.extend(uart.read(n))
|
||||
if LINE_TERM in buf:
|
||||
break
|
||||
time.sleep_ms(2)
|
||||
got = bytes(buf).strip()
|
||||
if got != msg:
|
||||
errors.append((msg, got))
|
||||
uart.deinit()
|
||||
if errors:
|
||||
print("FAIL loopback:", errors)
|
||||
else:
|
||||
print("PASS loopback: sent and received", to_send)
|
||||
@@ -0,0 +1,32 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Serial receive test – single file. Run on Pico (RX side).
|
||||
Wire: ESP32 TX (GPIO17) → Pico RX (GPIO1); GND ↔ GND. Run send test on ESP32.
|
||||
mpremote run pico/test/test_serial_receive.py
|
||||
"""
|
||||
import time
|
||||
import sys
|
||||
from machine import UART, Pin
|
||||
|
||||
if "esp32" in sys.platform:
|
||||
UART_ID, TX_PIN, RX_PIN, BAUD = 1, 17, 18, 115200
|
||||
else:
|
||||
UART_ID, TX_PIN, RX_PIN, BAUD = 0, 0, 1, 115200
|
||||
|
||||
print("UART receive: %s UART%d TX=%s RX=%s %d baud (10 s)" % (sys.platform, UART_ID, TX_PIN, RX_PIN, BAUD))
|
||||
uart = UART(UART_ID, baudrate=BAUD, tx=Pin(TX_PIN, Pin.OUT), rx=Pin(RX_PIN, Pin.IN))
|
||||
buf = bytearray()
|
||||
deadline = time.ticks_add(time.ticks_ms(), 10000)
|
||||
while time.ticks_diff(deadline, time.ticks_ms()) > 0:
|
||||
n = uart.any()
|
||||
if n:
|
||||
buf.extend(uart.read(n))
|
||||
while b"\n" in buf:
|
||||
idx = buf.index(b"\n")
|
||||
line = bytes(buf[:idx]).strip()
|
||||
buf = buf[idx + 1:]
|
||||
if line:
|
||||
print("rx:", line.decode("utf-8", "replace"))
|
||||
time.sleep_ms(10)
|
||||
uart.deinit()
|
||||
print("Receive test done.")
|
||||
@@ -0,0 +1,23 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Serial send test – single file. Run on ESP32 (TX side).
|
||||
Wire: ESP32 TX (GPIO17) → Pico RX (GPIO1); GND ↔ GND. Run receive test on Pico.
|
||||
mpremote run pico/test/test_serial_send.py
|
||||
"""
|
||||
import time
|
||||
import sys
|
||||
from machine import UART, Pin
|
||||
|
||||
if "esp32" in sys.platform:
|
||||
UART_ID, TX_PIN, BAUD = 1, 17, 115200
|
||||
else:
|
||||
UART_ID, TX_PIN, BAUD = 0, 0, 115200
|
||||
|
||||
print("UART send: %s UART%d TX=%s %d baud" % (sys.platform, UART_ID, TX_PIN, BAUD))
|
||||
uart = UART(UART_ID, baudrate=BAUD, tx=Pin(TX_PIN, Pin.OUT))
|
||||
for line in [b"serial send test 1", b"serial send test 2", b"{\"v\":\"1\",\"b\":128}"]:
|
||||
uart.write(line + b"\n")
|
||||
print("sent:", line.decode("utf-8"))
|
||||
time.sleep_ms(50)
|
||||
uart.deinit()
|
||||
print("Send test done.")
|
||||
Reference in new issue
Block a user