Compare commits
21
Commits
ff55e9ddb0
...
c
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
ac6a900ded | ||
|
|
d4ffb1561d | ||
|
|
05c4bb87f9 | ||
|
|
47f4a6663b | ||
|
|
bf0429c505 | ||
|
|
b3e9fc9663 | ||
|
|
b783d97f13 | ||
|
|
47c17dba36 | ||
|
|
e75723e2e7 | ||
|
|
52a5f0f8c4 | ||
|
|
646b988cdd | ||
|
|
615431d6c5 | ||
|
|
b45823c479 | ||
|
|
0c73d56ab5 | ||
|
|
86b28a1b9c | ||
|
|
2869ec9300 | ||
|
|
c062110e35 | ||
|
|
6b5ae78591 | ||
|
|
bfa85c5688 | ||
|
|
a3ab572851 | ||
|
|
a3510ab164 |
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": {}
|
||||
}
|
||||
@@ -1,2 +1,30 @@
|
||||
# led-bar
|
||||
|
||||
## Recovery: when the board is stuck and you have to nuke the flash
|
||||
|
||||
**Option A – clear startup files (no reflash)**
|
||||
If the board runs but REPL/Thonny is blocked by `main.py` or `boot.py`, remove them so the next boot drops straight to REPL. From your PC (with the Pico connected via USB):
|
||||
|
||||
```bash
|
||||
# Remove startup files (paths are on the device; try without colons if one form fails)
|
||||
mpremote fs rm boot.py
|
||||
mpremote fs rm main.py
|
||||
mpremote reset
|
||||
```
|
||||
|
||||
If that fails, try one of these:
|
||||
|
||||
```bash
|
||||
mpremote rm boot.py
|
||||
mpremote rm main.py
|
||||
```
|
||||
|
||||
Or in **Thonny**: Stop the running program (Ctrl+C or Stop button), then **View → Files**, right‑click the device, delete `boot.py` and `main.py` on the device, then **Tools → Reset**.
|
||||
|
||||
If the board doesn’t respond to serial at all, use Option B.
|
||||
|
||||
**Option B – full flash erase (Pico 2)**
|
||||
1. Unplug the Pico 2.
|
||||
2. Hold **BOOTSEL**, plug USB in, then release BOOTSEL.
|
||||
3. It should mount as a drive. Delete any existing UF2 if you want a clean state.
|
||||
4. Copy the MicroPython UF2 for Pico 2 (RP2350) onto the drive. The board will reboot with a fresh install and empty filesystem.
|
||||
@@ -1,20 +0,0 @@
|
||||
difference() {
|
||||
cube([30,25,20]);
|
||||
//hoop
|
||||
translate([15,12.5,-905]){
|
||||
rotate([90,0,0])
|
||||
rotate_extrude($fn=300)
|
||||
translate([900,0,0])
|
||||
circle(d=25, $fn=100);
|
||||
};
|
||||
//pico
|
||||
translate([3.25,3.5,0])
|
||||
cube([23.5,18,12]);
|
||||
//pico usb port
|
||||
translate([26.75,8,6.5])
|
||||
cube([3.25,9,5.5]);
|
||||
//wifi
|
||||
translate([2.5,5,12])
|
||||
cube([25,15,5]);
|
||||
|
||||
};
|
||||
@@ -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 |
@@ -1,33 +1,91 @@
|
||||
#!/usr/bin/env python3
|
||||
|
||||
import os
|
||||
import subprocess
|
||||
import serial
|
||||
import sys
|
||||
|
||||
print(sys.argv)
|
||||
|
||||
port = sys.argv[1]
|
||||
|
||||
cmd = sys.argv[1]
|
||||
|
||||
for cmd in sys.argv[1:]:
|
||||
print(cmd)
|
||||
match cmd:
|
||||
case "src":
|
||||
subprocess.call(["mpremote", "connect", port, "fs", "cp", "-r", ".", ":" ], cwd="src")
|
||||
case "lib":
|
||||
subprocess.call(["mpremote", "connect", port, "fs", "cp", "-r", "lib", ":" ])
|
||||
case "ls":
|
||||
subprocess.call(["mpremote", "connect", port, "fs", "ls", ":" ])
|
||||
case "reset":
|
||||
with serial.Serial(port, baudrate=115200) as ser:
|
||||
ser.write(b'\x03\x03\x04')
|
||||
case "follow":
|
||||
with serial.Serial(port, baudrate=115200) as ser:
|
||||
while True:
|
||||
if ser.in_waiting > 0: # Check if there is data in the buffer
|
||||
data = ser.readline().decode('utf-8').strip() # Read and decode the data
|
||||
print(data)
|
||||
import serial
|
||||
|
||||
|
||||
def usage() -> None:
|
||||
print("Usage:")
|
||||
print(" dev.py <port> <device> [src] [lib] [reset] [follow]")
|
||||
print(" e.g. dev.py /dev/ttyUSB0 pico src lib")
|
||||
print(" e.g. dev.py /dev/ttyUSB0 esp32 src reset follow")
|
||||
print(" device: pico | esp32. If no src/lib given, deploys both.")
|
||||
|
||||
|
||||
def main() -> None:
|
||||
if len(sys.argv) < 3:
|
||||
usage()
|
||||
return
|
||||
|
||||
port = sys.argv[1]
|
||||
device = sys.argv[2].lower()
|
||||
actions = [a.lower() for a in sys.argv[3:]]
|
||||
|
||||
if port.startswith("/") or (len(port) >= 3 and port.upper().startswith("COM")):
|
||||
pass
|
||||
else:
|
||||
print("First argument must be serial port (e.g. /dev/ttyUSB0 or COM3).")
|
||||
usage()
|
||||
return
|
||||
|
||||
if device not in ("pico", "esp32"):
|
||||
print("Device must be pico or esp32.")
|
||||
usage()
|
||||
return
|
||||
|
||||
if not actions:
|
||||
actions = ["src", "lib"]
|
||||
|
||||
src_dir = f"{device}/src"
|
||||
lib_dir = f"{device}/lib"
|
||||
|
||||
for a in actions:
|
||||
print(a)
|
||||
match a:
|
||||
case "src":
|
||||
if os.path.isdir(src_dir):
|
||||
# Ensure remote directories exist before copying files
|
||||
created_dirs: set[str] = set()
|
||||
for dirpath, _, filenames in os.walk(src_dir):
|
||||
for name in filenames:
|
||||
path = os.path.join(dirpath, name)
|
||||
rel = os.path.relpath(path, src_dir).replace(os.sep, "/")
|
||||
remote_dir = ""
|
||||
if "/" in rel:
|
||||
remote_dir = rel.rsplit("/", 1)[0]
|
||||
if remote_dir and remote_dir not in created_dirs:
|
||||
subprocess.call(
|
||||
["mpremote", "connect", port, "fs", "mkdir", ":" + remote_dir],
|
||||
)
|
||||
created_dirs.add(remote_dir)
|
||||
subprocess.call(
|
||||
["mpremote", "connect", port, "fs", "cp", path, ":" + rel],
|
||||
)
|
||||
else:
|
||||
print(" (no src dir)")
|
||||
case "lib":
|
||||
if os.path.isdir(lib_dir):
|
||||
subprocess.call(
|
||||
["mpremote", "connect", port, "fs", "cp", "-r", lib_dir, ":"],
|
||||
)
|
||||
else:
|
||||
print(" (no lib dir)")
|
||||
case "reset":
|
||||
with serial.Serial(port, baudrate=115200) as ser:
|
||||
ser.write(b"\x03\x03\x04")
|
||||
case "follow":
|
||||
with serial.Serial(port, baudrate=115200) as ser:
|
||||
while True:
|
||||
if ser.in_waiting > 0:
|
||||
data = ser.readline().decode("utf-8").strip()
|
||||
print(data)
|
||||
case _:
|
||||
print("Unknown action:", a)
|
||||
usage()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
@@ -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"}
|
||||
]
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,109 @@
|
||||
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
|
||||
|
||||
# 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 []
|
||||
|
||||
|
||||
def _save_buttons(buttons):
|
||||
try:
|
||||
with open("buttons.json", "w") as f:
|
||||
json.dump({"buttons": buttons}, f)
|
||||
return True
|
||||
except OSError:
|
||||
return False
|
||||
|
||||
|
||||
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)
|
||||
@@ -0,0 +1,64 @@
|
||||
"""
|
||||
ESP32-C6 test: send JSON messages to Pico over UART (GPIO17).
|
||||
Settings use strips = [[pin, num_leds], ...]. Run with Pico connected on RX.
|
||||
|
||||
Run with mpremote (from repo root):
|
||||
./esp32/run_test_uart_json.sh
|
||||
# or
|
||||
mpremote run esp32/test/test_uart_send_json.py
|
||||
# or with port
|
||||
mpremote connect /dev/ttyUSB0 run esp32/test/test_uart_send_json.py
|
||||
"""
|
||||
import machine
|
||||
import time
|
||||
import json
|
||||
|
||||
UART_TX_PIN = 17
|
||||
UART_BAUD = 921600
|
||||
LED_PIN = 15
|
||||
|
||||
|
||||
def send_json(uart, obj):
|
||||
line = json.dumps(obj) + "\n"
|
||||
uart.write(line)
|
||||
print("TX:", line.strip())
|
||||
|
||||
|
||||
def main():
|
||||
uart = machine.UART(1, baudrate=UART_BAUD, tx=UART_TX_PIN)
|
||||
led = machine.Pin(LED_PIN, machine.Pin.OUT)
|
||||
|
||||
# 1) Settings: one strip, pin 2, 10 LEDs (list of lists)
|
||||
send_json(uart, {
|
||||
"v": 1,
|
||||
"settings": {
|
||||
"strips": [[2, 10]],
|
||||
"brightness": 30,
|
||||
},
|
||||
})
|
||||
led.value(1)
|
||||
time.sleep(0.2)
|
||||
led.value(0)
|
||||
time.sleep(0.3)
|
||||
|
||||
# 2) led-controller format: light + settings.color (hex)
|
||||
send_json(uart, {"light": "strip1", "settings": {"color": "#FF0000"}, "save": False})
|
||||
time.sleep(0.5)
|
||||
|
||||
# 3) led-controller format: light + settings.r,g,b
|
||||
send_json(uart, {"light": "strip1", "settings": {"r": 0, "g": 255, "b": 0}, "save": False})
|
||||
time.sleep(0.5)
|
||||
|
||||
# 4) led-controller format: blue (hex)
|
||||
send_json(uart, {"light": "strip1", "settings": {"color": "#0000FF"}, "save": False})
|
||||
time.sleep(0.5)
|
||||
|
||||
# 5) Off (existing format)
|
||||
send_json(uart, {"v": 1, "off": True})
|
||||
time.sleep(0.3)
|
||||
|
||||
print("Done. Pico: settings -> red (hex) -> green (r,g,b) -> blue (hex) -> off.")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,32 @@
|
||||
"""
|
||||
ESP32-C6 UART TX + LED test. Sends a few commands on GPIO17, blinks LED on GPIO15.
|
||||
Run on device: exec(open('test/test_uart_tx').read()) or import test.test_uart_tx
|
||||
Does not require Pico connected.
|
||||
"""
|
||||
import machine
|
||||
import time
|
||||
|
||||
UART_TX_PIN = 17
|
||||
LED_PIN = 15
|
||||
|
||||
def main():
|
||||
uart = machine.UART(1, baudrate=115200, tx=UART_TX_PIN)
|
||||
led = machine.Pin(LED_PIN, machine.Pin.OUT)
|
||||
|
||||
def send(cmd):
|
||||
uart.write(cmd + "\n")
|
||||
print("TX:", cmd)
|
||||
|
||||
# Blink and send a short command sequence
|
||||
commands = ["off", "fill 255 0 0", "fill 0 255 0", "fill 0 0 255", "off"]
|
||||
for i, cmd in enumerate(commands):
|
||||
led.value(1)
|
||||
send(cmd)
|
||||
time.sleep(0.3)
|
||||
led.value(0)
|
||||
time.sleep(0.2)
|
||||
|
||||
print("Done. Connect Pico to see strip follow commands.")
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,102 @@
|
||||
# """
|
||||
# Pico: receive led-driver JSON from UART (one message per line). Runs Presets + patterns.
|
||||
# UART RX on D7 (GPIO1). Non-blocking so presets.tick() runs every loop.
|
||||
# """
|
||||
# from settings import Settings
|
||||
# from machine import UART, Pin
|
||||
# import utime
|
||||
# from presets import Presets
|
||||
# from utils import convert_and_reorder_colors
|
||||
# import json
|
||||
|
||||
# # UART (Pico XIAO: D7 = GPIO1)
|
||||
# UART_RX_PIN = 1
|
||||
# UART_BAUD = 115200
|
||||
# UART_ID = 0
|
||||
|
||||
# settings = Settings()
|
||||
# print(settings)
|
||||
|
||||
# presets = Presets(settings["led_pin"], settings["num_leds"])
|
||||
# presets.load()
|
||||
# presets.b = settings.get("brightness", 255)
|
||||
# startup_preset = settings.get("startup_preset")
|
||||
# if startup_preset:
|
||||
# presets.select(startup_preset)
|
||||
# print("Selected startup preset:", startup_preset)
|
||||
|
||||
# last_brightness_save = 0
|
||||
|
||||
# # Non-blocking UART
|
||||
# uart = UART(UART_ID, baudrate=UART_BAUD, rx=Pin(UART_RX_PIN), rxbuf=512, timeout=0)
|
||||
# uart_buf = bytearray()
|
||||
|
||||
# print("UART RX on pin %s, %s baud (one JSON object per line)" % (UART_RX_PIN, UART_BAUD))
|
||||
|
||||
|
||||
# def process_message(data):
|
||||
# """Handle one JSON message (led-driver protocol: v, b, presets, select, default, save)."""
|
||||
# if data.get("v") != "1":
|
||||
# return
|
||||
# global last_brightness_save
|
||||
# if "b" in data:
|
||||
# try:
|
||||
# presets.b = max(0, min(255, int(data["b"])))
|
||||
# settings["brightness"] = presets.b
|
||||
# now = utime.ticks_ms()
|
||||
# if utime.ticks_diff(now, last_brightness_save) >= 500:
|
||||
# settings.save()
|
||||
# last_brightness_save = now
|
||||
# except (TypeError, ValueError):
|
||||
# pass
|
||||
# if "presets" in data:
|
||||
# for id, preset_data in data["presets"].items():
|
||||
# if "c" in preset_data:
|
||||
# preset_data["c"] = convert_and_reorder_colors(preset_data["c"], settings)
|
||||
# presets.edit(id, preset_data)
|
||||
# print("Edited preset", id, preset_data.get("name", ""))
|
||||
# if settings.get("name") in data.get("select", {}):
|
||||
# select_list = data["select"][settings.get("name")]
|
||||
# if select_list:
|
||||
# preset_name = select_list[0]
|
||||
# step = select_list[1] if len(select_list) > 1 else None
|
||||
# presets.select(preset_name, step=step)
|
||||
# if "default" in data:
|
||||
# settings["startup_preset"] = data["default"]
|
||||
# print("Set startup preset to", data["default"])
|
||||
# settings.save()
|
||||
# if "save" in data:
|
||||
# presets.save()
|
||||
|
||||
|
||||
# while True:
|
||||
# presets.tick()
|
||||
# n = uart.any()
|
||||
# if n:
|
||||
# data_in = uart.read(n)
|
||||
# if data_in:
|
||||
# for b in data_in:
|
||||
# if b in (0x0A, 0x0D): # LF or CR
|
||||
# if uart_buf:
|
||||
# try:
|
||||
# msg = uart_buf.decode("utf-8").strip()
|
||||
# if msg:
|
||||
# data = json.loads(msg)
|
||||
# process_message(data)
|
||||
# except (ValueError, UnicodeError):
|
||||
# pass
|
||||
# uart_buf = bytearray()
|
||||
# else:
|
||||
# if len(uart_buf) < 1024:
|
||||
# uart_buf.append(b)
|
||||
# utime.sleep_ms(1)
|
||||
|
||||
from neopixel import NeoPixel
|
||||
from machine import Pin
|
||||
|
||||
pins = ((2,270), (3,271), (4,272), (0,273), (7,274), (6,275), (29,276), (28,277))
|
||||
for pin, num_leds in pins:
|
||||
print(pin, num_leds)
|
||||
np = NeoPixel(Pin(pin), num_leds)
|
||||
np.fill((8, 0, 0))
|
||||
np.write()
|
||||
@@ -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 start_transfer(self, buffer):
|
||||
self.dma_chan.READ_ADDR_REG = uctypes.addressof(buffer)
|
||||
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._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()
|
||||
|
||||
|
||||
|
||||
@@ -1,68 +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):
|
||||
self.pio_dma.start_transfer(self.ar)
|
||||
|
||||
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 = 10, 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)
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,63 @@
|
||||
from machine import UART, Pin
|
||||
import json
|
||||
from presets import Presets
|
||||
import gc
|
||||
|
||||
uart = UART(0, baudrate=921600, rx=Pin(1, Pin.IN))
|
||||
|
||||
presets = Presets()
|
||||
presets.load()
|
||||
|
||||
print(presets.presets.keys())
|
||||
|
||||
presets.select("off")
|
||||
|
||||
#print memory usage
|
||||
print(f"Memory usage: {gc.mem_free()/1024} kB free")
|
||||
|
||||
i = 0
|
||||
while True:
|
||||
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")
|
||||
|
||||
@@ -0,0 +1,17 @@
|
||||
from .blink import Blink
|
||||
from .rainbow import Rainbow
|
||||
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,33 @@
|
||||
import utime
|
||||
|
||||
|
||||
class Blink:
|
||||
def __init__(self, driver):
|
||||
self.driver = driver
|
||||
|
||||
def run(self, preset):
|
||||
"""Blink pattern: toggles LEDs on/off using preset delay, cycling through colors."""
|
||||
# Use provided colors, or default to white if none
|
||||
colors = preset.c if preset.c else [(255, 255, 255)]
|
||||
color_index = 0
|
||||
state = True # True = on, False = off
|
||||
last_update = utime.ticks_ms()
|
||||
|
||||
while True:
|
||||
current_time = utime.ticks_ms()
|
||||
# Re-read delay each loop so live updates to preset.d take effect
|
||||
delay_ms = max(1, int(preset.d))
|
||||
if utime.ticks_diff(current_time, last_update) >= delay_ms:
|
||||
if state:
|
||||
base_color = colors[color_index % len(colors)]
|
||||
color = self.driver.apply_brightness(base_color, preset.b)
|
||||
self.driver.fill(color)
|
||||
# Advance to next color for the next "on" phase
|
||||
color_index += 1
|
||||
else:
|
||||
# "Off" phase: turn all LEDs off
|
||||
self.driver.fill((0, 0, 0))
|
||||
state = not state
|
||||
last_update = current_time
|
||||
# Yield once per tick so other logic can run
|
||||
yield
|
||||
@@ -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,124 @@
|
||||
import utime
|
||||
|
||||
|
||||
class Chase:
|
||||
def __init__(self, driver):
|
||||
self.driver = driver
|
||||
|
||||
def run(self, preset):
|
||||
"""Chase pattern: n1 LEDs of color0, n2 LEDs of color1, repeating.
|
||||
Moves by n3 on even steps, n4 on odd steps (n3/n4 can be positive or negative)"""
|
||||
colors = preset.c
|
||||
if len(colors) < 1:
|
||||
# Need at least 1 color
|
||||
return
|
||||
|
||||
# Access colors, delay, and n values from preset
|
||||
if not colors:
|
||||
return
|
||||
# If only one color provided, use it for both colors
|
||||
if len(colors) < 2:
|
||||
color0 = colors[0]
|
||||
color1 = colors[0]
|
||||
else:
|
||||
color0 = colors[0]
|
||||
color1 = colors[1]
|
||||
|
||||
color0 = self.driver.apply_brightness(color0, preset.b)
|
||||
color1 = self.driver.apply_brightness(color1, preset.b)
|
||||
|
||||
n1 = max(1, int(preset.n1)) # LEDs of color 0
|
||||
n2 = max(1, int(preset.n2)) # LEDs of color 1
|
||||
n3 = int(preset.n3) # Step movement on even steps (can be negative)
|
||||
n4 = int(preset.n4) # Step movement on odd steps (can be negative)
|
||||
|
||||
segment_length = n1 + n2
|
||||
|
||||
# Calculate position from step_count
|
||||
step_count = self.driver.step
|
||||
# Position alternates: step 0 adds n3, step 1 adds n4, step 2 adds n3, etc.
|
||||
if step_count % 2 == 0:
|
||||
# Even steps: (step_count//2) pairs of (n3+n4) plus one extra n3
|
||||
position = (step_count // 2) * (n3 + n4) + n3
|
||||
else:
|
||||
# Odd steps: ((step_count+1)//2) pairs of (n3+n4)
|
||||
position = ((step_count + 1) // 2) * (n3 + n4)
|
||||
|
||||
# Wrap position to keep it reasonable
|
||||
max_pos = self.driver.num_leds + segment_length
|
||||
position = position % max_pos
|
||||
if position < 0:
|
||||
position += max_pos
|
||||
|
||||
# If auto is False, run a single step and then stop
|
||||
if not preset.a:
|
||||
# Clear all LEDs
|
||||
self.driver.n.fill((0, 0, 0))
|
||||
|
||||
# Draw repeating pattern starting at position
|
||||
for i in range(self.driver.num_leds):
|
||||
# Calculate position in the repeating segment
|
||||
relative_pos = (i - position) % segment_length
|
||||
if relative_pos < 0:
|
||||
relative_pos = (relative_pos + segment_length) % segment_length
|
||||
|
||||
# Determine which color based on position in segment
|
||||
if relative_pos < n1:
|
||||
self.driver.n[i] = color0
|
||||
else:
|
||||
self.driver.n[i] = color1
|
||||
|
||||
self.driver.n.write()
|
||||
|
||||
# Increment step for next beat
|
||||
self.driver.step = step_count + 1
|
||||
|
||||
# Allow tick() to advance the generator once
|
||||
yield
|
||||
return
|
||||
|
||||
# Auto mode: continuous loop
|
||||
# Use transition_duration for timing and force the first update to happen immediately
|
||||
transition_duration = max(10, int(preset.d))
|
||||
last_update = utime.ticks_ms() - transition_duration
|
||||
|
||||
while True:
|
||||
current_time = utime.ticks_ms()
|
||||
if utime.ticks_diff(current_time, last_update) >= transition_duration:
|
||||
# Calculate current position from step_count
|
||||
if step_count % 2 == 0:
|
||||
position = (step_count // 2) * (n3 + n4) + n3
|
||||
else:
|
||||
position = ((step_count + 1) // 2) * (n3 + n4)
|
||||
|
||||
# Wrap position
|
||||
max_pos = self.driver.num_leds + segment_length
|
||||
position = position % max_pos
|
||||
if position < 0:
|
||||
position += max_pos
|
||||
|
||||
# Clear all LEDs
|
||||
self.driver.n.fill((0, 0, 0))
|
||||
|
||||
# Draw repeating pattern starting at position
|
||||
for i in range(self.driver.num_leds):
|
||||
# Calculate position in the repeating segment
|
||||
relative_pos = (i - position) % segment_length
|
||||
if relative_pos < 0:
|
||||
relative_pos = (relative_pos + segment_length) % segment_length
|
||||
|
||||
# Determine which color based on position in segment
|
||||
if relative_pos < n1:
|
||||
self.driver.n[i] = color0
|
||||
else:
|
||||
self.driver.n[i] = color1
|
||||
|
||||
self.driver.n.write()
|
||||
|
||||
# Increment step
|
||||
step_count += 1
|
||||
self.driver.step = step_count
|
||||
last_update = current_time
|
||||
|
||||
# Yield once per tick so other logic can run
|
||||
yield
|
||||
@@ -0,0 +1,96 @@
|
||||
import utime
|
||||
|
||||
|
||||
class Circle:
|
||||
def __init__(self, driver):
|
||||
self.driver = driver
|
||||
|
||||
def run(self, preset):
|
||||
"""Circle loading pattern - grows to n2, then tail moves forward at n3 until min length n4"""
|
||||
head = 0
|
||||
tail = 0
|
||||
|
||||
# Calculate timing from preset
|
||||
head_rate = max(1, int(preset.n1)) # n1 = head moves per second
|
||||
tail_rate = max(1, int(preset.n3)) # n3 = tail moves per second
|
||||
max_length = max(1, int(preset.n2)) # n2 = max length
|
||||
min_length = max(0, int(preset.n4)) # n4 = min length
|
||||
|
||||
head_delay = 1000 // head_rate # ms between head movements
|
||||
tail_delay = 1000 // tail_rate # ms between tail movements
|
||||
|
||||
last_head_move = utime.ticks_ms()
|
||||
last_tail_move = utime.ticks_ms()
|
||||
|
||||
phase = "growing" # "growing", "shrinking", or "off"
|
||||
|
||||
# Support up to two colors (like chase). If only one color is provided,
|
||||
# use black for the second; if none, default to white.
|
||||
colors = preset.c
|
||||
if not colors:
|
||||
base0 = base1 = (255, 255, 255)
|
||||
elif len(colors) == 1:
|
||||
base0 = colors[0]
|
||||
base1 = (0, 0, 0)
|
||||
else:
|
||||
base0 = colors[0]
|
||||
base1 = colors[1]
|
||||
|
||||
color0 = self.driver.apply_brightness(base0, preset.b)
|
||||
color1 = self.driver.apply_brightness(base1, preset.b)
|
||||
|
||||
while True:
|
||||
current_time = utime.ticks_ms()
|
||||
|
||||
# Background: use second color during the "off" phase, otherwise clear to black
|
||||
if phase == "off":
|
||||
self.driver.n.fill(color1)
|
||||
else:
|
||||
self.driver.n.fill((0, 0, 0))
|
||||
|
||||
# Calculate segment length
|
||||
segment_length = (head - tail) % self.driver.num_leds
|
||||
if segment_length == 0 and head != tail:
|
||||
segment_length = self.driver.num_leds
|
||||
|
||||
# Draw segment from tail to head as a solid color (no per-LED alternation)
|
||||
current_color = color0
|
||||
for i in range(segment_length + 1):
|
||||
led_pos = (tail + i) % self.driver.num_leds
|
||||
self.driver.n[led_pos] = current_color
|
||||
|
||||
# Move head continuously at n1 LEDs per second
|
||||
if utime.ticks_diff(current_time, last_head_move) >= head_delay:
|
||||
head = (head + 1) % self.driver.num_leds
|
||||
last_head_move = current_time
|
||||
|
||||
# Tail behavior based on phase
|
||||
if phase == "growing":
|
||||
# Growing phase: tail stays at 0 until max length reached
|
||||
if segment_length >= max_length:
|
||||
phase = "shrinking"
|
||||
elif phase == "shrinking":
|
||||
# Shrinking phase: move tail forward at n3 LEDs per second
|
||||
if utime.ticks_diff(current_time, last_tail_move) >= tail_delay:
|
||||
tail = (tail + 1) % self.driver.num_leds
|
||||
last_tail_move = current_time
|
||||
|
||||
# Check if we've reached min length
|
||||
current_length = (head - tail) % self.driver.num_leds
|
||||
if current_length == 0 and head != tail:
|
||||
current_length = self.driver.num_leds
|
||||
|
||||
# For min_length = 0, we need at least 1 LED (the head)
|
||||
if min_length == 0 and current_length <= 1:
|
||||
phase = "off" # All LEDs off for 1 step
|
||||
elif min_length > 0 and current_length <= min_length:
|
||||
phase = "growing" # Cycle repeats
|
||||
else: # phase == "off"
|
||||
# Off phase: second color fills the ring for 1 step, then restart
|
||||
tail = head # Reset tail to head position to start fresh
|
||||
phase = "growing"
|
||||
|
||||
self.driver.n.write()
|
||||
|
||||
# Yield once per tick so other logic can run
|
||||
yield
|
||||
@@ -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
|
||||
@@ -0,0 +1,64 @@
|
||||
import utime
|
||||
|
||||
|
||||
class Pulse:
|
||||
def __init__(self, driver):
|
||||
self.driver = driver
|
||||
|
||||
def run(self, preset):
|
||||
self.driver.off()
|
||||
|
||||
# Get colors from preset
|
||||
colors = preset.c
|
||||
if not colors:
|
||||
colors = [(255, 255, 255)]
|
||||
|
||||
color_index = 0
|
||||
cycle_start = utime.ticks_ms()
|
||||
|
||||
# State machine based pulse using a single generator loop
|
||||
while True:
|
||||
# Read current timing parameters from preset
|
||||
attack_ms = max(0, int(preset.n1)) # Attack time in ms
|
||||
hold_ms = max(0, int(preset.n2)) # Hold time in ms
|
||||
decay_ms = max(0, int(preset.n3)) # Decay time in ms
|
||||
delay_ms = max(0, int(preset.d))
|
||||
|
||||
total_ms = attack_ms + hold_ms + decay_ms + delay_ms
|
||||
if total_ms <= 0:
|
||||
total_ms = 1
|
||||
|
||||
now = utime.ticks_ms()
|
||||
elapsed = utime.ticks_diff(now, cycle_start)
|
||||
|
||||
base_color = colors[color_index % len(colors)]
|
||||
|
||||
if elapsed < attack_ms and attack_ms > 0:
|
||||
# Attack: fade 0 -> 1
|
||||
factor = elapsed / attack_ms
|
||||
color = tuple(int(c * factor) for c in base_color)
|
||||
self.driver.fill(self.driver.apply_brightness(color, preset.b))
|
||||
elif elapsed < attack_ms + hold_ms:
|
||||
# Hold: full brightness
|
||||
self.driver.fill(self.driver.apply_brightness(base_color, preset.b))
|
||||
elif elapsed < attack_ms + hold_ms + decay_ms and decay_ms > 0:
|
||||
# Decay: fade 1 -> 0
|
||||
dec_elapsed = elapsed - attack_ms - hold_ms
|
||||
factor = max(0.0, 1.0 - (dec_elapsed / decay_ms))
|
||||
color = tuple(int(c * factor) for c in base_color)
|
||||
self.driver.fill(self.driver.apply_brightness(color, preset.b))
|
||||
elif elapsed < total_ms:
|
||||
# Delay phase: LEDs off between pulses
|
||||
self.driver.fill((0, 0, 0))
|
||||
else:
|
||||
# End of cycle, move to next color and restart timing
|
||||
color_index += 1
|
||||
cycle_start = now
|
||||
if not preset.a:
|
||||
break
|
||||
# Skip drawing this tick, start next cycle
|
||||
yield
|
||||
continue
|
||||
|
||||
# Yield once per tick
|
||||
yield
|
||||
@@ -0,0 +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
|
||||
self._buffers_cache = {}
|
||||
|
||||
def run(self, preset):
|
||||
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
|
||||
|
||||
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:
|
||||
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()
|
||||
if utime.ticks_diff(current_time, last_update) >= sleep_ms:
|
||||
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
|
||||
@@ -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()
|
||||
@@ -0,0 +1,57 @@
|
||||
import utime
|
||||
|
||||
|
||||
class Transition:
|
||||
def __init__(self, driver):
|
||||
self.driver = driver
|
||||
|
||||
def run(self, preset):
|
||||
"""Transition between colors, blending over `delay` ms."""
|
||||
colors = preset.c
|
||||
if not colors:
|
||||
self.driver.off()
|
||||
yield
|
||||
return
|
||||
|
||||
# Only one color: just keep it on
|
||||
if len(colors) == 1:
|
||||
while True:
|
||||
self.driver.fill(self.driver.apply_brightness(colors[0], preset.b))
|
||||
yield
|
||||
return
|
||||
|
||||
color_index = 0
|
||||
start_time = utime.ticks_ms()
|
||||
|
||||
while True:
|
||||
if not colors:
|
||||
break
|
||||
|
||||
# Get current and next color based on live list
|
||||
c1 = colors[color_index % len(colors)]
|
||||
c2 = colors[(color_index + 1) % len(colors)]
|
||||
|
||||
duration = max(10, int(preset.d)) # At least 10ms
|
||||
now = utime.ticks_ms()
|
||||
elapsed = utime.ticks_diff(now, start_time)
|
||||
|
||||
if elapsed >= duration:
|
||||
# End of this transition step
|
||||
if not preset.a:
|
||||
# One-shot: transition from first to second color only
|
||||
self.driver.fill(self.driver.apply_brightness(c2, preset.b))
|
||||
break
|
||||
# Auto: move to next pair
|
||||
color_index = (color_index + 1) % len(colors)
|
||||
start_time = now
|
||||
yield
|
||||
continue
|
||||
|
||||
# Interpolate between c1 and c2
|
||||
factor = elapsed / duration
|
||||
interpolated = tuple(
|
||||
int(c1[i] + (c2[i] - c1[i]) * factor) for i in range(3)
|
||||
)
|
||||
self.driver.fill(self.driver.apply_brightness(interpolated, preset.b))
|
||||
|
||||
yield
|
||||
@@ -0,0 +1,83 @@
|
||||
class Preset:
|
||||
def __init__(self, data):
|
||||
# Set default values for all preset attributes
|
||||
self.p = "off"
|
||||
self.d = 100
|
||||
self.b = 127
|
||||
self.c = [(255, 255, 255)]
|
||||
self.a = True
|
||||
self.n1 = 0
|
||||
self.n2 = 0
|
||||
self.n3 = 0
|
||||
self.n4 = 0
|
||||
self.n5 = 0
|
||||
self.n6 = 0
|
||||
self.n7 = 0
|
||||
self.n8 = 0
|
||||
|
||||
# Override defaults with provided data
|
||||
self.edit(data)
|
||||
|
||||
def edit(self, data=None):
|
||||
if not data:
|
||||
return False
|
||||
for key, value in data.items():
|
||||
setattr(self, key, value)
|
||||
return True
|
||||
|
||||
@property
|
||||
def pattern(self):
|
||||
return self.p
|
||||
|
||||
@pattern.setter
|
||||
def pattern(self, value):
|
||||
self.p = value
|
||||
|
||||
@property
|
||||
def delay(self):
|
||||
return self.d
|
||||
|
||||
@delay.setter
|
||||
def delay(self, value):
|
||||
self.d = value
|
||||
|
||||
@property
|
||||
def brightness(self):
|
||||
return self.b
|
||||
|
||||
@brightness.setter
|
||||
def brightness(self, value):
|
||||
self.b = value
|
||||
|
||||
@property
|
||||
def colors(self):
|
||||
return self.c
|
||||
|
||||
@colors.setter
|
||||
def colors(self, value):
|
||||
self.c = value
|
||||
|
||||
@property
|
||||
def auto(self):
|
||||
return self.a
|
||||
|
||||
@auto.setter
|
||||
def auto(self, value):
|
||||
self.a = value
|
||||
|
||||
def to_dict(self):
|
||||
return {
|
||||
"p": self.p,
|
||||
"d": self.d,
|
||||
"b": self.b,
|
||||
"c": self.c,
|
||||
"a": self.a,
|
||||
"n1": self.n1,
|
||||
"n2": self.n2,
|
||||
"n3": self.n3,
|
||||
"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
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,207 @@
|
||||
from machine import Pin
|
||||
from ws2812 import WS2812B
|
||||
import dma
|
||||
from preset import Preset
|
||||
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):
|
||||
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)
|
||||
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
|
||||
|
||||
self.generator = None
|
||||
self.presets = {}
|
||||
self.selected = None
|
||||
|
||||
# Register all pattern methods
|
||||
self.patterns = {
|
||||
"off": self.off,
|
||||
"on": self.on,
|
||||
"blink": Blink(self).run,
|
||||
"rainbow": Rainbow(self).run,
|
||||
"pulse": Pulse(self).run,
|
||||
"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:
|
||||
json.dump({name: preset.to_dict() for name, preset in self.presets.items()}, f)
|
||||
return True
|
||||
|
||||
def load(self):
|
||||
"""Load presets from a file."""
|
||||
try:
|
||||
with open("presets.json", "r") as f:
|
||||
data = json.load(f)
|
||||
except OSError:
|
||||
# Create an empty presets file if missing
|
||||
self.presets = {}
|
||||
self.save()
|
||||
return True
|
||||
|
||||
self.presets = {}
|
||||
for name, preset_data in data.items():
|
||||
if "c" in preset_data:
|
||||
preset_data["c"] = [tuple(color) for color in preset_data["c"]]
|
||||
self.presets[name] = Preset(preset_data)
|
||||
if self.presets:
|
||||
print("Loaded presets:")
|
||||
#for name in sorted(self.presets.keys()):
|
||||
# print(f" {name}: {self.presets[name].to_dict()}")
|
||||
return True
|
||||
|
||||
def edit(self, name, data):
|
||||
"""Create or update a preset with the given name."""
|
||||
if name in self.presets:
|
||||
# Update existing preset
|
||||
self.presets[name].edit(data)
|
||||
else:
|
||||
# Create new preset
|
||||
self.presets[name] = Preset(data)
|
||||
return True
|
||||
|
||||
def delete(self, name):
|
||||
if name in self.presets:
|
||||
del self.presets[name]
|
||||
return True
|
||||
return False
|
||||
|
||||
def tick(self):
|
||||
if self.generator is None:
|
||||
return
|
||||
try:
|
||||
next(self.generator)
|
||||
except StopIteration:
|
||||
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]
|
||||
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
|
||||
local = brightness_override if brightness_override is not None else 255
|
||||
# Scale preset brightness by global brightness
|
||||
effective_brightness = int(local * self.b / 255)
|
||||
return tuple(int(c * effective_brightness / 255) for c in color)
|
||||
|
||||
def off(self, preset=None):
|
||||
self.fill((0, 0, 0))
|
||||
|
||||
def on(self, preset):
|
||||
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])
|
||||
@@ -0,0 +1,53 @@
|
||||
def convert_and_reorder_colors(colors, settings_or_color_order):
|
||||
"""Convert hex color strings to RGB tuples and reorder based on device color order.
|
||||
|
||||
Args:
|
||||
colors: List of colors, either hex strings like "#FF0000" or RGB tuples like (255, 0, 0)
|
||||
settings_or_color_order: Either a Settings object or a color_order string (e.g., "rgb", "grb")
|
||||
|
||||
Returns:
|
||||
List of RGB tuples reordered according to device color order
|
||||
"""
|
||||
# Get channel order from settings or color_order string
|
||||
if hasattr(settings_or_color_order, 'get_rgb_channel_order'):
|
||||
# It's a Settings object
|
||||
channel_order = settings_or_color_order.get_rgb_channel_order()
|
||||
elif isinstance(settings_or_color_order, str):
|
||||
# It's a color_order string, convert to channel order
|
||||
color_order = settings_or_color_order.lower()
|
||||
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)
|
||||
}
|
||||
hex_indices = color_orders.get(color_order, (1, 3, 5))
|
||||
# Map hex string positions to RGB channel indices
|
||||
hex_to_channel = {1: 0, 3: 1, 5: 2}
|
||||
channel_order = tuple(hex_to_channel[pos] for pos in hex_indices)
|
||||
else:
|
||||
# Assume it's already a channel order tuple
|
||||
channel_order = settings_or_color_order
|
||||
|
||||
converted_colors = []
|
||||
for color in colors:
|
||||
# Convert "#RRGGBB" to (R, G, B)
|
||||
if isinstance(color, str) and color.startswith("#"):
|
||||
r = int(color[1:3], 16)
|
||||
g = int(color[3:5], 16)
|
||||
b = int(color[5:7], 16)
|
||||
rgb = (r, g, b)
|
||||
# Reorder based on device color order
|
||||
reordered = (rgb[channel_order[0]], rgb[channel_order[1]], rgb[channel_order[2]])
|
||||
converted_colors.append(reordered)
|
||||
elif isinstance(color, (list, tuple)) and len(color) == 3:
|
||||
# Already a tuple/list, just reorder
|
||||
rgb = tuple(color)
|
||||
reordered = (rgb[channel_order[0]], rgb[channel_order[1]], rgb[channel_order[2]])
|
||||
converted_colors.append(reordered)
|
||||
else:
|
||||
# Keep as-is if not recognized format
|
||||
converted_colors.append(color)
|
||||
return converted_colors
|
||||
@@ -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)
|
||||
@@ -0,0 +1,32 @@
|
||||
from ws2812 import WS2812B
|
||||
import time
|
||||
|
||||
|
||||
# --- Rainbow pattern (outside ws2812): pregen double buffer, show via head offset ---
|
||||
|
||||
|
||||
# --- Strips + rainbow buffers per strip ---
|
||||
|
||||
strips = []
|
||||
pins = ((2, 291),
|
||||
(3, 290),
|
||||
(4, 283),
|
||||
(7, 278),
|
||||
(0, 275),
|
||||
(28, 278),
|
||||
(29, 283),
|
||||
(6, 290))
|
||||
|
||||
sm = 0
|
||||
|
||||
for pin, num_leds in pins:
|
||||
print(pin, num_leds)
|
||||
ws = WS2812B(num_leds, pin, sm, brightness=1.0) # 1.0 so fill() is visible
|
||||
strips.append(ws)
|
||||
sm += 1
|
||||
ws.fill((8,0,0))
|
||||
ws.show()
|
||||
time.sleep(1)
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,190 @@
|
||||
#!/usr/bin/env python3
|
||||
import utime
|
||||
from machine import WDT
|
||||
from settings import Settings
|
||||
from presets import Presets
|
||||
|
||||
|
||||
def run_for(p, wdt, duration_ms):
|
||||
"""Run pattern for specified duration."""
|
||||
start = utime.ticks_ms()
|
||||
while utime.ticks_diff(utime.ticks_ms(), start) < duration_ms:
|
||||
wdt.feed()
|
||||
p.tick()
|
||||
utime.sleep_ms(10)
|
||||
|
||||
|
||||
def main():
|
||||
s = Settings()
|
||||
pin = s.get("led_pin", 10)
|
||||
num = s.get("num_leds", 30)
|
||||
|
||||
p = Presets(pin=pin, num_leds=num)
|
||||
wdt = WDT(timeout=10000)
|
||||
|
||||
print("=" * 50)
|
||||
print("Testing Auto and Manual Modes")
|
||||
print("=" * 50)
|
||||
|
||||
# Test 1: Rainbow in AUTO mode (continuous)
|
||||
print("\nTest 1: Rainbow pattern in AUTO mode (should run continuously)")
|
||||
p.edit("rainbow_auto", {
|
||||
"p": "rainbow",
|
||||
"b": 128,
|
||||
"d": 50,
|
||||
"n1": 2,
|
||||
"a": True,
|
||||
})
|
||||
p.select("rainbow_auto")
|
||||
print("Running rainbow_auto for 3 seconds...")
|
||||
run_for(p, wdt, 3000)
|
||||
print("✓ Auto mode: Pattern ran continuously")
|
||||
|
||||
# Test 2: Rainbow in MANUAL mode (one step per tick)
|
||||
print("\nTest 2: Rainbow pattern in MANUAL mode (one step per tick)")
|
||||
p.edit("rainbow_manual", {
|
||||
"p": "rainbow",
|
||||
"b": 128,
|
||||
"d": 50,
|
||||
"n1": 2,
|
||||
"a": False,
|
||||
})
|
||||
p.select("rainbow_manual")
|
||||
print("Calling tick() 5 times (should advance 5 steps)...")
|
||||
for i in range(5):
|
||||
p.tick()
|
||||
utime.sleep_ms(100) # Small delay to see changes
|
||||
print(f" Tick {i+1}: generator={'active' if p.generator is not None else 'stopped'}")
|
||||
|
||||
# Check if generator stopped after one cycle
|
||||
if p.generator is None:
|
||||
print("✓ Manual mode: Generator stopped after one step (as expected)")
|
||||
else:
|
||||
print("⚠ Manual mode: Generator still active (may need multiple ticks)")
|
||||
|
||||
# Test 3: Pulse in AUTO mode (continuous cycles)
|
||||
print("\nTest 3: Pulse pattern in AUTO mode (should pulse continuously)")
|
||||
p.edit("pulse_auto", {
|
||||
"p": "pulse",
|
||||
"b": 128,
|
||||
"d": 100,
|
||||
"n1": 500, # Attack
|
||||
"n2": 200, # Hold
|
||||
"n3": 500, # Decay
|
||||
"c": [(255, 0, 0)],
|
||||
"a": True,
|
||||
})
|
||||
p.select("pulse_auto")
|
||||
print("Running pulse_auto for 3 seconds...")
|
||||
run_for(p, wdt, 3000)
|
||||
print("✓ Auto mode: Pulse ran continuously")
|
||||
|
||||
# Test 4: Pulse in MANUAL mode (one cycle then stop)
|
||||
print("\nTest 4: Pulse pattern in MANUAL mode (one cycle then stop)")
|
||||
p.edit("pulse_manual", {
|
||||
"p": "pulse",
|
||||
"b": 128,
|
||||
"d": 100,
|
||||
"n1": 300, # Attack
|
||||
"n2": 200, # Hold
|
||||
"n3": 300, # Decay
|
||||
"c": [(0, 255, 0)],
|
||||
"a": False,
|
||||
})
|
||||
p.select("pulse_manual")
|
||||
print("Running pulse_manual until generator stops...")
|
||||
tick_count = 0
|
||||
max_ticks = 200 # Safety limit
|
||||
while p.generator is not None and tick_count < max_ticks:
|
||||
p.tick()
|
||||
tick_count += 1
|
||||
utime.sleep_ms(10)
|
||||
|
||||
if p.generator is None:
|
||||
print(f"✓ Manual mode: Pulse completed one cycle after {tick_count} ticks")
|
||||
else:
|
||||
print(f"⚠ Manual mode: Pulse still running after {tick_count} ticks")
|
||||
|
||||
# Test 5: Transition in AUTO mode (continuous transitions)
|
||||
print("\nTest 5: Transition pattern in AUTO mode (continuous transitions)")
|
||||
p.edit("transition_auto", {
|
||||
"p": "transition",
|
||||
"b": 128,
|
||||
"d": 500,
|
||||
"c": [(255, 0, 0), (0, 255, 0), (0, 0, 255)],
|
||||
"a": True,
|
||||
})
|
||||
p.select("transition_auto")
|
||||
print("Running transition_auto for 3 seconds...")
|
||||
run_for(p, wdt, 3000)
|
||||
print("✓ Auto mode: Transition ran continuously")
|
||||
|
||||
# Test 6: Transition in MANUAL mode (one transition then stop)
|
||||
print("\nTest 6: Transition pattern in MANUAL mode (one transition then stop)")
|
||||
p.edit("transition_manual", {
|
||||
"p": "transition",
|
||||
"b": 128,
|
||||
"d": 500,
|
||||
"c": [(255, 0, 0), (0, 255, 0)],
|
||||
"a": False,
|
||||
})
|
||||
p.select("transition_manual")
|
||||
print("Running transition_manual until generator stops...")
|
||||
tick_count = 0
|
||||
max_ticks = 200
|
||||
while p.generator is not None and tick_count < max_ticks:
|
||||
p.tick()
|
||||
tick_count += 1
|
||||
utime.sleep_ms(10)
|
||||
|
||||
if p.generator is None:
|
||||
print(f"✓ Manual mode: Transition completed after {tick_count} ticks")
|
||||
else:
|
||||
print(f"⚠ Manual mode: Transition still running after {tick_count} ticks")
|
||||
|
||||
# Test 7: Switching between auto and manual modes
|
||||
print("\nTest 7: Switching between auto and manual modes")
|
||||
p.edit("switch_test", {
|
||||
"p": "rainbow",
|
||||
"b": 128,
|
||||
"d": 50,
|
||||
"n1": 2,
|
||||
"a": True,
|
||||
})
|
||||
p.select("switch_test")
|
||||
print("Running in auto mode for 1 second...")
|
||||
run_for(p, wdt, 1000)
|
||||
|
||||
# Switch to manual mode by editing the preset
|
||||
print("Switching to manual mode...")
|
||||
p.edit("switch_test", {"a": False})
|
||||
p.select("switch_test") # Re-select to apply changes
|
||||
|
||||
print("Calling tick() 3 times in manual mode...")
|
||||
for i in range(3):
|
||||
p.tick()
|
||||
utime.sleep_ms(100)
|
||||
print(f" Tick {i+1}: generator={'active' if p.generator is not None else 'stopped'}")
|
||||
|
||||
# Switch back to auto mode
|
||||
print("Switching back to auto mode...")
|
||||
p.edit("switch_test", {"a": True})
|
||||
p.select("switch_test")
|
||||
print("Running in auto mode for 1 second...")
|
||||
run_for(p, wdt, 1000)
|
||||
print("✓ Successfully switched between auto and manual modes")
|
||||
|
||||
# Cleanup
|
||||
print("\nCleaning up...")
|
||||
p.edit("cleanup_off", {"p": "off"})
|
||||
p.select("cleanup_off")
|
||||
p.tick()
|
||||
utime.sleep_ms(100)
|
||||
|
||||
print("\n" + "=" * 50)
|
||||
print("All tests completed!")
|
||||
print("=" * 50)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,35 @@
|
||||
#!/usr/bin/env python3
|
||||
import utime
|
||||
from machine import WDT
|
||||
from settings import Settings
|
||||
from presets import Presets
|
||||
|
||||
|
||||
def main():
|
||||
s = Settings()
|
||||
pin = s.get("led_pin", 10)
|
||||
num = s.get("num_leds", 30)
|
||||
|
||||
p = Presets(pin=pin, num_leds=num)
|
||||
wdt = WDT(timeout=10000)
|
||||
|
||||
# Create blink preset (use short-key fields: p=pattern, b=brightness, d=delay, c=colors)
|
||||
p.edit("test_blink", {
|
||||
"p": "blink",
|
||||
"b": 64,
|
||||
"d": 200,
|
||||
"c": [(255, 0, 0), (0, 0, 255)],
|
||||
})
|
||||
p.select("test_blink")
|
||||
|
||||
start = utime.ticks_ms()
|
||||
while utime.ticks_diff(utime.ticks_ms(), start) < 1500:
|
||||
wdt.feed()
|
||||
p.tick()
|
||||
utime.sleep_ms(10)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
|
||||
|
||||
@@ -0,0 +1,161 @@
|
||||
#!/usr/bin/env python3
|
||||
import utime
|
||||
from machine import WDT
|
||||
from settings import Settings
|
||||
from presets import Presets
|
||||
|
||||
|
||||
def run_for(p, wdt, ms):
|
||||
"""Helper: run current pattern for given ms using tick()."""
|
||||
start = utime.ticks_ms()
|
||||
while utime.ticks_diff(utime.ticks_ms(), start) < ms:
|
||||
wdt.feed()
|
||||
p.tick()
|
||||
utime.sleep_ms(10)
|
||||
|
||||
|
||||
def main():
|
||||
s = Settings()
|
||||
pin = s.get("led_pin", 10)
|
||||
num = s.get("num_leds", 30)
|
||||
|
||||
p = Presets(pin=pin, num_leds=num)
|
||||
wdt = WDT(timeout=10000)
|
||||
|
||||
# Test 1: Basic chase (n1=5, n2=5, n3=1, n4=1)
|
||||
print("Test 1: Basic chase (n1=5, n2=5, n3=1, n4=1)")
|
||||
p.edit("chase1", {
|
||||
"p": "chase",
|
||||
"b": 255,
|
||||
"d": 200,
|
||||
"n1": 5,
|
||||
"n2": 5,
|
||||
"n3": 1,
|
||||
"n4": 1,
|
||||
"c": [(255, 0, 0), (0, 255, 0)],
|
||||
})
|
||||
p.select("chase1")
|
||||
run_for(p, wdt, 3000)
|
||||
|
||||
# Test 2: Forward and backward (n3=2, n4=-1)
|
||||
print("Test 2: Forward and backward (n3=2, n4=-1)")
|
||||
p.edit("chase2", {
|
||||
"p": "chase",
|
||||
"n1": 3,
|
||||
"n2": 3,
|
||||
"n3": 2,
|
||||
"n4": -1,
|
||||
"d": 150,
|
||||
"c": [(0, 0, 255), (255, 255, 0)],
|
||||
})
|
||||
p.select("chase2")
|
||||
run_for(p, wdt, 3000)
|
||||
|
||||
# Test 3: Large segments (n1=10, n2=5)
|
||||
print("Test 3: Large segments (n1=10, n2=5, n3=3, n4=3)")
|
||||
p.edit("chase3", {
|
||||
"p": "chase",
|
||||
"n1": 10,
|
||||
"n2": 5,
|
||||
"n3": 3,
|
||||
"n4": 3,
|
||||
"d": 200,
|
||||
"c": [(255, 128, 0), (128, 0, 255)],
|
||||
})
|
||||
p.select("chase3")
|
||||
run_for(p, wdt, 3000)
|
||||
|
||||
# Test 4: Fast movement (n3=5, n4=5)
|
||||
print("Test 4: Fast movement (n3=5, n4=5)")
|
||||
p.edit("chase4", {
|
||||
"p": "chase",
|
||||
"n1": 4,
|
||||
"n2": 4,
|
||||
"n3": 5,
|
||||
"n4": 5,
|
||||
"d": 100,
|
||||
"c": [(255, 0, 255), (0, 255, 255)],
|
||||
})
|
||||
p.select("chase4")
|
||||
run_for(p, wdt, 2000)
|
||||
|
||||
# Test 5: Backward movement (n3=-2, n4=-2)
|
||||
print("Test 5: Backward movement (n3=-2, n4=-2)")
|
||||
p.edit("chase5", {
|
||||
"p": "chase",
|
||||
"n1": 6,
|
||||
"n2": 4,
|
||||
"n3": -2,
|
||||
"n4": -2,
|
||||
"d": 200,
|
||||
"c": [(255, 255, 255), (0, 0, 0)],
|
||||
})
|
||||
p.select("chase5")
|
||||
run_for(p, wdt, 3000)
|
||||
|
||||
# Test 6: Alternating forward/backward (n3=3, n4=-2)
|
||||
print("Test 6: Alternating forward/backward (n3=3, n4=-2)")
|
||||
p.edit("chase6", {
|
||||
"p": "chase",
|
||||
"n1": 5,
|
||||
"n2": 5,
|
||||
"n3": 3,
|
||||
"n4": -2,
|
||||
"d": 250,
|
||||
"c": [(255, 0, 0), (0, 255, 0)],
|
||||
})
|
||||
p.select("chase6")
|
||||
run_for(p, wdt, 4000)
|
||||
|
||||
# Test 7: Manual mode - advance one step per beat
|
||||
print("Test 7: Manual mode chase (auto=False, n3=2, n4=1)")
|
||||
p.edit("chase_manual", {
|
||||
"p": "chase",
|
||||
"n1": 4,
|
||||
"n2": 4,
|
||||
"n3": 2,
|
||||
"n4": 1,
|
||||
"d": 200,
|
||||
"c": [(255, 255, 0), (0, 255, 255)],
|
||||
"a": False,
|
||||
})
|
||||
p.step = 0 # Reset step counter
|
||||
print(" Advancing pattern with 10 beats (select + tick)...")
|
||||
for i in range(10):
|
||||
p.select("chase_manual") # Simulate beat - restarts generator
|
||||
p.tick() # Advance one step
|
||||
utime.sleep_ms(500) # Pause to see the pattern
|
||||
wdt.feed()
|
||||
print(f" Beat {i+1}: step={p.step}")
|
||||
|
||||
# Test 8: Verify step increments correctly in manual mode
|
||||
print("Test 8: Verify step increments (auto=False)")
|
||||
p.edit("chase_manual2", {
|
||||
"p": "chase",
|
||||
"n1": 3,
|
||||
"n2": 3,
|
||||
"n3": 1,
|
||||
"n4": 1,
|
||||
"a": False,
|
||||
})
|
||||
p.step = 0
|
||||
initial_step = p.step
|
||||
p.select("chase_manual2")
|
||||
p.tick()
|
||||
final_step = p.step
|
||||
print(f" Step updated from {initial_step} to {final_step} (expected: 1)")
|
||||
if final_step == 1:
|
||||
print(" ✓ Step increment working correctly")
|
||||
else:
|
||||
print(f" ✗ Step increment mismatch! Expected 1, got {final_step}")
|
||||
|
||||
# Cleanup
|
||||
print("Test complete, turning off")
|
||||
p.edit("cleanup_off", {"p": "off"})
|
||||
p.select("cleanup_off")
|
||||
run_for(p, wdt, 100)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
|
||||
@@ -0,0 +1,113 @@
|
||||
#!/usr/bin/env python3
|
||||
import utime
|
||||
from machine import WDT
|
||||
from settings import Settings
|
||||
from presets import Presets
|
||||
|
||||
|
||||
def run_for(p, wdt, ms):
|
||||
"""Helper: run current pattern for given ms using tick()."""
|
||||
start = utime.ticks_ms()
|
||||
while utime.ticks_diff(utime.ticks_ms(), start) < ms:
|
||||
wdt.feed()
|
||||
p.tick()
|
||||
utime.sleep_ms(10)
|
||||
|
||||
|
||||
def main():
|
||||
s = Settings()
|
||||
pin = s.get("led_pin", 10)
|
||||
num = s.get("num_leds", 30)
|
||||
|
||||
p = Presets(pin=pin, num_leds=num)
|
||||
wdt = WDT(timeout=10000)
|
||||
|
||||
# Test 1: Basic circle (n1=50, n2=100, n3=200, n4=0)
|
||||
print("Test 1: Basic circle (n1=50, n2=100, n3=200, n4=0)")
|
||||
p.edit("circle1", {
|
||||
"p": "circle",
|
||||
"b": 255,
|
||||
"n1": 50, # Head moves 50 LEDs/second
|
||||
"n2": 100, # Max length 100 LEDs
|
||||
"n3": 200, # Tail moves 200 LEDs/second
|
||||
"n4": 0, # Min length 0 LEDs
|
||||
"c": [(255, 0, 0)], # Red
|
||||
})
|
||||
p.select("circle1")
|
||||
run_for(p, wdt, 5000)
|
||||
|
||||
# Test 2: Slow growth, fast shrink (n1=20, n2=50, n3=100, n4=0)
|
||||
print("Test 2: Slow growth, fast shrink (n1=20, n2=50, n3=100, n4=0)")
|
||||
p.edit("circle2", {
|
||||
"p": "circle",
|
||||
"n1": 20,
|
||||
"n2": 50,
|
||||
"n3": 100,
|
||||
"n4": 0,
|
||||
"c": [(0, 255, 0)], # Green
|
||||
})
|
||||
p.select("circle2")
|
||||
run_for(p, wdt, 5000)
|
||||
|
||||
# Test 3: Fast growth, slow shrink (n1=100, n2=30, n3=20, n4=0)
|
||||
print("Test 3: Fast growth, slow shrink (n1=100, n2=30, n3=20, n4=0)")
|
||||
p.edit("circle3", {
|
||||
"p": "circle",
|
||||
"n1": 100,
|
||||
"n2": 30,
|
||||
"n3": 20,
|
||||
"n4": 0,
|
||||
"c": [(0, 0, 255)], # Blue
|
||||
})
|
||||
p.select("circle3")
|
||||
run_for(p, wdt, 5000)
|
||||
|
||||
# Test 4: With minimum length (n1=50, n2=40, n3=100, n4=10)
|
||||
print("Test 4: With minimum length (n1=50, n2=40, n3=100, n4=10)")
|
||||
p.edit("circle4", {
|
||||
"p": "circle",
|
||||
"n1": 50,
|
||||
"n2": 40,
|
||||
"n3": 100,
|
||||
"n4": 10,
|
||||
"c": [(255, 255, 0)], # Yellow
|
||||
})
|
||||
p.select("circle4")
|
||||
run_for(p, wdt, 5000)
|
||||
|
||||
# Test 5: Very fast (n1=200, n2=20, n3=200, n4=0)
|
||||
print("Test 5: Very fast (n1=200, n2=20, n3=200, n4=0)")
|
||||
p.edit("circle5", {
|
||||
"p": "circle",
|
||||
"n1": 200,
|
||||
"n2": 20,
|
||||
"n3": 200,
|
||||
"n4": 0,
|
||||
"c": [(255, 0, 255)], # Magenta
|
||||
})
|
||||
p.select("circle5")
|
||||
run_for(p, wdt, 3000)
|
||||
|
||||
# Test 6: Very slow (n1=10, n2=25, n3=10, n4=0)
|
||||
print("Test 6: Very slow (n1=10, n2=25, n3=10, n4=0)")
|
||||
p.edit("circle6", {
|
||||
"p": "circle",
|
||||
"n1": 10,
|
||||
"n2": 25,
|
||||
"n3": 10,
|
||||
"n4": 0,
|
||||
"c": [(0, 255, 255)], # Cyan
|
||||
})
|
||||
p.select("circle6")
|
||||
run_for(p, wdt, 5000)
|
||||
|
||||
# Cleanup
|
||||
print("Test complete, turning off")
|
||||
p.edit("cleanup_off", {"p": "off"})
|
||||
p.select("cleanup_off")
|
||||
run_for(p, wdt, 100)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
|
||||
@@ -0,0 +1,30 @@
|
||||
#!/usr/bin/env python3
|
||||
import utime
|
||||
from machine import WDT
|
||||
from settings import Settings
|
||||
from presets import Presets
|
||||
|
||||
|
||||
def main():
|
||||
s = Settings()
|
||||
pin = s.get("led_pin", 10)
|
||||
num = s.get("num_leds", 30)
|
||||
|
||||
p = Presets(pin=pin, num_leds=num)
|
||||
wdt = WDT(timeout=10000)
|
||||
|
||||
# Create an "off" preset (use short-key field `p` for pattern)
|
||||
p.edit("test_off", {"p": "off"})
|
||||
p.select("test_off")
|
||||
|
||||
start = utime.ticks_ms()
|
||||
while utime.ticks_diff(utime.ticks_ms(), start) < 200:
|
||||
wdt.feed()
|
||||
p.tick()
|
||||
utime.sleep_ms(10)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
|
||||
|
||||
@@ -0,0 +1,47 @@
|
||||
#!/usr/bin/env python3
|
||||
import utime
|
||||
from machine import WDT
|
||||
from settings import Settings
|
||||
from presets import Presets
|
||||
|
||||
|
||||
def main():
|
||||
s = Settings()
|
||||
pin = s.get("led_pin", 10)
|
||||
num = s.get("num_leds", 30)
|
||||
|
||||
p = Presets(pin=pin, num_leds=num)
|
||||
wdt = WDT(timeout=10000)
|
||||
|
||||
# Create presets for on and off using the short-key fields that Presets expects
|
||||
# Preset fields:
|
||||
# p = pattern name, b = brightness, d = delay, c = list of (r,g,b) colors
|
||||
p.edit("test_on", {
|
||||
"p": "on",
|
||||
"b": 64,
|
||||
"d": 120,
|
||||
"c": [(255, 0, 0), (0, 0, 255)],
|
||||
})
|
||||
p.edit("test_off", {"p": "off"})
|
||||
|
||||
# ON phase
|
||||
p.select("test_on")
|
||||
start = utime.ticks_ms()
|
||||
while utime.ticks_diff(utime.ticks_ms(), start) < 800:
|
||||
wdt.feed()
|
||||
p.tick()
|
||||
utime.sleep_ms(10)
|
||||
|
||||
# OFF phase
|
||||
p.select("test_off")
|
||||
start = utime.ticks_ms()
|
||||
while utime.ticks_diff(utime.ticks_ms(), start) < 100:
|
||||
wdt.feed()
|
||||
p.tick()
|
||||
utime.sleep_ms(10)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
|
||||
|
||||
@@ -0,0 +1,92 @@
|
||||
#!/usr/bin/env python3
|
||||
import utime
|
||||
from machine import WDT
|
||||
from settings import Settings
|
||||
from presets import Presets
|
||||
|
||||
|
||||
def run_for(p, wdt, ms):
|
||||
"""Helper: run current pattern for given ms using tick()."""
|
||||
start = utime.ticks_ms()
|
||||
while utime.ticks_diff(utime.ticks_ms(), start) < ms:
|
||||
wdt.feed()
|
||||
p.tick()
|
||||
utime.sleep_ms(10)
|
||||
|
||||
|
||||
def main():
|
||||
s = Settings()
|
||||
pin = s.get("led_pin", 10)
|
||||
num = s.get("num_leds", 30)
|
||||
|
||||
p = Presets(pin=pin, num_leds=num)
|
||||
wdt = WDT(timeout=10000)
|
||||
|
||||
# Test 1: Simple single-color pulse
|
||||
print("Test 1: Single-color pulse (attack=500, hold=500, decay=500, delay=500)")
|
||||
p.edit("pulse1", {
|
||||
"p": "pulse",
|
||||
"b": 255,
|
||||
"c": [(255, 0, 0)],
|
||||
"n1": 500, # attack ms
|
||||
"n2": 500, # hold ms
|
||||
"n3": 500, # decay ms
|
||||
"d": 500, # delay ms between pulses
|
||||
"a": True,
|
||||
})
|
||||
p.select("pulse1")
|
||||
run_for(p, wdt, 5000)
|
||||
|
||||
# Test 2: Faster pulse
|
||||
print("Test 2: Fast pulse (attack=100, hold=100, decay=100, delay=100)")
|
||||
p.edit("pulse2", {
|
||||
"p": "pulse",
|
||||
"n1": 100,
|
||||
"n2": 100,
|
||||
"n3": 100,
|
||||
"d": 100,
|
||||
"c": [(0, 255, 0)],
|
||||
})
|
||||
p.select("pulse2")
|
||||
run_for(p, wdt, 4000)
|
||||
|
||||
# Test 3: Multi-color pulse cycle
|
||||
print("Test 3: Multi-color pulse (red -> green -> blue)")
|
||||
p.edit("pulse3", {
|
||||
"p": "pulse",
|
||||
"n1": 300,
|
||||
"n2": 300,
|
||||
"n3": 300,
|
||||
"d": 200,
|
||||
"c": [(255, 0, 0), (0, 255, 0), (0, 0, 255)],
|
||||
"a": True,
|
||||
})
|
||||
p.select("pulse3")
|
||||
run_for(p, wdt, 6000)
|
||||
|
||||
# Test 4: One-shot pulse (auto=False)
|
||||
print("Test 4: Single pulse, auto=False")
|
||||
p.edit("pulse4", {
|
||||
"p": "pulse",
|
||||
"n1": 400,
|
||||
"n2": 0,
|
||||
"n3": 400,
|
||||
"d": 0,
|
||||
"c": [(255, 255, 255)],
|
||||
"a": False,
|
||||
})
|
||||
p.select("pulse4")
|
||||
# Run long enough to allow one full pulse cycle
|
||||
run_for(p, wdt, 1500)
|
||||
|
||||
# Cleanup
|
||||
print("Test complete, turning off")
|
||||
p.edit("cleanup_off", {"p": "off"})
|
||||
p.select("cleanup_off")
|
||||
run_for(p, wdt, 200)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
|
||||
|
||||
@@ -0,0 +1,151 @@
|
||||
#!/usr/bin/env python3
|
||||
import utime
|
||||
from machine import WDT
|
||||
from settings import Settings
|
||||
from presets import Presets
|
||||
|
||||
|
||||
def run_for(p, wdt, ms):
|
||||
"""Helper: run current pattern for given ms using tick()."""
|
||||
start = utime.ticks_ms()
|
||||
while utime.ticks_diff(utime.ticks_ms(), start) < ms:
|
||||
wdt.feed()
|
||||
p.tick()
|
||||
utime.sleep_ms(10)
|
||||
|
||||
|
||||
def main():
|
||||
s = Settings()
|
||||
pin = s.get("led_pin", 10)
|
||||
num = s.get("num_leds", 30)
|
||||
|
||||
p = Presets(pin=pin, num_leds=num)
|
||||
wdt = WDT(timeout=10000)
|
||||
|
||||
# Test 1: Basic rainbow with auto=True (continuous)
|
||||
print("Test 1: Basic rainbow (auto=True, n1=1)")
|
||||
p.edit("rainbow1", {
|
||||
"p": "rainbow",
|
||||
"b": 255,
|
||||
"d": 100,
|
||||
"n1": 1,
|
||||
"a": True,
|
||||
})
|
||||
p.select("rainbow1")
|
||||
run_for(p, wdt, 3000)
|
||||
|
||||
# Test 2: Fast rainbow
|
||||
print("Test 2: Fast rainbow (low delay, n1=1)")
|
||||
p.edit("rainbow2", {
|
||||
"p": "rainbow",
|
||||
"d": 50,
|
||||
"n1": 1,
|
||||
"a": True,
|
||||
})
|
||||
p.select("rainbow2")
|
||||
run_for(p, wdt, 2000)
|
||||
|
||||
# Test 3: Slow rainbow
|
||||
print("Test 3: Slow rainbow (high delay, n1=1)")
|
||||
p.edit("rainbow3", {
|
||||
"p": "rainbow",
|
||||
"d": 500,
|
||||
"n1": 1,
|
||||
"a": True,
|
||||
})
|
||||
p.select("rainbow3")
|
||||
run_for(p, wdt, 3000)
|
||||
|
||||
# Test 4: Low brightness rainbow
|
||||
print("Test 4: Low brightness rainbow (n1=1)")
|
||||
p.edit("rainbow4", {
|
||||
"p": "rainbow",
|
||||
"b": 64,
|
||||
"d": 100,
|
||||
"n1": 1,
|
||||
"a": True,
|
||||
})
|
||||
p.select("rainbow4")
|
||||
run_for(p, wdt, 2000)
|
||||
|
||||
# Test 5: Single-step rainbow (auto=False)
|
||||
print("Test 5: Single-step rainbow (auto=False, n1=1)")
|
||||
p.edit("rainbow5", {
|
||||
"p": "rainbow",
|
||||
"b": 255,
|
||||
"d": 100,
|
||||
"n1": 1,
|
||||
"a": False,
|
||||
})
|
||||
p.step = 0
|
||||
for i in range(10):
|
||||
p.select("rainbow5")
|
||||
# One tick advances the generator one frame when auto=False
|
||||
p.tick()
|
||||
utime.sleep_ms(100)
|
||||
wdt.feed()
|
||||
|
||||
# Test 6: Verify step updates correctly
|
||||
print("Test 6: Verify step updates (auto=False, n1=1)")
|
||||
p.edit("rainbow6", {
|
||||
"p": "rainbow",
|
||||
"n1": 1,
|
||||
"a": False,
|
||||
})
|
||||
initial_step = p.step
|
||||
p.select("rainbow6")
|
||||
p.tick()
|
||||
final_step = p.step
|
||||
print(f"Step updated from {initial_step} to {final_step} (expected increment: 1)")
|
||||
|
||||
# Test 7: Fast step increment (n1=5)
|
||||
print("Test 7: Fast rainbow (n1=5, auto=True)")
|
||||
p.edit("rainbow7", {
|
||||
"p": "rainbow",
|
||||
"b": 255,
|
||||
"d": 100,
|
||||
"n1": 5,
|
||||
"a": True,
|
||||
})
|
||||
p.select("rainbow7")
|
||||
run_for(p, wdt, 2000)
|
||||
|
||||
# Test 8: Very fast step increment (n1=10)
|
||||
print("Test 8: Very fast rainbow (n1=10, auto=True)")
|
||||
p.edit("rainbow8", {
|
||||
"p": "rainbow",
|
||||
"n1": 10,
|
||||
"a": True,
|
||||
})
|
||||
p.select("rainbow8")
|
||||
run_for(p, wdt, 2000)
|
||||
|
||||
# Test 9: Verify n1 controls step increment (auto=False)
|
||||
print("Test 9: Verify n1 step increment (auto=False, n1=5)")
|
||||
p.edit("rainbow9", {
|
||||
"p": "rainbow",
|
||||
"n1": 5,
|
||||
"a": False,
|
||||
})
|
||||
p.step = 0
|
||||
initial_step = p.step
|
||||
p.select("rainbow9")
|
||||
p.tick()
|
||||
final_step = p.step
|
||||
expected_step = (initial_step + 5) % 256
|
||||
print(f"Step updated from {initial_step} to {final_step} (expected: {expected_step})")
|
||||
if final_step == expected_step:
|
||||
print("✓ n1 step increment working correctly")
|
||||
else:
|
||||
print(f"✗ Step increment mismatch! Expected {expected_step}, got {final_step}")
|
||||
|
||||
# Cleanup
|
||||
print("Test complete, turning off")
|
||||
p.edit("cleanup_off", {"p": "off"})
|
||||
p.select("cleanup_off")
|
||||
run_for(p, wdt, 100)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
|
||||
@@ -0,0 +1,81 @@
|
||||
#!/usr/bin/env python3
|
||||
import utime
|
||||
from machine import WDT
|
||||
from settings import Settings
|
||||
from presets import Presets
|
||||
|
||||
|
||||
def run_for(p, wdt, ms):
|
||||
"""Helper: run current pattern for given ms using tick()."""
|
||||
start = utime.ticks_ms()
|
||||
while utime.ticks_diff(utime.ticks_ms(), start) < ms:
|
||||
wdt.feed()
|
||||
p.tick()
|
||||
utime.sleep_ms(10)
|
||||
|
||||
|
||||
def main():
|
||||
s = Settings()
|
||||
pin = s.get("led_pin", 10)
|
||||
num = s.get("num_leds", 30)
|
||||
|
||||
p = Presets(pin=pin, num_leds=num)
|
||||
wdt = WDT(timeout=10000)
|
||||
|
||||
# Test 1: Simple two-color transition
|
||||
print("Test 1: Two-color transition (red <-> blue, delay=1000)")
|
||||
p.edit("transition1", {
|
||||
"p": "transition",
|
||||
"b": 255,
|
||||
"d": 1000, # transition duration
|
||||
"c": [(255, 0, 0), (0, 0, 255)],
|
||||
"a": True,
|
||||
})
|
||||
p.select("transition1")
|
||||
run_for(p, wdt, 6000)
|
||||
|
||||
# Test 2: Multi-color transition
|
||||
print("Test 2: Multi-color transition (red -> green -> blue -> white)")
|
||||
p.edit("transition2", {
|
||||
"p": "transition",
|
||||
"d": 800,
|
||||
"c": [(255, 0, 0), (0, 255, 0), (0, 0, 255), (255, 255, 255)],
|
||||
"a": True,
|
||||
})
|
||||
p.select("transition2")
|
||||
run_for(p, wdt, 8000)
|
||||
|
||||
# Test 3: One-shot transition (auto=False)
|
||||
print("Test 3: One-shot transition (auto=False)")
|
||||
p.edit("transition3", {
|
||||
"p": "transition",
|
||||
"d": 1000,
|
||||
"c": [(255, 0, 0), (0, 255, 0)],
|
||||
"a": False,
|
||||
})
|
||||
p.select("transition3")
|
||||
# Run long enough for a single transition step
|
||||
run_for(p, wdt, 2000)
|
||||
|
||||
# Test 4: Single-color behavior (should just stay on)
|
||||
print("Test 4: Single-color transition (should hold color)")
|
||||
p.edit("transition4", {
|
||||
"p": "transition",
|
||||
"c": [(0, 0, 255)],
|
||||
"d": 500,
|
||||
"a": True,
|
||||
})
|
||||
p.select("transition4")
|
||||
run_for(p, wdt, 3000)
|
||||
|
||||
# Cleanup
|
||||
print("Test complete, turning off")
|
||||
p.edit("cleanup_off", {"p": "off"})
|
||||
p.select("cleanup_off")
|
||||
run_for(p, wdt, 200)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
|
||||
|
||||
@@ -0,0 +1,99 @@
|
||||
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
|
||||
|
||||
# --- Rainbow pattern (outside ws2812): pregen double buffer, show via head offset ---
|
||||
|
||||
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).
|
||||
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)
|
||||
|
||||
|
||||
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, 278),
|
||||
(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=1.0) # 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
|
||||
|
||||
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)
|
||||
Loaded 100 of 120 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user