Compare commits

...
Author SHA1 Message Date
clydebarrowandClaude Opus 5.5 6ea74123f8 [lzss] Cap match length, share the hash chains, and check room below compression
- compress() splits matches longer than 65536 bytes, the longest that
  expand() reads.
- Every compression layer uses one hash chain buffer, as compress() needs
  it only while it runs.
- An explicit max_packet_size needs at least 16 bytes below the header,
  so a packet that does not compress can still be sent.
- WINDOW is documented as part of the format.
- Tests for a missing header, an oversized uncompressed packet and a send
  larger than max_packet_size.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 17:06:37 +11:00
clydebarrow 74ad3af091 Merge packet-interface-09 2026-11-16 17:03:25 +11:00
clydebarrowandClaude Opus 5.5 f12e235cdd [espnow][udp] Report ESP-NOW send room, and refuse addresses that name no one device
- The ESP-NOW link reports the free slots in the shared send queue, and
  addressing ports pass on their link's capacity, so fragmentation does
  not start a packet that the queue cannot take whole.
- An ESP-NOW peer_address must be a device's own address or broadcast,
  not a group or all-zero address.
- The broadcast address is added as a peer at boot, not at the first send.
- A UDP destination of 0.0.0.0 or 255.255.255.255 is not taken as one peer.
- A test for the once a minute warning of a dropped UDP sender.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 17:03:13 +11:00
clydebarrow 39ee9cdd62 Merge packet-interface-09 2026-11-16 15:41:35 +11:00
clydebarrow 0f6e49e9c1 Merge dev into packet-interface-09 2026-11-16 15:41:30 +11:00
c6f330458a [tcp] Add TCP packet interface link (#21119)
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: pre-commit-ci-lite[bot] <117423508+pre-commit-ci-lite[bot]@users.noreply.github.com>
2026-11-16 04:36:50 +00:00
clydebarrowandClaude Opus 5.5 f79e7f710a [lzss] Move the LZSS codec into its own component
The compression layer's encoder and decoder become a code-only lzss
component, so other code can use them. The packet_interface layer keeps
the header byte and loads lzss when a link uses compression. The wire
format is unchanged.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 15:33:58 +11:00
clydebarrow f861a6c9d2 Merge packet-interface-08 2026-11-16 15:17:48 +11:00
clydebarrow 80667abdb1 Merge packet-interface-09 2026-11-16 15:17:48 +11:00
clydebarrowandClaude Opus 5.5 577a91ccb5 [packet_interface] Find the layers a link provides from the link, also for a peer
interface_has_layer() looked up the provided layers by the type of the
configuration holding the layers, which for an addressing peer is the
peer, so a peer never had what its link provides.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 15:17:46 +11:00
clydebarrow 6b82439a60 Merge packet-interface-08 2026-11-16 15:06:12 +11:00
clydebarrow c7294104f8 Merge packet-interface-09 2026-11-16 15:06:12 +11:00
clydebarrowandClaude Opus 5.5 af097bc1cd [packet_interface] Warn when a fragmented packet is cut short
A link that refuses a fragment after others were sent leaves the peer
with part of a packet, which it drops. The fragmentation layer now logs
a warning then. The TCP link's capacity comment no longer claims that
this cannot happen: a socket that stalls part way through still cuts a
packet short.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 15:06:06 +11:00
clydebarrow 4f05346d8f Merge packet-interface-09 2026-11-16 14:28:08 +11:00
clydebarrow 8855c059af Merge packet-interface-08 2026-11-16 14:27:58 +11:00
clydebarrow f9f8fe4a4f Merge remote-tracking branch 'upstream/dev' into pi-08-local
# Conflicts:
#	esphome/components/packet_interface/__init__.py
2026-11-16 14:21:05 +11:00
Clyde StubbsandJ. Nick Koston dbb4ba769a [sx126x][sx127x] Packet interface links for SX126x and SX127x (#21110)
Co-authored-by: J. Nick Koston <nick@koston.org>
2026-11-16 14:19:19 +11:00
J. Nick Kostonandclydebarrow 0eb4a09935 [sx127x] Write multi-byte settings in one SPI burst (#22776)
Co-authored-by: clydebarrow <2366188+clydebarrow@users.noreply.github.com>
2026-11-16 14:16:55 +11:00
Clyde Stubbs ed9e5cff58 [sx127x] Set rx_floor in the unit test radio (#22779) 2026-11-15 20:31:44 -06:00
clydebarrowandClaude Opus 5.5 612d1d0888 Merge packet-interface-09
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 12:08:52 +11:00
clydebarrowandClaude Opus 5.5 d8b6f315dc Merge packet-interface-08
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 12:08:51 +11:00
clydebarrowandClaude Opus 5.5 76c5005fa0 Merge packet-interface-07
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 12:08:51 +11:00
clydebarrowandClaude Opus 5.5 551b7e2a40 [packet_interface] Take turns only with a reliability layer, and count a failed SX126x read as receiving
A session layer's peer does not answer each packet, so turn taking on a link without a
reliability layer only refused sends that nothing would send again. A failed interrupt
read in SX126xRadio::is_receiving() read as a free channel, so the link could send over
a reception it could not see; it now holds the send, and warns if the radio stays unreadable.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 12:08:49 +11:00
J. Nick Koston 7acd023079 [web_server_base] Bump ESPAsyncWebServer to 3.12.1 (#22682) 2026-11-16 13:43:15 +13:00
clydebarrowandClaude Opus 5.5 8235565016 [packet_interface] Size compression offsets by the window, cap the dictionary at it, and log the dictionary check
A match reaches back at most 512 bytes, so dictionary bytes before that were hashed on
every send and never used, and offsets had a bit more than the window needs. The check
value in dump_config shows at a glance when two devices have different dictionaries.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 11:05:40 +11:00
clydebarrowandClaude Opus 5.5 5c4aa43840 Merge packet-interface-09
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 11:04:26 +11:00
clydebarrowandClaude Opus 5.5 b1187431fe [espnow][udp] Warn now and then about oversized ESP-NOW packets, and log a failed UDP read
An ESP-NOW peer with a larger max_packet_size has its larger packets dropped, which was
logged only at verbose level, and the size check now runs after the peer filter, so other
senders' packets are not counted. A UDP read that fails other than for want of data is
logged: the raw lwIP socket consumes a packet whose source address it cannot convert.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 11:04:25 +11:00
clydebarrowandClaude Opus 5.5 0957ee51a5 Merge packet-interface-08
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 11:03:11 +11:00
clydebarrowandClaude Opus 5.5 054d9657dc [tcp] Pass the link's send capacity through encryption, and declare the connected sensor with SUB_BINARY_SENSOR
On TCP, encryption sits right below fragmentation, and reported an unlimited capacity
whatever the link had room for, so a fragmented packet could be started that the link
could not take in full.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 11:03:02 +11:00
clydebarrowandClaude Opus 5.5 4a71b15edb Merge packet-interface-07
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 11:01:36 +11:00
clydebarrowandClaude Opus 5.5 ca8137ca5f [packet_interface] Say in the radio busy warning whether the send went out
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 11:01:29 +11:00
clydebarrowandClaude Opus 5.5 a3974b7640 Merge packet-interface-09, with dev merged in
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 10:53:53 +11:00
clydebarrowandClaude Opus 5.5 30955abf51 Merge packet-interface-08, with dev merged in
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 10:53:53 +11:00
clydebarrowandClaude Opus 5.5 cc24f06a15 Merge packet-interface-07, with dev merged in
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 10:53:53 +11:00
clydebarrowandClaude Opus 5.5 3dc9595f08 Merge branch 'dev' into packet-interface-07
dev now has the SX127x async PR, so 07 adds only its own SX127x changes on top.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 10:53:52 +11:00
Clyde Stubbs 5623a5d511 [sx127x] Add async sends and failure recovery (#22733) 2026-11-15 23:52:31 +00:00
clydebarrowandClaude Opus 5.5 972a664c01 Merge packet-interface-09
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 10:47:27 +11:00
clydebarrowandClaude Opus 5.5 e4fd61538b Merge packet-interface-08
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 10:47:27 +11:00
clydebarrowandClaude Opus 5.5 73766dc622 Merge packet-interface-07
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 10:47:27 +11:00
clydebarrowandClaude Opus 5.5 366fe14053 Merge the SX127x async PR's shorter comments
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 10:47:26 +11:00
clydebarrowandClaude Opus 5.5 dbcb55ce92 [sx127x] Shorten the comments
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 10:46:46 +11:00
clydebarrowandClaude Opus 5.5 e6286b8fef Merge packet-interface-09, with dev merged in
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 10:40:11 +11:00
clydebarrowandClaude Opus 5.5 df54f8b7cb Merge packet-interface-08, with dev merged in
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 10:40:11 +11:00
clydebarrowandClaude Opus 5.5 d3e81fbb7c Merge packet-interface-07, with dev merged in
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 10:40:11 +11:00
clydebarrowandClaude Opus 5.5 034be60a11 Merge branch 'dev' into packet-interface-07
dev now packs the SX126x interrupt setup through set_dio_irq_params_(). It takes the
flagged interrupts and the DIO1 ones separately, so receive can flag a valid header
or sync word without signalling it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 10:40:10 +11:00
J. Nick Koston 4f8c2239dd [components] Use put_be16 and the other byte helpers in more drivers (#22771) 2026-11-15 23:32:08 +00:00
clydebarrowandClaude Opus 5.5 d23c08ba61 Merge packet-interface-09, now based on the SX127x async PR
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 10:29:13 +11:00
clydebarrowandClaude Opus 5.5 8a86bb98dc Merge packet-interface-08, now based on the SX127x async PR
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 10:29:13 +11:00
clydebarrowandClaude Opus 5.5 35929b3b2d Merge packet-interface-07, now based on the SX127x async PR
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 10:29:12 +11:00
clydebarrowandClaude Opus 5.5 856c2c1816 Merge the SX127x async PR into packet-interface-07, which brings in the SX126x refactor
07 is now based on clydebarrow/sx127x-async-transmit (esphome PR 22733), which is on dev
after the SX126x radio lifecycle refactor (PR 22197). 07's driver changes are ported:

- is_receiving() moves into SX126xRadio, and into the new SX127x radio state; both report
  a held packet and stay false while sending or asleep.
- SX126x flags a valid header or sync word for is_receiving() without signalling it on DIO1.
- SX127x FSK packets are at most 63 bytes, as the FIFO also holds the length byte.
- The radio link takes an Error value of 0 as success, as both radios' NONE values are renamed.
- 07's own FSK SNR change is dropped; both drivers now report NAN.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 10:27:55 +11:00
Mark Mayo 07bbad4061 [esp32] Import the SBOM writer only when generating the build (#22702) 2026-11-15 16:50:14 -06:00
Mark Mayo 1cd99ce6d6 [core] Import url2pathname only where a file URL is converted (#22703) 2026-11-15 16:50:04 -06:00
Mark Mayo 91db9d86d0 [debug] Import the nrf52 helper only when building for Zephyr (#22701) 2026-11-15 16:42:23 -06:00
clydebarrowandClaude Opus 5.5 7fa96b0ac4 [sx127x] Send and receive with the settings configure() last applied
configure() is refused while a send is on air, but the setters still changed the
modulation, payload length, packet mode, RX start and frequency that the end of
the send and later sends and packets used, before the chip had them.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 07:53:18 +11:00
clydebarrowandClaude Opus 5.5 3df2e55176 [sx127x] Arm the configuration retry before setting the warning
The warning's log message can run user code that calls configure(). Armed
afterwards, the retry stayed set on a radio that had already recovered, and reset
it a second later.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 07:46:06 +11:00
Tanguy Pruvot 2f900f23d7 [cst3240] Add the Hynitron CST3240 touchscreen (#22601) 2026-11-15 12:20:54 -06:00
373224c141 [npm1300] Add the Nordic nPM1300 PMIC component (#22661)
Co-authored-by: Claude <noreply@anthropic.com>
Co-authored-by: J. Nick Koston <nick@home-assistant.io>
2026-11-15 12:52:15 +01:00
Hajo Noerenberg 1dff22f578 [cc1101] Add long packet support, plus a lambda packet_length for unknown-length packets (#17578) 2026-11-14 21:43:21 -06:00
clydebarrowandClaude Opus 5.5 7f200e14ed [sx127x] Go through standby when a send ends early
An SX1276 stays in TX when asked for RX while a packet is still going out, so a
cancelled or timed out send set a warning until the radio was configured again.
The test chip now behaves the same way.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-15 13:41:54 +11:00
clydebarrowandClaude Opus 5.5 d3d792d356 [sx127x] Define the interrupt handler in the header, as SX126x does
Out of line, it shares the RP2040 .time_critical section with inline functions such
as get_loop_component_start_time(), which the compiler rejects as a section type conflict.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-15 13:41:53 +11:00
clydebarrowandClaude Opus 5.5 0ef6c41e02 [sx127x] Add asynchronous sending, and recover from failed mode changes
Matches the SX126x changes: start_transmit_async(), cancel_transmit_async() and
is_transmitting(), with SX127xTransmitListener. A received packet still waiting
when a send starts is kept, the send returns BUSY, and the next loop delivers
the packet. Mode changes are ignored while a send is on air.

A mode change that does not take now sets a warning and the radio is configured
again every second, instead of marking the component failed. The error values
are renamed to SX127X_ERROR_*, and FSK packets report NAN for SNR.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-15 13:34:04 +11:00
Vinicius FortunaandClyde Stubbs c2eb540b37 [sx126x] Refactor/sx126x radio lifecycle (#22197)
Co-authored-by: Clyde Stubbs <2366188+clydebarrow@users.noreply.github.com>
2026-11-15 13:17:23 +11:00
J. Nick Kostonandclydebarrow fad21e3f14 [cstxxx] Share the Hynitron 16-bit register touchscreen code (#22718)
Co-authored-by: clydebarrow <2366188+clydebarrow@users.noreply.github.com>
2026-11-15 02:11:09 +00:00
Rodrigoah 904f0df920 [whirlpool] Add the Hitachi HCRA31NEWH model (#22704) 2026-11-14 14:23:51 -06:00
Chris 7128d22f07 [ethernet] Notify IP state listeners from the main loop (#22657) 2026-11-14 13:22:11 -06:00
Miguel Angel Nubla 825e2c3dd0 [wifi] Leave the AP before restarting on ESP32 (#22715) 2026-11-14 18:05:42 +00:00
clydebarrow d35e49cfa6 Merge branch 'clydebarrow/packet-interface-09' into clydebarrow/packet-interface-10 2026-11-14 12:43:39 +11:00
clydebarrow 65a6c41c6b Merge branch 'clydebarrow/packet-interface-08' into clydebarrow/packet-interface-09 2026-11-14 12:43:39 +11:00
clydebarrow 4bbd53bf7a Merge branch 'clydebarrow/packet-interface-07' into clydebarrow/packet-interface-08 2026-11-14 12:43:39 +11:00
clydebarrowandClaude Opus 5.5 d66faa3ba7 [packet_interface] Take turns on a radio link whose peer replies
After a send, the next frame of a burst went out at once, on top of the peer's
acknowledgement or reply, as the radio only notices a packet once its header
has arrived. Both packets were lost, and the reliability layer threw away the
rest of the burst. Now, on a link with a layer that needs replies, a send in a
later loop pass waits until the peer has had time to start a reply and its
header to be received, unless a packet arrives first. Sends in the same loop
pass, such as the fragments of one packet, are not held apart, and one-way
links are unchanged.

On a SX1262 and SX1276 pair at SF10, 45 minutes of counter updates both ways
went from 86 to 90 percent delivered, with a link reset every 9 minutes, to
all 540 delivered each way with no resends.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-14 09:56:50 +11:00
clydebarrow 228536a0fe Merge branch 'clydebarrow/packet-interface-09' into clydebarrow/packet-interface-10 2026-11-14 08:10:05 +11:00
clydebarrow 10f45748df Merge branch 'clydebarrow/packet-interface-08' into clydebarrow/packet-interface-09 2026-11-14 08:10:05 +11:00
clydebarrow ccaebe0dce Merge branch 'clydebarrow/packet-interface-07' into clydebarrow/packet-interface-08 2026-11-14 08:10:05 +11:00
clydebarrowandClaude Opus 5.5 33d0b19643 [packet_interface] Resend only the oldest frame after a reliability timeout
Resending every unacknowledged frame on each timeout let two radio peers whose
acknowledgements were lost keep sending long bursts that collided again, until
one side reset the link. Now only the oldest frame is resent; the peer's answer
acknowledges whatever it already has, and the remaining frames follow.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-14 08:09:58 +11:00
clydebarrow c41f5e2378 Merge branch 'clydebarrow/packet-interface-09' into clydebarrow/packet-interface-10 2026-11-13 10:53:33 +11:00
clydebarrow 31de10509b Merge branch 'clydebarrow/packet-interface-08' into clydebarrow/packet-interface-09 2026-11-13 10:53:33 +11:00
clydebarrow d39519a424 Merge branch 'clydebarrow/packet-interface-07' into clydebarrow/packet-interface-08 2026-11-13 10:53:32 +11:00
clydebarrowandClaude Opus 5.5 1e78fb08fa [sx126x][sx127x] Name the radio link's time source without the protected suffix, as it is virtual
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-13 10:53:32 +11:00
clydebarrow 6570fe4f66 Merge branch 'clydebarrow/packet-interface-09' into clydebarrow/packet-interface-10 2026-11-13 09:03:27 +11:00
clydebarrow 88ddf2d0bb Merge branch 'clydebarrow/packet-interface-08' into clydebarrow/packet-interface-09 2026-11-13 09:03:27 +11:00
clydebarrow 51c1b7a9ba Merge branch 'clydebarrow/packet-interface-07' into clydebarrow/packet-interface-08 2026-11-13 09:03:27 +11:00
clydebarrowandClaude Opus 5.5 6c6e680828 [sx126x][sx127x] Time busy periods from the current time, and size radio timings for the largest packet on the channel
- Listen before talk reads the current time, not the loop's start: earlier sends in the same loop pass may have
  waited seconds for the radio, and a reception first seen then could be sent over at once.
- A send made over a busy flag that seemed stuck ends the busy period, so a reception that starts before loop()
  runs is waited for again.
- An accepted packet ends a run of dropped oversized ones.
- The reliability timeout and the listen before talk limit allow for the largest packet any device on the channel
  can send, not only this link's own; a refused resend still counts as a retry.
- The suggested max_packet_size is never below 16, the smallest allowed.
- A warning is logged when one send can become several radio packets that together hold up other components for
  more than 4 s, as the drivers wait for each packet to be sent.
- SX126x FSK packets report the SNR as NAN, as the radio does not measure it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-13 09:03:25 +11:00
clydebarrow ca184567ec Merge branch 'clydebarrow/packet-interface-09' into clydebarrow/packet-interface-10 2026-11-12 21:41:05 +11:00
clydebarrow 22d4f1564f Merge branch 'clydebarrow/packet-interface-08' into clydebarrow/packet-interface-09 2026-11-12 21:41:05 +11:00
clydebarrowandClaude Opus 5.5 2ddc1109c2 [tcp] Read at most 8 frames per loop pass, and report send capacity while frames wait for the socket
- A peer sending without a pause no longer holds the main loop in the receive loop; a frame being read carries over.
- While frames wait for the socket, the link reports how many more full frames fit, so a fragmentation layer above
  does not start a packet that would be cut short.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-12 21:41:05 +11:00
clydebarrow 70c75fb627 Merge branch 'clydebarrow/packet-interface-09' into clydebarrow/packet-interface-10 2026-11-12 21:35:06 +11:00
clydebarrow d26e3dc68c Merge branch 'clydebarrow/packet-interface-08' into clydebarrow/packet-interface-09 2026-11-12 21:35:05 +11:00
clydebarrow 5a1e5eb899 Merge branch 'clydebarrow/packet-interface-07' into clydebarrow/packet-interface-08
# Conflicts:
#	esphome/components/packet_interface/__init__.py
2026-11-12 21:35:03 +11:00
clydebarrowandClaude Opus 5.5 22666de8aa [packet_interface] Check ack_delay against the reliability timeout that the link will use
Without a timeout, ack_delay was checked against the 200 ms default even on a radio link, which works out a longer
timeout that allows for the delay.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-12 21:34:39 +11:00
clydebarrow 31db0c6f01 Merge branch 'clydebarrow/packet-interface-09' into clydebarrow/packet-interface-10 2026-11-12 21:01:50 +11:00
clydebarrow e6ddb7c669 Merge branch 'clydebarrow/packet-interface-08' into clydebarrow/packet-interface-09 2026-11-12 21:01:50 +11:00
clydebarrow e1ff5028b4 Merge branch 'clydebarrow/packet-interface-07' into clydebarrow/packet-interface-08 2026-11-12 21:01:50 +11:00
clydebarrowandClaude Opus 5.5 add9caa66d [sx126x][sx127x] Work out reliability timeouts and size limits from the radio settings, and fix SX127x TX_DONE and FSK handling
- A reliability layer on a radio link without a timeout gets one long enough for the peer's largest packet and an
  acknowledgement, from the radio's settings; a timeout set shorter is rejected.
- A max_packet_size whose packets take longer to send than the drivers wait for (4 s) is rejected, naming the largest
  that fits.
- Listen before talk holds sends back for as long as the largest packet the radio can receive takes, not the link's
  own limit.
- A received packet larger than the link's max_packet_size is dropped.
- SX127x: in LoRa mode DIO0 also signals TX_DONE when the radio sleeps after sending, which was taken for a received
  packet, both by is_receiving() and loop(); FSK and OOK packets report RSSI and SNR as NAN, as the radio does not
  measure them; variable length FSK and OOK packets hold at most 63 bytes, as the FIFO also holds the length byte.
- The radio's configuration is found with fv.get_declaring_config().

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-12 21:01:47 +11:00
clydebarrow f1a4b3f7ec Merge branch 'clydebarrow/packet-interface-09' into clydebarrow/packet-interface-10 2026-11-12 20:43:52 +11:00
clydebarrow a96e323e4c Merge branch 'clydebarrow/packet-interface-08' into clydebarrow/packet-interface-09 2026-11-12 20:43:52 +11:00
clydebarrow 1a2ec29caa Merge branch 'clydebarrow/packet-interface-07' into clydebarrow/packet-interface-08 2026-11-12 20:43:52 +11:00
clydebarrow 5acd25e70c Merge branch 'clydebarrow/packet-interface-09' into clydebarrow/packet-interface-10 2026-11-12 20:42:45 +11:00
clydebarrow 16ee16f391 Merge branch 'clydebarrow/packet-interface-08' into clydebarrow/packet-interface-09 2026-11-12 20:42:45 +11:00
clydebarrow 3e62f017af Merge branch 'clydebarrow/packet-interface-07' into clydebarrow/packet-interface-08 2026-11-12 20:42:44 +11:00
clydebarrow 2d67382a17 Merge remote-tracking branch 'upstream/dev' into clydebarrow/packet-interface-07 2026-11-12 20:42:44 +11:00
clydebarrowandClaude Opus 5.5 e71c4ed0d9 [sx126x][sx127x] Put the radio link's flag in the spare byte of the packet interface base
Declared first, it fills the byte the base class leaves at its end, which takes each radio link from 56 to 52 bytes
on ESP32.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-12 20:14:32 +11:00
clydebarrowandClaude Opus 5.5 27ee1540e6 [sx126x][sx127x] Warn about sending over a busy radio only once the radio has the packet
A log line can run an automation that sends again, which would overwrite the buffer of a layer above before the
radio had read it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-12 20:14:32 +11:00
clydebarrowandClaude Opus 5.5 2671bad22b [sx126x][sx127x] Stop reading a radio that fails while sends are held back
Also drop a leftover preamble_detect key from a test case.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-12 20:14:32 +11:00
clydebarrowandClaude Opus 5.5 a3bf895895 [sx127x] Count only the sync word match as a packet arriving without LoRa
The preamble flag stays set when no sync word follows, so a packet from
another network held every send back until max_busy ran out. A link
without LoRa now needs a sync_value.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-12 20:14:32 +11:00
clydebarrowandClaude Opus 5.5 f400132b16 [sx126x] Require a sync word for a link with FSK
Without one the radio cannot tell that a packet is arriving, so listen
before talk does nothing.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-12 20:14:32 +11:00
clydebarrowandClaude Opus 5.5 d92883f0c3 [sx126x][sx127x] Fixes from code review
- Without LoRa, require the SX127x radio to have a sync word or preamble
  detection, as listen before talk cannot see a packet arriving otherwise
- Warn once when a send finds the radio failed

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-12 20:14:32 +11:00
clydebarrowandClaude Opus 5.5 61d8a52e2b [sx126x][sx127x] Fixes from code review
- Warn when a send goes ahead over a busy period at its limit, as that
  means a stuck busy indication or a jammed channel
- Log an empty packet at verbose level, and say why it counts as sent
- Name the radio id if code generation cannot find its configuration

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-12 20:14:32 +11:00
clydebarrowandClaude Opus 5.5 38ef34e006 [sx126x][sx127x] Say which callers send a refused packet again
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-12 20:14:32 +11:00
clydebarrowandClaude Opus 5.5 a6ee2288be [sx126x][sx127x] Require rx_start for layers that need replies
- Reject a radio with rx_start false when the link or a peer has a layer
  that needs packets back from the peer, as the radio sleeps after sending
- Log a send over a long busy period at debug level, so a lost reception
  can be traced

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-12 20:14:32 +11:00
clydebarrowandClaude Opus 5.5 5647a22c9a [sx126x][sx127x] Share the radio link code, and fixes from code review
- Make both links one RadioLink template in packet_interface, with shared
  code generation in radio_link.py, so a fix applies to both radios
- While sending is held back, watch the radio from loop() and end the
  busy period once it is free, so a later reception starts a new period
  instead of being sent over
- Reject an SX127x link without LoRa unless the radio is in packet mode

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-12 20:14:32 +11:00
clydebarrowandClaude Code 4f008b76e4 [sx126x][sx127x] Take the packet size at construction
The radio links have no buffer of their own, so code generation passes
the configured max_packet_size to the constructor.

Co-Authored-By: Claude Code <noreply@anthropic.com>
2026-11-12 20:14:32 +11:00
clydebarrowandClaude Opus 5.5 3a4ae0342d [sx126x][sx127x] Fixes from code review
- Hold a send back for at most the airtime of the largest packet, worked
  out from the radio settings and at least 2 s, instead of a fixed 2 s
  that a LoRa packet at a high spreading factor outlasts
- End a busy period when a send finds the radio free, so a busy flag that
  never clears is released however rarely sends are tried
- Detect an FSK reception on the SX127x from its preamble and sync word
  flags
- Test the radio links' final validation

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-12 20:14:32 +11:00
clydebarrowandClaude Opus 5.5 a2c1fdf9a1 [sx126x][sx127x] Add packet interface links for SX126x and SX127x radios
Each packet is one radio packet, with the RSSI and SNR of received
packets in the metadata. A radio cannot hear while it sends, so a link
refuses to send while its radio is receiving a packet, for up to two
seconds, and the layers above send again shortly.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-12 20:14:32 +11:00
clydebarrow 5d553ee518 Merge branch 'clydebarrow/packet-interface-09' into clydebarrow/packet-interface-10 2026-11-12 14:18:16 +11:00
clydebarrow fbd5c8097a Merge branch 'clydebarrow/packet-interface-08' into clydebarrow/packet-interface-09 2026-11-12 14:18:16 +11:00
clydebarrow eda4be7972 Merge branch 'clydebarrow/packet-interface-07' into clydebarrow/packet-interface-08 2026-11-12 14:18:16 +11:00
clydebarrow 87d0e2370d Merge branch 'clydebarrow/packet-interface-06' into clydebarrow/packet-interface-07 2026-11-12 14:18:16 +11:00
clydebarrowandClaude Opus 5.5 596a0e6a4a [packet_interface] Warn about a refused nested send once the outer send is done, not from a deferred call
A deferred call could outlive the layer in the unit tests, which run many components in one program.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-12 14:14:10 +11:00
clydebarrow de70e899b8 Merge branch 'clydebarrow/packet-interface-09' into clydebarrow/packet-interface-10 2026-11-12 13:15:38 +11:00
clydebarrow 8d89e2bc1d Merge branch 'clydebarrow/packet-interface-08' into clydebarrow/packet-interface-09 2026-11-12 13:15:38 +11:00
clydebarrow d1ad87f4e6 Merge branch 'clydebarrow/packet-interface-07' into clydebarrow/packet-interface-08 2026-11-12 13:15:37 +11:00
clydebarrow b37748c2d3 Merge branch 'clydebarrow/packet-interface-06' into clydebarrow/packet-interface-07 2026-11-12 13:15:37 +11:00
clydebarrowandClaude Opus 5.5 dd876c98fc [packet_interface] Warn about refused nested sends, keep destination warnings per port, and check sizes when validating
- A send refused because another is in progress is now logged once per layer, from the next loop, as the logger
  drops lines logged from an automation that a log line runs.
- Each addressing port warns about its own refused destinations, naming the port, so a refusal on one port does not
  hide a later one on another.
- The session layer reports its one byte header and its keep-alive size to config validation, so the sizes there
  match the C++ layers.
- A layer that the layers below leave no room for is rejected during validation, not when the device starts.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-12 13:15:30 +11:00
clydebarrowandClaude Opus 5.5 235e3a078d [packet_interface] Give the compression layer generated buffers
The packet buffers and the match chains come from cg.static_buffer, in PSRAM when it is enabled, instead of being
allocated in setup().

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-12 12:43:28 +11:00
clydebarrow d61598e323 Merge branch 'clydebarrow/packet-interface-09' into clydebarrow/packet-interface-10
# Conflicts:
#	tests/unit_tests/test_packet_interface.py
2026-11-12 12:39:43 +11:00
clydebarrow 5c800279f7 Merge branch 'clydebarrow/packet-interface-08' into clydebarrow/packet-interface-09 2026-11-12 12:39:30 +11:00
clydebarrow 1fa3dcb0f3 Merge branch 'clydebarrow/packet-interface-07' into clydebarrow/packet-interface-08
# Conflicts:
#	esphome/components/entity_transport/__init__.py
2026-11-12 12:39:28 +11:00
clydebarrow bd04e4bf2e Merge branch 'clydebarrow/packet-interface-06' into clydebarrow/packet-interface-07 2026-11-12 12:39:01 +11:00
clydebarrowandClaude Opus 5.5 90f6d49b55 [packet_interface] Guard the UART link against nested sends, and give fragmentation and entity_transport generated buffers
- The UART link writes a frame in pieces, so a send made from a UART debug automation, possibly through another
  addressing peer, is now refused instead of landing inside the frame.
- Addressing peers whose encryption keeps state for one peer, such as the rolling code, must use different keys; a
  packet relabelled with another peer's source address would otherwise pass that peer's checks.
- An addressing port named with port_id is now found when an application refers to it.
- The reliability layer refuses a packet with a chosen destination, which it could not keep for a resend.
- The fragmentation layer and entity_transport take buffers from cg.static_buffer, in PSRAM when it is enabled;
  entity_transport's size comes from the configured layers, and setup() fails if the C++ layers need more.
- destination is validated with cv validators that schema tooling can describe, and the address header uses
  put_le16().

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-12 12:38:52 +11:00
clydebarrow f2b9d083ef Merge branch 'clydebarrow/packet-interface-09' into clydebarrow/packet-interface-10 2026-11-12 09:00:24 +11:00
clydebarrow 1c725e37e2 Merge branch 'clydebarrow/packet-interface-08' into clydebarrow/packet-interface-09 2026-11-12 09:00:23 +11:00
clydebarrow 8f8243c164 Merge branch 'clydebarrow/packet-interface-07' into clydebarrow/packet-interface-08 2026-11-12 09:00:23 +11:00
clydebarrow 702f44e4dd Merge branch 'clydebarrow/packet-interface-06' into clydebarrow/packet-interface-07 2026-11-12 09:00:22 +11:00
clydebarrow bf503dc448 Merge remote-tracking branch 'upstream/dev' into clydebarrow/packet-interface-06
# Conflicts:
#	esphome/components/entity_transport/__init__.py
#	esphome/components/packet_interface/__init__.py
#	tests/unit_tests/test_entity_transport.py
2026-11-12 09:00:10 +11:00
clydebarrow 86e50adfb4 Merge branch 'clydebarrow/packet-interface-09' into clydebarrow/packet-interface-10 2026-11-12 08:25:49 +11:00
clydebarrow 69e70b7da1 Merge branch 'clydebarrow/packet-interface-08' into clydebarrow/packet-interface-09 2026-11-12 08:25:48 +11:00
clydebarrow 26a5003459 Merge branch 'clydebarrow/packet-interface-07' into clydebarrow/packet-interface-08 2026-11-12 08:25:48 +11:00
clydebarrow a48da110ca Merge branch 'clydebarrow/packet-interface-06' into clydebarrow/packet-interface-07 2026-11-12 08:25:48 +11:00
clydebarrowandClaude Opus 5.5 bd26849dc3 [packet_interface] Name the test's queue length constant in upper case, as clang-tidy requires
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-12 08:25:47 +11:00
clydebarrowandClaude Opus 5.5 ba0d1aa874 [packet_interface] Put the compression layer's check byte in the spare byte of the packet interface base
Declared first, it fills the byte the base class leaves at its end, which takes the layer from 68 to 64 bytes on
ESP32.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-12 08:06:31 +11:00
clydebarrowandClaude Opus 5.5 635f4d850d [espnow][udp] Order the ESP-NOW and UDP link members to avoid padding
The six byte peer address now sits with the two flags, and the UDP link's flag fills the spare byte at the end of
the packet interface base, which takes the ESP-NOW link from 76 to 72 bytes and the UDP link from 56 to 52 on
ESP32.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-12 08:06:03 +11:00
clydebarrow 485f8997f9 Merge branch 'clydebarrow/packet-interface-09' into clydebarrow/packet-interface-10 2026-11-12 08:06:03 +11:00
clydebarrow dc428031aa Merge branch 'clydebarrow/packet-interface-08' into clydebarrow/packet-interface-09 2026-11-12 08:05:25 +11:00
clydebarrowandClaude Opus 5.5 03958a6c1b [tcp] Keep the server flag with the other small members of the TCP link
It sat alone after the listener, padded to a word, which took the link from 76 to 80 bytes on ESP32.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-12 08:05:24 +11:00
clydebarrow fed10a9dc9 Merge branch 'clydebarrow/packet-interface-07' into clydebarrow/packet-interface-08 2026-11-12 08:04:57 +11:00
clydebarrowandClaude Opus 5.5 5925f80e4d [sx126x][sx127x] Put the radio link's flag in the spare byte of the packet interface base
Declared first, it fills the byte the base class leaves at its end, which takes each radio link from 56 to 52 bytes
on ESP32.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-12 08:04:56 +11:00
clydebarrow d1b40be6d4 Merge branch 'clydebarrow/packet-interface-06' into clydebarrow/packet-interface-07 2026-11-12 08:04:36 +11:00
clydebarrowandClaude Opus 5.5 86ca922934 [packet_interface] Keep the fragmentation layer's members free of padding
The length of the packet being joined fits in 16 bits, as configuration limits it to 16384 bytes, and the two flags
share a byte, which takes the layer from 56 to 52 bytes on ESP32.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-12 08:04:35 +11:00
clydebarrow ab2e3c81ce Merge branch 'clydebarrow/packet-interface-09' into clydebarrow/packet-interface-10
# Conflicts:
#	esphome/components/packet_interface/layers/__init__.py
2026-11-12 07:58:14 +11:00
clydebarrow b199e4eeb5 Merge branch 'clydebarrow/packet-interface-08' into clydebarrow/packet-interface-09 2026-11-12 07:56:51 +11:00
clydebarrow 4beea465c7 Merge branch 'clydebarrow/packet-interface-07' into clydebarrow/packet-interface-08 2026-11-12 07:56:36 +11:00
clydebarrow 3068b6adb7 Merge branch 'clydebarrow/packet-interface-06' into clydebarrow/packet-interface-07 2026-11-12 07:56:20 +11:00
clydebarrow 32ac29fb21 Merge branch 'clydebarrow/packet-interface-05' into clydebarrow/packet-interface-06
# Conflicts:
#	esphome/components/packet_interface/__init__.py
#	esphome/components/packet_interface/layers/__init__.py
#	esphome/components/packet_interface/layers/hdlc_reliability.py
#	esphome/components/packet_interface/layers/xxtea_encryption.py
2026-11-12 07:56:02 +11:00
clydebarrow 98b41c4dc8 Merge remote-tracking branch 'upstream/dev' into clydebarrow/packet-interface-05 2026-11-12 07:48:17 +11:00
clydebarrow 65f8d3767f Merge branch 'clydebarrow/packet-interface-09' into clydebarrow/packet-interface-10 2026-11-12 07:42:57 +11:00
clydebarrow edf7d6e07e Merge branch 'clydebarrow/packet-interface-08' into clydebarrow/packet-interface-09 2026-11-12 07:42:56 +11:00
clydebarrow 64a9afd8b5 Merge branch 'clydebarrow/packet-interface-07' into clydebarrow/packet-interface-08 2026-11-12 07:42:56 +11:00
clydebarrow 0ee08e9a79 Merge branch 'clydebarrow/packet-interface-06' into clydebarrow/packet-interface-07 2026-11-12 07:42:56 +11:00
clydebarrow b92b0d01c0 Merge branch 'clydebarrow/packet-interface-05' into clydebarrow/packet-interface-06 2026-11-12 07:42:56 +11:00
clydebarrowandClaude Opus 5.5 5bcafec97b [entity_transport] Order the members to avoid padding, and keep the flags in one-bit fields
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-12 07:42:55 +11:00
clydebarrow fb98efa42e Merge branch 'clydebarrow/packet-interface-09' into clydebarrow/packet-interface-10 2026-11-10 16:41:33 +11:00
clydebarrowandClaude Opus 5.5 7cc4eaa09b [espnow] Warn now and then when a unicast peer does not acknowledge packets
Without a reliability layer above, a peer that is off, out of range or has another address went unreported, as the
delivery result was logged only at verbose level by the espnow component.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 16:41:33 +11:00
clydebarrow cbf19d2d7e Merge branch 'clydebarrow/packet-interface-08' into clydebarrow/packet-interface-09 2026-11-10 16:39:20 +11:00
clydebarrowandClaude Opus 5.5 eeb6b2a6e5 [tcp] Report a packet as not sent when the write that sends it drops the connection
The failed write closes the link and discards the queued frame, so returning true lost the packet without the
sender knowing.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 16:39:13 +11:00
clydebarrow fe15eec956 Merge branch 'clydebarrow/packet-interface-06' into clydebarrow/packet-interface-07 2026-11-10 16:38:21 +11:00
clydebarrow d94705d359 Merge branch 'clydebarrow/packet-interface-07' into clydebarrow/packet-interface-08 2026-11-10 16:38:21 +11:00
clydebarrowandClaude Opus 5.5 e4b8fa7f89 [packet_interface] Take a chosen destination only through the broadcast port, and never this device's own address
A port to one peer may have layers that keep state for that peer, such as reliability, a session or a rolling code,
which a packet sent elsewhere would break. A packet to this device's own address is dropped by every receiver, as
metadata copied from a received packet would give. Both are now refused with a warning.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 16:38:14 +11:00
clydebarrow 5710093517 Merge branch 'clydebarrow/packet-interface-09' into clydebarrow/packet-interface-10 2026-11-10 16:30:37 +11:00
clydebarrow 5c24d1c66f Merge branch 'clydebarrow/packet-interface-08' into clydebarrow/packet-interface-09 2026-11-10 16:30:37 +11:00
clydebarrow 384982896e Merge branch 'clydebarrow/packet-interface-06' into clydebarrow/packet-interface-07 2026-11-10 16:30:37 +11:00
clydebarrow 0edc6fffec Merge branch 'clydebarrow/packet-interface-07' into clydebarrow/packet-interface-08 2026-11-10 16:30:37 +11:00
clydebarrowandClaude Opus 5.5 29da0e8e36 [entity_transport] Rate limit each kind of dropped packet warning separately, and log each new provider's dictionary
One limit covered every kind of drop, so a steady stream of one kind, such as a neighbour on other firmware, could
take nearly every warning and leave a rarer kind seldom reported. The name of the device that sent each new
dictionary is now logged at debug level, so a provider that matches no device heard is easy to spot.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 16:30:36 +11:00
clydebarrow 05a1d9a3cc Merge branch 'clydebarrow/packet-interface-05' into clydebarrow/packet-interface-06 2026-11-10 16:30:36 +11:00
clydebarrowandClaude Opus 5.5 07b522e23f [packet_interface] Use the shared guard against nested sends in the compression layer
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 15:56:17 +11:00
clydebarrow 40f926cfaf Merge branch 'clydebarrow/packet-interface-08' into clydebarrow/packet-interface-09 2026-11-10 15:55:51 +11:00
clydebarrow 0e8579b368 Merge branch 'clydebarrow/packet-interface-09' into clydebarrow/packet-interface-10 2026-11-10 15:55:51 +11:00
clydebarrowandClaude Opus 5.5 d48756a858 [sx126x][sx127x] Warn about sending over a busy radio only once the radio has the packet
A log line can run an automation that sends again, which would overwrite the buffer of a layer above before the
radio had read it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 15:55:50 +11:00
clydebarrow 6852a909bf Merge branch 'clydebarrow/packet-interface-07' into clydebarrow/packet-interface-08 2026-11-10 15:55:50 +11:00
clydebarrow f49008ad2c Merge branch 'clydebarrow/packet-interface-06' into clydebarrow/packet-interface-07 2026-11-10 15:55:02 +11:00
clydebarrowandClaude Opus 5.5 a608cacc33 [packet_interface] Refuse a send through the encryption or fragmentation layer while one is in progress
A log line further down, such as the radio's warning that it is sending although busy, can run an automation that
sends again before the layer below has read the layer's buffer. The nested send overwrote that buffer, so the outer
packet went out with the nested one's bytes. PacketInterface gets a helper that refuses such a send, which callers
already handle as a send that was not accepted.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 15:54:52 +11:00
clydebarrow 01478f7519 Merge branch 'clydebarrow/packet-interface-08' into clydebarrow/packet-interface-09 2026-11-10 15:48:56 +11:00
clydebarrow 8b28a1b789 Merge branch 'clydebarrow/packet-interface-09' into clydebarrow/packet-interface-10 2026-11-10 15:48:56 +11:00
clydebarrow dcc296afc9 Merge branch 'clydebarrow/packet-interface-07' into clydebarrow/packet-interface-08
# Conflicts:
#	esphome/components/entity_transport/__init__.py
#	tests/unit_tests/test_entity_transport.py
2026-11-10 15:48:54 +11:00
clydebarrow e190c1cea6 Merge branch 'clydebarrow/packet-interface-06' into clydebarrow/packet-interface-07 2026-11-10 15:48:19 +11:00
clydebarrow ce090adf57 Merge branch 'clydebarrow/packet-interface-05' into clydebarrow/packet-interface-06
# Conflicts:
#	esphome/components/entity_transport/__init__.py
#	esphome/components/packet_interface/__init__.py
#	tests/unit_tests/test_entity_transport.py
2026-11-10 15:48:17 +11:00
clydebarrowandClaude Opus 5.5 7a4e9a8e08 [entity_transport] Take the id of a packet interface layer as standing for its link
Applications send through top(), so the id of a layer still uses every layer of its link. Final validation now
finds the link from a layer's id and checks its layers, where the previous commit rejected the id with a wrong
reason.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 15:47:25 +11:00
clydebarrowandClaude Opus 5.5 5e3451c4a6 [packet_interface] Refuse a send through the compression layer while one is in progress, and limit the dictionary in bytes
A log line can run an automation that sends again before the layer below is done with the compressed packet,
which the nested send would overwrite. The dictionary limit now counts the UTF-8 bytes that are stored.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 15:14:38 +11:00
clydebarrow c5aabcb910 Merge branch 'clydebarrow/packet-interface-08' into clydebarrow/packet-interface-09 2026-11-10 15:13:33 +11:00
clydebarrow f58c351f6a Merge branch 'clydebarrow/packet-interface-09' into clydebarrow/packet-interface-10 2026-11-10 15:13:33 +11:00
clydebarrow 4032f1aa21 Merge branch 'clydebarrow/packet-interface-07' into clydebarrow/packet-interface-08
# Conflicts:
#	esphome/components/entity_transport/__init__.py
#	tests/unit_tests/test_entity_transport.py
2026-11-10 15:13:31 +11:00
clydebarrow 2df3d6c901 Merge branch 'clydebarrow/packet-interface-06' into clydebarrow/packet-interface-07 2026-11-10 15:13:01 +11:00
clydebarrow 98f94729d0 Merge branch 'clydebarrow/packet-interface-05' into clydebarrow/packet-interface-06
# Conflicts:
#	esphome/components/packet_interface/__init__.py
#	tests/unit_tests/test_entity_transport.py
2026-11-10 15:12:53 +11:00
clydebarrowandClaude Opus 5.5 dbfa5d212d [entity_transport] Reject the id of a packet interface layer, and log packets dropped for carrying our own dictionary id
An application given the id of a layer would leave out the layers above it, and final validation found no
interface for it, so its checks were skipped without an error. A packet with our own dictionary id that is not a
request is now logged at verbose level, as another device with the same name and entities sends such packets.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 15:12:05 +11:00
clydebarrowandClaude Opus 5.5 9c76945df5 [packet_interface] Use setup_check in the compression layer, and set its buffers only once all are allocated
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-09 21:25:12 +11:00
clydebarrowandClaude Opus 5.5 71c98d4575 [packet_interface] Add an LZSS compression layer with a preset dictionary
Each packet is compressed on its own, with matches that may copy from a dictionary held by both ends, so short JSON packets shrink. A packet that does not get smaller is sent as it is, after a one byte header that also checks both ends have the same dictionary.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-09 21:21:08 +11:00
clydebarrowandClaude Opus 5.5 447e2a0fd5 [espnow] Use cg.static_buffer for the packet interface copy buffer
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-09 15:02:14 +11:00
clydebarrowandClaude Opus 5.5 a9ffe139ca Merge branch 'clydebarrow/packet-interface-08' into clydebarrow/packet-interface-09
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-09 15:02:02 +11:00
clydebarrowandClaude Opus 5.5 26a67736ed [tcp] Use cg.static_buffer for the packet interface receive buffer
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-09 15:01:16 +11:00
clydebarrowandClaude Opus 5.5 629347dad0 Merge branch 'clydebarrow/packet-interface-07' into clydebarrow/packet-interface-08
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-09 15:01:01 +11:00
clydebarrowandClaude Opus 5.5 98d288e7bc Merge branch 'clydebarrow/packet-interface-06' into clydebarrow/packet-interface-07
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-09 15:00:59 +11:00
clydebarrowandClaude Opus 5.5 97f189578c Merge branch 'clydebarrow/packet-interface-05' into clydebarrow/packet-interface-06
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-09 15:00:57 +11:00
clydebarrowandClaude Opus 5.5 9255b8c43c Merge remote-tracking branch 'upstream/dev' into clydebarrow/packet-interface-05
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-09 15:00:56 +11:00
clydebarrowandClaude Opus 5.5 73a5d3a003 Merge branch 'clydebarrow/packet-interface-08' into clydebarrow/packet-interface-09
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-09 14:56:21 +11:00
clydebarrow 968a010448 Merge branch 'pi07' into pi08 2026-10-25 18:06:19 +11:00
clydebarrow 4d299da205 Merge branch 'pi06' into pi07 2026-10-25 18:06:18 +11:00
clydebarrow c691a71cc5 Merge branch 'pi05' into pi06 2026-10-25 18:06:18 +11:00
clydebarrow 07164fc8b1 Merge remote-tracking branch 'upstream/dev' into pi05
# Conflicts:
#	esphome/components/packet_interface/__init__.py
#	esphome/core/defines.h
2026-10-25 18:06:16 +11:00
clydebarrowandClaude Opus 5.5 1f67fdbd4c [espnow] Warn now and then when a packet interface link's sends keep failing
A failure that repeats on every send, such as a peer that could not be
added, was logged only at verbose level. The error name helper is now
shared so the link can name the error.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:39:41 +11:00
clydebarrowandClaude Opus 5.5 9f6bde2436 [espnow][udp] Log oversized ESP-NOW packets, and name any sender in the UDP drop warning
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:39:41 +11:00
clydebarrowandClaude Opus 5.5 d77c30f0bc [espnow][udp] Fixes from code review
- Add point_to_point to the UDP link, to override the guess that an
  address ending in .255 is a broadcast address, for subnets other than
  /24
- Warn, at most once a minute, when a point to point UDP link drops a
  packet from another sender
- Say that on ESP8266 an ESP-NOW peer link also receives the peer's
  broadcasts

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:39:41 +11:00
clydebarrowandClaude Code 06a9153011 [espnow][udp] Take the packet size from the copy buffer
The ESP-NOW link derives max_packet_size from the span it is given, as
the UDP point-to-point link already does.

Co-Authored-By: Claude Code <noreply@anthropic.com>
2026-10-23 13:39:41 +11:00
clydebarrowandClaude Opus 5.5 3aebba2cdf [espnow][udp] Fixes from code review
- Reject reliability, session and the rolling code on a broadcast UDP or
  ESP-NOW link without addressing, as every device hears the link
- Test the UDP and ESP-NOW final validation

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:39:41 +11:00
clydebarrowandClaude Opus 5.5 e6e1cb7540 [espnow] Keep the copy buffer in static memory
Code generation declares the ESP-NOW link's buffer for packets split
across buffers as a static array of max_packet_size bytes, so it is not
allocated at run time.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:39:41 +11:00
clydebarrowandClaude Opus 5.5 0c60a15d12 [espnow][udp] Add ESP-NOW packet interface link, and UDP point to point
The ESP-NOW link sends to one peer, which also provides addressing, or
broadcasts to every device on the channel. The UDP link accepts packets
only from the peer when the udp component sends to one unicast IPv4
address, and then provides addressing; the udp component now reports the
sender of each packet to its listeners.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:39:41 +11:00
clydeandClaude Opus 5.5 fe19e264ab [entity_transport] Reject a timeout on a link that does the session's job
TCP provides the session itself, so its config has no session key and
the timeout check let it through. update_interval then defaults to
never, and unchanged states timed out on a working link. Record the
layers each link class provides and check those too.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:39:40 +11:00
clydebarrowandClaude Opus 5.5 9f57216b9d [sx126x][sx127x] Stop reading a radio that fails while sends are held back
Also drop a leftover preamble_detect key from a test case.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:39:40 +11:00
clydebarrowandClaude Opus 5.5 923893f6df [packet_interface] Name a peer in the error for a link used with peers
The link may have only one peer, so the error no longer says several.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:39:40 +11:00
clydeandClaude Opus 5.5 a77653a0b3 [tcp] Apply clang-format to the packet interface test
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:39:40 +11:00
clydebarrowandClaude Opus 5.5 6d3b256191 [sx127x] Count only the sync word match as a packet arriving without LoRa
The preamble flag stays set when no sync word follows, so a packet from
another network held every send back until max_busy ran out. A link
without LoRa now needs a sync_value.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:39:40 +11:00
clydebarrowandClaude Opus 5.5 72f767cb4f [packet_interface] Log packets and fragments too short for their header
Every other drop in these layers is logged at verbose level.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:39:40 +11:00
clydebarrowandClaude Opus 5.5 861e0aa0da [packet_interface] Share the search for a layer that needs a session between both checks
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:39:40 +11:00
clydebarrowandClaude Opus 5.5 f3e727dc48 [sx126x] Require a sync word for a link with FSK
Without one the radio cannot tell that a packet is arriving, so listen
before talk does nothing.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:39:40 +11:00
clydebarrowandClaude Opus 5.5 681d93ddba [tcp] Explain why the rolling code cannot be used on a TCP link
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:39:40 +11:00
clydebarrowandClaude Opus 5.5 36799051e4 [sx126x][sx127x] Fixes from code review
- Without LoRa, require the SX127x radio to have a sync word or preamble
  detection, as listen before talk cannot see a packet arriving otherwise
- Warn once when a send finds the radio failed

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:39:40 +11:00
clydebarrowandClaude Opus 5.5 dd26efb0ca [tcp] Fixes from code review
- Publish the connected sensor as off at setup, so a link that never
  comes up does not show as unknown
- Add a timeout option, defaulting to three keep-alive intervals and
  longer than one, as the peer's keep_alive sets how often packets
  arrive; limit keep_alive to 1 h and timeout to 3 h
- Load binary_sensor for an empty config from tooling
- Name the layer in the error when a provided layer is configured

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:39:40 +11:00
clydebarrowandClaude Opus 5.5 d4d91bc9d1 [sx126x][sx127x] Fixes from code review
- Warn when a send goes ahead over a busy period at its limit, as that
  means a stuck busy indication or a jammed channel
- Log an empty packet at verbose level, and say why it counts as sent
- Name the radio id if code generation cannot find its configuration

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:39:40 +11:00
clydebarrowandClaude Code 8b5e3a1739 [tcp] Take the packet size from the receive buffer
The link takes the buffer as a std::span and derives max_packet_size
from its size, so a length beyond the buffer is refused and the
connection is closed.

Co-Authored-By: Claude Code <noreply@anthropic.com>
2026-10-23 13:39:40 +11:00
clydebarrowandClaude Opus 5.5 ff6d33b39b [sx126x][sx127x] Say which callers send a refused packet again
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:39:40 +11:00
clydebarrowandClaude Opus 5.5 df58794be0 [packet_interface] Keep App alive across tests
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:39:40 +11:00
clydebarrowandClaude Opus 5.5 b0632892c5 [sx126x][sx127x] Require rx_start for layers that need replies
- Reject a radio with rx_start false when the link or a peer has a layer
  that needs packets back from the peer, as the radio sleeps after sending
- Log a send over a long busy period at debug level, so a lost reception
  can be traced

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:39:40 +11:00
clydebarrowandClaude Opus 5.5 01e7827898 [packet_interface] Fix clang-tidy findings in tests
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:39:40 +11:00
clydebarrowandClaude Opus 5.5 dcc7c92a71 [sx126x][sx127x] Share the radio link code, and fixes from code review
- Make both links one RadioLink template in packet_interface, with shared
  code generation in radio_link.py, so a fix applies to both radios
- While sending is held back, watch the radio from loop() and end the
  busy period once it is free, so a later reception starts a new period
  instead of being sent over
- Reject an SX127x link without LoRa unless the radio is in packet mode

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:39:40 +11:00
clydebarrowandClaude Opus 5.5 de5652f845 [tcp] Fixes from code review
- Reserve the link's sockets, so the socket pool is sized for them
- Test the server role: accepting a client, receiving from it, and
  accepting the next after it disconnects
- Test a frame assembled across several reads, after a keep-alive

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:39:40 +11:00
clydebarrowandClaude Code 4614562856 [sx126x][sx127x] Take the packet size at construction
The radio links have no buffer of their own, so code generation passes
the configured max_packet_size to the constructor.

Co-Authored-By: Claude Code <noreply@anthropic.com>
2026-10-23 13:39:40 +11:00
clydebarrowandClaude Opus 5.5 4a26a38cee [tcp] Keep the receive buffer in static memory
Code generation declares the TCP link's receive buffer as a static array
of max_packet_size bytes, so it is not allocated at run time.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:39:40 +11:00
clydebarrowandClaude Opus 5.5 de6a9d5820 [sx126x][sx127x] Fixes from code review
- Hold a send back for at most the airtime of the largest packet, worked
  out from the radio settings and at least 2 s, instead of a fixed 2 s
  that a LoRa packet at a high spreading factor outlasts
- End a busy period when a send finds the radio free, so a busy flag that
  never clears is released however rarely sends are tried
- Detect an FSK reception on the SX127x from its preamble and sync word
  flags
- Test the radio links' final validation

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:39:40 +11:00
clydebarrowandClaude Opus 5.5 4e3f2b0e0b [packet_interface] Use a local to_vector() in tests
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:39:40 +11:00
clydebarrowandClaude Opus 5.5 cb28c2fc86 [sx126x][sx127x] Add packet interface links for SX126x and SX127x radios
Each packet is one radio packet, with the RSSI and SNR of received
packets in the metadata. A radio cannot hear while it sends, so a link
refuses to send while its radio is receiving a packet, for up to two
seconds, and the layers above send again shortly.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:39:40 +11:00
clydebarrowandClaude Opus 5.5 b04c8947e0 [tcp] Add TCP packet interface link
Packets go over one TCP connection, as a client that connects to a host
or a server that accepts one client at a time. TCP resends what is lost
and joins exactly two devices, so the link provides the reliability,
addressing and session layers itself, and those cannot be configured on
it. A link platform names such layers with the new provides argument.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:39:40 +11:00
clydebarrowandClaude Opus 5.5 b007bbb01c [packet_interface] Check at validation that fragments fit the reliability queue
- Work out each layer's packet size during validation, as the C++ does,
  and reject a fragmentation max_packet_size whose fragments do not all
  fit in the reliability queue at once, or need more than 128 fragments
- Fit the test peer's largest packet in its queue
- Reuse interface_layers() in final_validate_interface()
- Keep the earlier tests in place in test_packet_interface.py

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:39:39 +11:00
clydebarrowandClaude Opus 5.5 7ac9ba6daf [packet_interface] Use the shared max_packet_size constant in the fragmentation layer
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:39:39 +11:00
clydebarrowandClaude Opus 5.5 8b752525f5 [entity_transport] Find an addressing peer's layers for the timeout check
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:39:39 +11:00
clydebarrowandClaude Opus 5.5 07e1195ffa [packet_interface] Route broadcasts to the broadcast port, and keep a join
A broadcast from a device with its own port went to that port, whose
layers drop it, so a broadcast port could not reach reliable peers. It now
goes to the broadcast port when there is one.

Fragmentation allocates its buffers with RAMAllocator and fails setup when
they cannot be allocated. A fragment from another source no longer drops
the packet being joined.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:39:39 +11:00
clydebarrowandClaude Code 5ef072d03d [packet_interface] Take the addressing and fragmentation sizes at construction
AddressingPort derives max_packet_size from the link in its constructor,
and the fragmentation layer passes its configured size to the base
constructor.

Co-Authored-By: Claude Code <noreply@anthropic.com>
2026-10-23 13:39:39 +11:00
clydebarrowandClaude Opus 5.5 4d61784ba6 [packet_interface] Keep App alive across tests
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:39:39 +11:00
clydebarrowandClaude Opus 5.5 be4ea37f21 [packet_interface] Fix clang-tidy findings in tests
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:39:39 +11:00
clydebarrowandClaude Opus 5.5 9915cf6827 [packet_interface] Fixes from code review
- Reject an addressing destination or peer that is this device's own
  address, whose packets would be dropped as echoes
- Show 0 fragments, not SIZE_MAX, for a link with no room
- Test the check that applications use a peer's id

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:39:39 +11:00
clydebarrowandClaude Opus 5.5 beeeee07e8 [packet_interface] Use a local to_vector() in tests
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:39:21 +11:00
clydebarrowandClaude Opus 5.5 e9c386f57e [packet_interface] Leave no room, instead of underflowing, on a small link
As in the other layers, addressing ports and fragmentation get no room
when max_packet_size is smaller than their header, and fragmentation
fails its setup instead of dividing by zero.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:39:21 +11:00
clydebarrowandClaude Opus 5.5 01fbfeb16a [packet_interface] Add addressing and fragmentation layers
The addressing layer lets several devices share a channel such as an
RS485 bus or a radio, with 16-bit addresses. A link can carry several
peers, each with its own stack of layers and its own id. Layers that work
between two devices only are rejected with broadcast addressing. The
fragmentation layer splits packets larger than the layers below allow,
and joins them again.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:39:21 +11:00
pre-commit-ci-lite[bot] 369354a116 apply automatic formatting fixes 2026-10-23 13:39:03 +11:00
clydebarrowandClaude Opus 5.5 105d1bb088 [entity_transport] Warn when packets are refused for long, and check every complete dictionary
- Set a warning once the interface has accepted no packets for a minute,
  and log refused dictionary packets as data packets are
- Clear remote entities that a provider's dictionary does not name also
  when the provider goes back to a dictionary already seen

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:39:03 +11:00
clydebarrowandClaude Opus 5.5 1488af2b32 [entity_transport] Fixes from code review
- Check a data packet before asking for its dictionary, so a damaged
  packet does not make the provider resend everything
- When a provider's complete dictionary does not name a remote entity,
  warn and clear that entity's state, as a typo in provider or remote_id,
  or an entity the provider no longer sends, was otherwise silent

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:39:03 +11:00
clydebarrowandClaude Opus 5.5 74b8de8064 [entity_transport] Ask again for a dictionary with a lost part, and warn on dropped packets
A dictionary packet now carries its part index and a last-part flag. A dictionary counts as received, and is not
asked for again, only once its last part follows every other part in order. Until then, data under it sends a
request even when some remote entities are already known.

A refused request no longer starts the request interval. A short or malformed packet, or one with another format
version, is logged as a warning at most once a minute.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:39:03 +11:00
clydebarrowandClaude Opus 5.5 5393d192b4 [entity_transport] Reject a timeout on a packet interface with a session layer
With a session and a reliability layer, the update interval defaults to
never, and unchanged states are not sent again, so a receiver's timeout
cleared them on a working link. The session layer already clears the
states when the other device cannot be reached.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:39:03 +11:00
clydebarrowandClaude Opus 5.5 670934b3d8 [entity_transport] Tag each data record, and check whole packets before use
Each data record now starts with a 16-bit tag holding the entity's number
and type, and the form of its payload, so that more entity types can be
added and a receiver can skip records of types it does not know. A binary
sensor's state is in the tag; a sensor has a 4 byte state, or none.

Data and dictionary packets are checked in full before anything in them
is used, so a damaged or forged packet changes no state and teaches nothing.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:39:03 +11:00
clydebarrowandClaude Opus 5.5 f76dce46aa [entity_transport] Use the shared provider and remote id constants
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:39:03 +11:00
clydebarrowandClaude Opus 5.5 d44bccba3f [entity_transport] Ask only for dictionaries not yet received
A dictionary that names none of the remote entities was asked for again
every 5 seconds while any remote entity was unresolved, and each request
made its provider resend everything. A provider's new dictionary was not
asked for once every remote entity was resolved.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:39:03 +11:00
clydebarrowandClaude Opus 5.5 5b35282546 [entity_transport] Fail when the packet buffer cannot be allocated
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:39:03 +11:00
clydebarrowandClaude Code aa1d7fa26b [entity_transport] Set the test link's size at construction
The mock link takes max_packet_size in its constructor, so a test that
needs a different size builds a local link.

Co-Authored-By: Claude Code <noreply@anthropic.com>
2026-10-23 13:39:03 +11:00
clydebarrowandClaude Opus 5.5 3862504cdd [packet_interface] Keep App alive across tests
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:39:03 +11:00
clydebarrowandClaude Opus 5.5 ee3efdf15e [entity_transport] Brace multi-line if bodies
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:39:03 +11:00
clydebarrowandClaude Opus 5.5 db46ed33a2 [packet_interface] Fix clang-tidy findings in tests
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:39:03 +11:00
clydebarrowandClaude Opus 5.5 e09257a992 [packet_interface] Use a local to_vector() in tests
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:39:03 +11:00
clydebarrowandClaude Opus 5.5 1fa3dd37fe [entity_transport] Fixes from code review
- Compare received ids by length and bytes, so an id with an embedded NUL
  cannot read past the configured string
- Fail setup when max_packet_size cannot hold the device name and the
  longest entity id, instead of skipping the id at every resend
- Reject two entities of one type sent with the same id
- Avoid an unused variable without remote entities
- Use matching ids in the test configuration

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:39:03 +11:00
clydebarrowandClaude Opus 5.5 a7ca6a9608 [entity_transport] Add entity transport component
Sends sensor and binary sensor states to other devices over a packet
interface. A dictionary sent on connect, on request and at an interval
names the entities, so data packets refer to them by number. The update
interval and the handling of a lost peer follow the layers the interface
has, and remote states can time out.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:39:03 +11:00
clydeandClaude Opus 5.5 e046551825 [packet_interface] Stretch the XXTEA key text with PBKDF2
A single SHA-256 of the key text let a captured packet check about 2^30
guesses for every one that passes, so a weak key text fell quickly to
an offline search. Derive the key with PBKDF2-HMAC-SHA256 at 600,000
iterations instead; this runs at build time, so the device pays nothing.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:39:00 +11:00
pre-commit-ci-lite[bot] 18b5b7a24a apply automatic formatting fixes 2026-10-23 12:28:10 +10:00
clydebarrowandClaude Opus 5.5 179d20ba77 [packet_interface] Limit the session keep_alive to 1 h and timeout to 3 h
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 12:28:10 +10:00
clydebarrowandClaude Opus 5.5 1bc4779d96 [packet_interface] Fail the XXTEA layer when its buffers cannot be allocated
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 12:28:10 +10:00
clydebarrowandClaude Opus 5.5 366713ba05 [packet_interface] Check the layers in the link schema
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 12:28:10 +10:00
clydebarrowandClaude Opus 5.5 47b8aae1b5 [packet_interface] Require a session layer with the rolling code
The rolling code accepts a packet only once the peer has sent back this
device's boot number, so a device that only receives never gets a packet.
The session's keep-alives make sure packets go both ways.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 12:28:10 +10:00
pre-commit-ci-lite[bot] a9c155e4b4 apply automatic formatting fixes 2026-10-23 12:28:10 +10:00
clydebarrowandClaude Code 708e117a20 [packet_interface] Take the session and encryption sizes at construction
Both layers derive max_packet_size from the layer below in their
constructors instead of assigning it in the body.

Co-Authored-By: Claude Code <noreply@anthropic.com>
2026-10-23 12:28:10 +10:00
clydebarrowandClaude Opus 5.5 c6d1c63884 [packet_interface] Keep App alive across tests
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 12:28:10 +10:00
clydebarrowandClaude Opus 5.5 faef5a98bf [packet_interface] Fix clang-tidy findings in tests
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 12:28:10 +10:00
clydebarrowandClaude Opus 5.5 7c86318c1a [packet_interface] Use a local to_vector() in tests
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 12:28:10 +10:00
clydebarrowandClaude Opus 5.5 58ef6ef3d9 [packet_interface] Fixes from code review
- Fail setup, instead of underflowing, when max_packet_size leaves the
  encryption or session layer no room
- Warn when the boot number cannot be saved
- Warn once when the peer's packets carry an older boot number, which
  happens when its flash is erased
- Test the counter wrapping to a new boot number

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 12:28:10 +10:00
clydebarrowandClaude Opus 5.5 a6d2ae15a1 [packet_interface] Add session and XXTEA encryption layers
The session layer sends keep-alives and reports whether the peer can be
reached, including after it restarts or a reliability layer below loses
data. The encryption layer encrypts and checks each packet with XXTEA,
with an optional rolling code against replays. Components that a layer
needs, such as binary_sensor, are loaded only when it is configured.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 12:28:10 +10:00
clydebarrowandClaude Opus 5.5 63cfdf2b4d [packet_interface] Reject a layer type registered after the schemas are built
Such a type would be missing from the link schema, and selecting it would
fail with an unrelated error.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 12:28:10 +10:00
clydebarrowandClaude Opus 5.5 6411a8062f [packet_interface] Log a full queue during a link reset only once
While the peer is away the layers above keep sending, so the message
repeated about once a second until the link came up again.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 12:28:10 +10:00
clydebarrowandClaude Opus 5.5 c18ac5bac9 [packet_interface] Count the link reset tries outside the condition
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 12:28:10 +10:00
clydebarrowandClaude Opus 5.5 78396dd142 [packet_interface] Warn when the HDLC link cannot come up
A frame larger than max_packet_size, usually from a peer with a larger
setting, is warned about once. A link reset that the peer does not answer
is warned about after max_retries tries, and a full queue is logged at
debug level while the link is down.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 12:28:10 +10:00
clydebarrowandClaude Code 557e3c3e9e [packet_interface] Reject a duplicate layer type name
Every module in layers/ is imported automatically, so two modules
registering the same name silently replaced one with the other, in an
order decided by pkgutil. Registration now raises, so the mistake is
found when the configuration is loaded.

Co-Authored-By: Claude Code <noreply@anthropic.com>
2026-10-23 12:28:10 +10:00
clydebarrowandClaude Code 8fd05e93b4 [packet_interface] Answer a repeated SABM without resetting the link
A peer that has not heard the UA repeats its SABM, and cannot have sent a
numbered frame meanwhile. Treating that as a restart threw away queued
frames and reported the session lost for a single dropped UA. A SABM is
now a restart only if the peer has sent a numbered frame since the link
came up.

Co-Authored-By: Claude Code <noreply@anthropic.com>
2026-10-23 12:28:10 +10:00
clydebarrowandClaude Code f81c6847f3 [packet_interface] Take the reliability layer's size at construction
max_packet_size is derived from the layer below in the constructor
instead of being assigned in the body.

Co-Authored-By: Claude Code <noreply@anthropic.com>
2026-10-23 12:28:10 +10:00
clydebarrowandClaude Opus 5.5 d555d64300 [packet_interface] Fixes from code review
- Keep App alive across the HDLC tests, as the test main requires
- Run a layer's loop in the tests only while it has asked for it, so
  the loop's disable and request bookkeeping is tested, and wait for the
  retry timer in the tests of refused sends
- Report no send capacity while the layer has no send queue

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 12:28:10 +10:00
clydebarrowandClaude Opus 5.5 267e3d5d70 [packet_interface] Fix clang-tidy findings in tests
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 12:28:10 +10:00
clydebarrowandClaude Opus 5.5 2da760ea4f [packet_interface] Use a local to_vector() in tests
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 12:28:10 +10:00
clydebarrowandClaude Opus 5.5 0b34f811a4 [packet_interface] Fixes from code review
- Reset the link after max_retries even when it is 255, where the retry
  counter used to wrap
- Require a reliability timeout of at least 50 ms
- Drop received frames larger than the layer's max_packet_size
- Fail setup, instead of aborting, when the send queue cannot be
  allocated or max_packet_size leaves no room
- Test the ack delay timer and a refused REJ

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 12:28:10 +10:00
clydebarrowandClaude Opus 5.5 28833fe0f3 [packet_interface] Add layer registry and HDLC reliability layer
Layers stack on a link and are configured on its packet_interface entry.
Each layer type registers itself with its kind, so a new type needs only
a new module. The first is a reliability layer in the style of HDLC
asynchronous balanced mode, with go-back-N retransmission.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 12:28:10 +10:00
clydebarrowandClaude Code 929aac8fac [udp] Take the packet size from the copy buffer
The link derives max_packet_size from the span it is given, so a packet
larger than the copy buffer cannot be copied into it.

Co-Authored-By: Claude Code <noreply@anthropic.com>
2026-10-23 13:28:08 +11:00
clydebarrowandClaude Opus 5.5 11cc5bb008 [udp] Limit a split packet to the copy buffer
The copy buffer is sized by code generation to max_packet_size, but
set_max_packet_size() can raise the limit afterwards, and copying a split
packet would then overflow it. The link now takes the buffer as a span
and refuses a split packet larger than it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:28:08 +11:00
clydebarrowandClaude Opus 5.5 2d6be6c27a [udp] Drop datagrams longer than the receive buffer
A read cuts a datagram longer than the buffer to fit, so a 600 byte
datagram arrived as a valid looking 508 byte packet. The buffer is now one
byte longer, and a read that fills it is dropped. The split packet test
also checks the bytes joined in the copy buffer.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:28:08 +11:00
clydebarrowandClaude Opus 5.5 bfa6e68039 [packet_interface] Fix clang-tidy findings in tests
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:28:08 +11:00
clydebarrowandClaude Opus 5.5 c39566f312 [udp] Keep the copy buffer in static memory
Code generation declares the UDP link's buffer for packets split across
buffers as a static array of max_packet_size bytes, so it is not
allocated at run time.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:28:08 +11:00
clydebarrowandClaude Opus 5.5 5197140f2c [packet_interface] Use a local to_vector() in tests
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:28:08 +11:00
clydebarrowandClaude Opus 5.5 ee0c6a412e [udp] Fixes from code review
- Enforce max_packet_size on send and receive
- Copy split packets into a buffer allocated in setup, not on the stack
- Add unit tests for the link's send and receive paths
- Explain why the broadcast socket is always enabled

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:28:08 +11:00
clydebarrowandClaude Opus 5.5 373c6398b2 [udp] Add UDP packet interface link
Each packet is one UDP datagram, using the settings of the udp component.
The udp component now reports whether a packet was sent, and an ENOMEM
refusal from lwIP is logged at verbose level as the packet can be sent
again.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 13:28:08 +11:00
194 changed files with 12531 additions and 1257 deletions

No files matched your search

+10 -1
View File
@@ -146,9 +146,11 @@ esphome/components/cover/* @esphome/core
esphome/components/cs5460a/* @balrog-kun
esphome/components/cse7761/* @berfenger
esphome/components/cst226/* @clydebarrow
esphome/components/cst3240/* @tpruvot
esphome/components/cst328/* @latonita
esphome/components/cst816/* @clydebarrow
esphome/components/cst9220/* @clydebarrow
esphome/components/cstxxx/* @clydebarrow @latonita
esphome/components/ct_clamp/* @jesserockz
esphome/components/current_based/* @djwmarcx
esphome/components/cw2017/* @exciton
@@ -225,6 +227,7 @@ esphome/components/esp_ldo/* @clydebarrow
esphome/components/espectre/* @francescopace
esphome/components/esphome/ota/* @esphome/core
esphome/components/espnow/* @jesserockz
esphome/components/espnow/packet_interface/* @clydebarrow
esphome/components/espnow/packet_transport/* @EasilyBoredEngineer
esphome/components/ethernet_info/* @gtjadsonsantos
esphome/components/event/* @nohat
@@ -379,6 +382,7 @@ esphome/components/ltr390/* @latonita @sjtrny
esphome/components/ltr501/* @latonita
esphome/components/ltr_als_ps/* @latonita
esphome/components/lvgl/* @clydebarrow
esphome/components/lzss/* @clydebarrow
esphome/components/m5stack_4relay/* @KoenBreeman
esphome/components/m5stack_8angle/* @rnauber
esphome/components/m5stack_unit_bldc/* @lboue
@@ -466,6 +470,7 @@ esphome/components/nfc/* @jesserockz @kbx81
esphome/components/noblex/* @AGalfra
esphome/components/noise/* @esphome/core
esphome/components/npi19/* @bakerkj
esphome/components/npm1300/* @tomaszduda23
esphome/components/nrf52/* @tomaszduda23
esphome/components/ns2009/* @tchilov
esphome/components/ns2009/touchscreen/* @tchilov
@@ -648,7 +653,9 @@ esphome/components/sun_gtil2/* @Mat931
esphome/components/switch/* @esphome/core
esphome/components/switch/binary_sensor/* @ssieb
esphome/components/sx126x/* @swoboda1337
esphome/components/sx126x/packet_interface/* @clydebarrow
esphome/components/sx127x/* @swoboda1337
esphome/components/sx127x/packet_interface/* @clydebarrow
esphome/components/sy6970/* @linkedupbits
esphome/components/syslog/* @clydebarrow
esphome/components/systa_bus/* @Mat931
@@ -660,6 +667,8 @@ esphome/components/tca8418/* @zebble
esphome/components/tca9548a/* @andreashergert1984
esphome/components/tca9555/* @mobrembski
esphome/components/tcl112/* @glmnet
esphome/components/tcp/* @clydebarrow
esphome/components/tcp/packet_interface/* @clydebarrow
esphome/components/tcp_uart/* @Bascht74
esphome/components/tee501/* @Stock-M
esphome/components/teleinfo/* @0hax @FredM67
@@ -741,7 +750,7 @@ esphome/components/web_server_idf/* @dentra
esphome/components/weikai/* @DrCoolZic
esphome/components/weikai_i2c/* @DrCoolZic
esphome/components/weikai_spi/* @DrCoolZic
esphome/components/whirlpool/* @arpena @glmnet
esphome/components/whirlpool/* @arpena @glmnet @Rodrigoah
esphome/components/whynter/* @aeonsablaze
esphome/components/wiegand/* @ssieb
esphome/components/wireguard/* @droscy @lhoracek @thomas0bernard
@@ -278,10 +278,9 @@ APIError APINoiseFrameHelper::state_action_client_hello_() {
state_ = State::FAILED;
return APIError::OUT_OF_MEMORY;
}
dst[0] = (uint8_t) (rx_size >> 8);
dst[1] = (uint8_t) rx_size;
uint8_t *payload = put_be16(dst, rx_size);
if (rx_size > 0) {
std::memcpy(dst + 2, this->rx_buf_.data(), rx_size);
std::memcpy(payload, this->rx_buf_.data(), rx_size);
}
#ifdef USE_API_OUTGOING_CONNECTION
@@ -464,10 +463,8 @@ APIError APINoiseFrameHelper::encrypt_noise_message_(uint8_t *buf_start, uint16_
// Write message header (to be encrypted)
constexpr uint8_t msg_offset = noise::FRAME_HEADER_SIZE;
buf_start[msg_offset] = static_cast<uint8_t>(message_type >> 8); // type high byte
buf_start[msg_offset + 1] = static_cast<uint8_t>(message_type); // type low byte
buf_start[msg_offset + 2] = static_cast<uint8_t>(payload_size >> 8); // data_len high byte
buf_start[msg_offset + 3] = static_cast<uint8_t>(payload_size); // data_len low byte
put_be16(buf_start + msg_offset, message_type);
put_be16(buf_start + msg_offset + 2, payload_size);
// payload data is already in the buffer starting at offset + 7
// Encrypt the message in place
@@ -1,6 +1,7 @@
#include "api_overflow_buffer.h"
#ifdef USE_API
#include <cstring>
#include "esphome/core/helpers.h"
namespace esphome::api {
@@ -17,7 +18,7 @@ ssize_t APIOverflowBuffer::try_drain(socket::Socket *socket) {
while (this->count_ > 0) {
uint8_t *msg = this->buf_.data() + this->head_;
size_t len = msg[0] | (msg[1] << 8);
size_t len = encode_value_le<uint16_t>(msg);
ssize_t sent = socket->write(msg + LEN_PREFIX, len);
if (sent <= 0)
+5 -1
View File
@@ -35,7 +35,11 @@ async def to_code(config: ConfigType) -> None:
add_idf_component(name="esp32async/asynctcp", ref="3.4.91")
elif CORE.is_libretiny:
# https://github.com/ESP32Async/AsyncTCP
cg.add_library("ESP32Async/AsyncTCP", "3.4.5")
cg.add_library("ESP32Async/AsyncTCP", "3.5.0")
# AsyncTCP 3.5.0 debug logs call xPortGetCoreID(), which LibreTiny (single core) lacks; they are compiled
# in by LibreTiny's debug level or CONFIG_ASYNC_TCP_DEBUG, so the call always expands to int(), which is 0
# (a function-like -D does not survive PlatformIO's build flags)
cg.add_build_flag("-DxPortGetCoreID=int")
elif CORE.is_esp8266:
# https://github.com/ESP32Async/ESPAsyncTCP
cg.add_library("ESP32Async/ESPAsyncTCP", "2.0.0")
@@ -2,6 +2,7 @@
#include <algorithm>
#include <cstring>
#include "esphome/core/helpers.h"
namespace esphome::ble_device_base {
@@ -163,8 +164,7 @@ bool aes_ccm_auth_decrypt(const uint8_t key[16], const uint8_t *nonce, size_t no
if (aad_len > 0) {
// Only the < 2^16-2^8 encoding is needed for BLE-sized AAD.
uint8_t blk[16] = {0};
blk[0] = static_cast<uint8_t>((aad_len >> 8) & 0xff);
blk[1] = static_cast<uint8_t>(aad_len & 0xff);
put_be16(blk, aad_len);
size_t ai = 0;
size_t pos = 2;
while (pos < 16 && ai < aad_len)
+42 -7
View File
@@ -1,3 +1,5 @@
from typing import Any
from esphome import automation, pins
from esphome.automation import maybe_simple_id
import esphome.codegen as cg
@@ -13,6 +15,7 @@ from esphome.const import (
CONF_VALUE,
CONF_WAIT_TIME,
)
from esphome.types import ConfigType
CODEOWNERS = ["@lygris", "@gabest11"]
DEPENDENCIES = ["spi"]
@@ -22,6 +25,8 @@ MULTI_CONF = True
ns = cg.esphome_ns.namespace("cc1101")
CC1101Component = ns.class_("CC1101Component", cg.Component, spi.SPIDevice)
CC1101Listener = ns.class_("CC1101Listener")
PACKET_TYPE = cg.std_vector.template(cg.uint8)
RX_FIFO_SIZE = 64
# Config keys
CONF_RX_ATTENUATION = "rx_attenuation"
@@ -241,20 +246,34 @@ CONFIG_MAP = {
cv.Optional(CONF_BS_POST_KI): cv.enum(BS_POST_KI, upper=False),
cv.Optional(CONF_BS_POST_KP): cv.enum(BS_POST_KP, upper=False),
cv.Optional(CONF_PACKET_MODE, default=False): cv.boolean,
cv.Optional(CONF_PACKET_LENGTH): cv.uint8_t,
cv.Optional(CONF_CRC_ENABLE, default=False): cv.boolean,
cv.Optional(CONF_WHITENING, default=False): cv.boolean,
}
def _validate_packet_mode(config):
if config.get(CONF_PACKET_MODE, False):
def _is_long_packet(packet_length: Any) -> bool:
"""A packet_length that does not fit the RX FIFO, or is a lambda."""
return cg.is_template(packet_length) or (packet_length or 0) > RX_FIFO_SIZE
def _validate_packet_mode(config: ConfigType) -> ConfigType:
packet_mode = config.get(CONF_PACKET_MODE, False)
packet_length = config.get(CONF_PACKET_LENGTH)
if packet_mode:
if CONF_GDO0_PIN not in config:
raise cv.Invalid("gdo0_pin is required when packet_mode is enabled")
if CONF_PACKET_LENGTH not in config:
if packet_length is None:
raise cv.Invalid("packet_length is required when packet_mode is enabled")
if config[CONF_PACKET_LENGTH] > 64:
raise cv.Invalid("packet_length must be <= 64 (FIFO size)")
elif cg.is_template(packet_length):
raise cv.Invalid("packet_mode is required when packet_length is a lambda")
if (
packet_mode
and _is_long_packet(packet_length)
and config.get(CONF_CRC_ENABLE, False)
):
raise cv.Invalid(
"crc_enable is not supported with packet_length > 64 or a lambda"
)
return config
@@ -263,6 +282,9 @@ CONFIG_SCHEMA = cv.All(
{
cv.GenerateID(): cv.declare_id(CC1101Component),
cv.Optional(CONF_GDO0_PIN): pins.internal_gpio_input_pin_schema,
cv.Optional(CONF_PACKET_LENGTH): cv.templatable(
cv.int_range(min=0, max=1024)
),
cv.Optional(CONF_ON_PACKET): automation.validate_automation(single=True),
}
)
@@ -282,11 +304,24 @@ async def to_code(config):
cg.add(getattr(var, f"set_{key}")(config[key]))
await cg.add_pin(var.set_gdo0_pin, config.get(CONF_GDO0_PIN))
if (packet_length := config.get(CONF_PACKET_LENGTH)) is not None:
# packet_mode can also be switched on at run time, so this does not check it
if _is_long_packet(packet_length):
cg.add_define("USE_CC1101_LONG_PACKET")
if cg.is_template(packet_length):
lambda_ = await cg.process_lambda(
packet_length,
[(PACKET_TYPE.operator("ref").operator("const"), "x")],
return_type=cg.int32,
)
cg.add(var.set_packet_length_lambda(lambda_))
else:
cg.add(var.set_packet_length(packet_length))
if CONF_ON_PACKET in config:
await automation.build_automation(
var.get_packet_trigger(),
[
(cg.std_vector.template(cg.uint8), "x"),
(PACKET_TYPE, "x"),
(cg.float_, "freq_offset"),
(cg.float_, "rssi"),
(cg.uint8, "lqi"),
+353 -33
View File
@@ -1,8 +1,10 @@
#include "cc1101.h"
#include "cc1101pa.h"
#include "esphome/core/application.h"
#include "esphome/core/helpers.h"
#include "esphome/core/log.h"
#include "esphome/core/progmem.h"
#include <algorithm>
#include <cmath>
#include <cstring>
@@ -14,9 +16,15 @@ namespace esphome::cc1101 {
ESPHOME_LOG_TAG(TAG, "cc1101");
static constexpr size_t TX_FIFO_SIZE = 64;
static constexpr size_t RX_FIFO_SIZE = 64;
// RX FIFO threshold for FIFO_THR = 7 in long packet mode
static constexpr uint8_t RX_FIFO_THRESHOLD = 32;
// The crystal takes about 150 us to start after CSn goes low
static constexpr uint32_t WAKEUP_DELAY_US = 200;
static float freq_offset_hz(uint8_t freqest) { return static_cast<int8_t>(freqest) * (XTAL_FREQUENCY / (1 << 14)); }
static float rssi_dbm(int8_t rssi) { return (rssi * RSSI_STEP) - RSSI_OFFSET; }
// MDMCFG2 MOD_FORMAT values
PROGMEM_STRING_TABLE(ModulationStrings, "2-FSK", "GFSK", "UNUSED", "ASK/OOK", "4-FSK", "UNUSED", "UNUSED", "MSK");
@@ -114,8 +122,6 @@ CC1101Component::CC1101Component() {
memset(this->pa_table_, 0, sizeof(this->pa_table_));
}
void IRAM_ATTR CC1101Component::gpio_intr(CC1101Component *arg) { arg->enable_loop_soon_any_context(); }
void CC1101Component::setup() {
this->spi_setup();
@@ -193,7 +199,220 @@ void CC1101Component::call_listeners_(const std::vector<uint8_t> &packet, float
this->packet_trigger_.trigger(packet, freq_offset, rssi, lqi);
}
float CC1101Component::symbol_rate_() const {
return (((256.0f + this->state_.DRATE_M) * (1 << this->state_.DRATE_E)) / (1 << 28)) * XTAL_FREQUENCY;
}
#ifdef USE_CC1101_LONG_PACKET
bool CC1101Component::is_long_packet_mode_() const {
return this->packet_mode_ && (this->packet_length_ > RX_FIFO_SIZE || this->packet_length_func_ != nullptr);
}
void CC1101Component::arm_length_(uint16_t length) {
// Over 255 bytes or unknown starts in infinite mode (datasheet section 15.2.2). PKTLEN must not be 0, so a
// multiple of 256 stays in infinite mode and ends on the MCU byte count alone.
this->packet_expected_length_ = length;
this->state_.LENGTH_CONFIG = static_cast<uint8_t>(length > 0 && length < 256 ? LengthConfig::LENGTH_CONFIG_FIXED
: LengthConfig::LENGTH_CONFIG_INFINITE);
this->state_.PKTLEN = length % 256 == 0 ? 0xFF : static_cast<uint8_t>(length % 256);
}
void CC1101Component::reset_long_packet_rx_() {
this->packet_.clear();
this->packet_last_byte_ms_ = 0;
this->high_freq_.stop();
this->arm_length_(this->packet_length_func_ != nullptr ? 0 : this->packet_length_);
}
void CC1101Component::restart_long_packet_rx_() {
this->enter_idle_();
this->enter_rx_();
this->disable_loop();
}
void CC1101Component::maybe_switch_long_packet_to_fixed_() {
const uint16_t expected = this->packet_expected_length_;
if (this->state_.LENGTH_CONFIG == static_cast<uint8_t>(LengthConfig::LENGTH_CONFIG_FIXED) || expected == 0 ||
expected % 256 == 0) {
return;
}
const uint16_t received = this->packet_.size();
if (expected - received >= 256) {
return;
}
// PKTLEN keeps the (length % 256) set at the start, as in TI Design Note DN500 section 2.3
this->state_.LENGTH_CONFIG = static_cast<uint8_t>(LengthConfig::LENGTH_CONFIG_FIXED);
this->write_(Register::PKTCTRL0);
ESP_LOGVV(TAG, "Switched long packet RX to fixed mode: received=%u expected=%u pktlen=%u", received, expected,
this->state_.PKTLEN);
}
void CC1101Component::finish_long_packet_() {
this->packet_.resize(this->packet_expected_length_);
this->read_(Register::FREQEST);
this->read_(Register::LQI);
const float freq_offset = freq_offset_hz(this->state_.FREQEST);
const uint8_t lqi = this->state_.LQI & STATUS_LQI_MASK;
// No CRC check: crc_enable is rejected for long packets, CRC_OK is only set after the last payload byte.
// Restart RX before dispatching so a callback may change settings; swapping back keeps the reserved capacity
// unless a callback reserved a larger buffer.
std::vector<uint8_t> packet;
packet.swap(this->packet_);
this->restart_long_packet_rx_();
this->call_listeners_(packet, freq_offset, rssi_dbm(this->long_packet_rssi_), lqi);
if (packet.capacity() > this->packet_.capacity()) {
packet.clear();
this->packet_.swap(packet);
}
}
void CC1101Component::handle_long_packet_(uint8_t rx_bytes) {
// Leave one byte in the FIFO unless it holds the rest of the packet (datasheet section 20)
uint16_t to_read = rx_bytes > 0 ? rx_bytes - 1 : 0;
if (this->packet_expected_length_ > 0) {
const uint16_t remaining = this->packet_expected_length_ - this->packet_.size();
if (remaining <= rx_bytes) {
to_read = remaining;
}
}
if (to_read == 0) {
if (this->packet_.empty()) {
return;
}
// Discard a packet when no byte arrived for the air time of PACKET_IDLE_TIMEOUT_BYTES
const uint32_t timeout_ms =
std::max(static_cast<uint32_t>(std::ceil((8.0f * PACKET_IDLE_TIMEOUT_BYTES * 1000.0f) / this->symbol_rate_())),
PACKET_IDLE_TIMEOUT_MIN_MS);
if (App.get_loop_component_start_time() - this->packet_last_byte_ms_ > timeout_ms) {
ESP_LOGW(TAG, "Packet receive timeout, discarding packet: received=%u expected=%u fifo=%u",
static_cast<uint16_t>(this->packet_.size()), this->packet_expected_length_, rx_bytes);
this->restart_long_packet_rx_();
}
return;
}
const size_t old_size = this->packet_.size();
if (old_size == 0) {
// The RSSI register follows the live signal; sample it while the packet is still on air
this->read_(Register::RSSI);
this->long_packet_rssi_ = this->state_.RSSI;
// The FIFO threshold signal does not fire for the bytes after the last threshold crossing; poll until done
this->high_freq_.start();
}
// Read through an aligned buffer: for an unaligned target the ESP32 SPI driver allocates a bounce buffer
alignas(4) uint8_t staged[RX_FIFO_SIZE];
this->read_(Register::FIFO, staged, to_read);
this->packet_.resize(old_size + to_read);
std::memcpy(this->packet_.data() + old_size, staged, to_read);
this->packet_last_byte_ms_ = App.get_loop_component_start_time();
ESP_LOGVV(TAG, "Drained RX FIFO: read=%u received=%u expected=%u fifo=%u", to_read,
static_cast<uint16_t>(this->packet_.size()), this->packet_expected_length_, rx_bytes);
if (this->packet_expected_length_ == 0 && this->packet_length_func_ != nullptr) {
const int32_t length = this->packet_length_func_(this->packet_);
if (length < 0) {
ESP_LOGVV(TAG, "Packet length lambda discarded packet: received=%u", static_cast<uint16_t>(this->packet_.size()));
this->restart_long_packet_rx_();
return;
}
if (length > MAX_PACKET_LENGTH) {
ESP_LOGW(TAG, "Packet length exceeds maximum, discarding packet: length=%" PRId32 " max=%u", length,
MAX_PACKET_LENGTH);
this->restart_long_packet_rx_();
return;
}
if (length > 0) {
this->arm_length_(static_cast<uint16_t>(length));
// A packet shorter than the first FIFO drain is already complete; finish_long_packet_() truncates it
if (this->packet_expected_length_ <= this->packet_.size()) {
this->finish_long_packet_();
return;
}
this->write_(Register::PKTLEN);
this->write_(Register::PKTCTRL0);
ESP_LOGVV(TAG, "Resolved packet length: received=%u expected=%u pktlen=%u",
static_cast<uint16_t>(this->packet_.size()), this->packet_expected_length_, this->state_.PKTLEN);
}
}
// Only reachable while the length is still unknown; a known length caps every read
if (this->packet_.size() > MAX_PACKET_LENGTH) {
ESP_LOGW(TAG, "Packet length exceeds maximum, discarding packet: length=%u max=%u",
static_cast<uint16_t>(this->packet_.size()), MAX_PACKET_LENGTH);
this->restart_long_packet_rx_();
return;
}
this->maybe_switch_long_packet_to_fixed_();
if (this->packet_expected_length_ > 0 && this->packet_.size() >= this->packet_expected_length_) {
this->finish_long_packet_();
}
}
void CC1101Component::loop_long_packet_() {
if (this->sleeping_ || this->state_.PKT_FORMAT != static_cast<uint8_t>(PacketFormat::PACKET_FORMAT_FIFO) ||
this->gdo0_pin_ == nullptr) {
this->high_freq_.stop();
this->disable_loop();
return;
}
// While GDO0 (RX FIFO threshold) is high, the FIFO holds at least RX_FIFO_THRESHOLD bytes, so drain without
// reading RXBYTES. At high data rates RXBYTES changes between two reads, so waiting for two reads that agree
// and retrying on the next loop pass lets the FIFO overflow. MARCSTATE does not change during RX.
for (uint8_t i = 0; i < RX_FIFO_SIZE / RX_FIFO_THRESHOLD + 2 && this->gdo0_pin_->digital_read(); i++) {
this->read_(Register::MARCSTATE);
if (static_cast<State>(this->state_.MARC_STATE) == State::RXFIFO_OVERFLOW) {
ESP_LOGW(TAG, "RX FIFO overflow, discarding packet: received=%u expected=%u",
static_cast<uint16_t>(this->packet_.size()), this->packet_expected_length_);
this->restart_long_packet_rx_();
return;
}
this->handle_long_packet_(RX_FIFO_THRESHOLD);
if (this->packet_.empty()) {
return; // finished or discarded
}
}
// Below the threshold the next crossing raises GDO0 again, and after the packet the count no longer changes,
// so retrying on the next loop pass is safe here. RXBYTES can be misread while bytes arrive (TI SWRZ020), so
// only trust two consecutive reads that agree.
this->read_(Register::RXBYTES);
uint8_t rx_bytes = this->state_.RXBYTES;
bool stable = false;
for (uint8_t retries = RXBYTES_STABLE_RETRIES; retries > 0 && !stable; retries--) {
const uint8_t previous = rx_bytes;
this->read_(Register::RXBYTES);
rx_bytes = this->state_.RXBYTES;
stable = rx_bytes == previous;
}
if (!stable) {
return;
}
rx_bytes = this->state_.NUM_RXBYTES;
// More than the FIFO holds can only be a misread; the staged drain buffer is FIFO sized
if (this->state_.RXFIFO_OVERFLOW || rx_bytes > RX_FIFO_SIZE) {
ESP_LOGW(TAG, "RX FIFO overflow, discarding packet: received=%u expected=%u fifo=%u",
static_cast<uint16_t>(this->packet_.size()), this->packet_expected_length_, rx_bytes);
this->restart_long_packet_rx_();
return;
}
if (rx_bytes == 0 && this->packet_.empty() && !this->gdo0_pin_->digital_read()) {
this->disable_loop();
return;
}
this->handle_long_packet_(rx_bytes);
}
#endif
void CC1101Component::loop() {
#ifdef USE_CC1101_LONG_PACKET
if (this->is_long_packet_mode_()) {
this->loop_long_packet_();
return;
}
#endif
this->disable_loop();
if (this->sleeping_ || this->state_.PKT_FORMAT != static_cast<uint8_t>(PacketFormat::PACKET_FORMAT_FIFO) ||
this->gdo0_pin_ == nullptr || !this->gdo0_pin_->digital_read()) {
@@ -221,7 +440,7 @@ void CC1101Component::loop() {
payload_length = this->state_.PKTLEN;
expected_rx = payload_length;
}
if (payload_length == 0 || payload_length > 64 || rx_bytes != expected_rx) {
if (payload_length == 0 || payload_length > RX_FIFO_SIZE || rx_bytes != expected_rx) {
ESP_LOGW(TAG, "Invalid packet: rx_bytes %u, payload_length %u", rx_bytes, payload_length);
this->enter_idle_();
this->strobe_(Command::FRX);
@@ -235,8 +454,8 @@ void CC1101Component::loop() {
this->read_(Register::FREQEST);
this->read_(Register::RSSI);
this->read_(Register::LQI);
float freq_offset = static_cast<int8_t>(this->state_.FREQEST) * (XTAL_FREQUENCY / (1 << 14));
float rssi = (this->state_.RSSI * RSSI_STEP) - RSSI_OFFSET;
float freq_offset = freq_offset_hz(this->state_.FREQEST);
float rssi = rssi_dbm(this->state_.RSSI);
bool crc_ok = (this->state_.LQI & STATUS_CRC_OK_MASK) != 0;
uint8_t lqi = this->state_.LQI & STATUS_LQI_MASK;
if (this->state_.CRC_EN == 0 || crc_ok) {
@@ -256,7 +475,7 @@ void CC1101Component::loop() {
void CC1101Component::dump_config() {
int32_t freq = static_cast<int32_t>(this->state_.FREQ2 << 16 | this->state_.FREQ1 << 8 | this->state_.FREQ0) *
XTAL_FREQUENCY / (1 << 16);
float symbol_rate = (((256.0f + this->state_.DRATE_M) * (1 << this->state_.DRATE_E)) / (1 << 28)) * XTAL_FREQUENCY;
float symbol_rate = this->symbol_rate_();
float bw = XTAL_FREQUENCY / (8.0f * (4 + this->state_.CHANBW_M) * (1 << this->state_.CHANBW_E));
ESP_LOGCONFIG(TAG,
"CC1101:\n"
@@ -271,6 +490,20 @@ void CC1101Component::dump_config() {
LOG_STR_ARG(ModulationStrings::get_log_str(this->state_.MOD_FORMAT & 0x07, 0)), symbol_rate, bw,
this->output_power_effective_);
LOG_PIN(" CS Pin: ", this->cs_);
LOG_PIN(" GDO0 Pin: ", this->gdo0_pin_);
if (this->packet_mode_) {
#ifdef USE_CC1101_LONG_PACKET
if (this->packet_length_func_ != nullptr) {
ESP_LOGCONFIG(TAG, " Packet Length: lambda");
} else
#endif
if (this->packet_length_ == 0) {
ESP_LOGCONFIG(TAG, " Packet Length: variable");
} else {
ESP_LOGCONFIG(TAG, " Packet Length: %u", this->packet_length_);
}
}
}
void CC1101Component::begin_tx() {
@@ -316,6 +549,14 @@ void CC1101Component::reset() {
void CC1101Component::set_idle() {
ESP_LOGV(TAG, "Setting IDLE state");
this->enter_idle_();
#ifdef USE_CC1101_LONG_PACKET
if (this->is_long_packet_mode_()) {
// Drop a partial packet so a pending loop pass cannot finish it and re-enter RX
this->strobe_(Command::FRX);
this->reset_long_packet_rx_();
this->disable_loop();
}
#endif
}
void CC1101Component::power_down() {
@@ -393,7 +634,18 @@ void CC1101Component::enter_idle_() {
}
}
bool CC1101Component::enter_rx_() { return this->enter_calibrated_(State::RX, Command::RX); }
bool CC1101Component::enter_rx_() {
#ifdef USE_CC1101_LONG_PACKET
if (this->is_long_packet_mode_()) {
// Every RX entry starts a fresh long packet; callers leave the chip in IDLE, where SFRX is allowed
this->strobe_(Command::FRX);
this->reset_long_packet_rx_();
this->write_(Register::PKTLEN);
this->write_(Register::PKTCTRL0);
}
#endif
return this->enter_calibrated_(State::RX, Command::RX);
}
bool CC1101Component::enter_tx_() { return this->enter_calibrated_(State::TX, Command::TX); }
@@ -456,12 +708,22 @@ void CC1101Component::read_(Register reg, uint8_t *buffer, size_t length) {
CC1101Error CC1101Component::transmit_packet(const uint8_t *data, size_t len) {
if (this->state_.PKT_FORMAT != static_cast<uint8_t>(PacketFormat::PACKET_FORMAT_FIFO)) {
ESP_LOGW(TAG, "Cannot transmit packet: packet mode is not FIFO");
return CC1101Error::PARAMS;
}
#ifdef USE_CC1101_LONG_PACKET
// Long packet TX needs chunked FIFO refills and is not implemented
if (this->is_long_packet_mode_()) {
ESP_LOGW(TAG, "Cannot transmit packet: long packet mode is RX-only");
return CC1101Error::PARAMS;
}
#endif
const bool variable = this->state_.LENGTH_CONFIG == static_cast<uint8_t>(LengthConfig::LENGTH_CONFIG_VARIABLE);
// In variable length mode the FIFO also holds the length byte
if (len + (variable ? 1 : 0) > TX_FIFO_SIZE) {
ESP_LOGE(TAG, "Packet of %u bytes does not fit the TX FIFO", static_cast<unsigned>(len));
ESP_LOGW(TAG,
"Cannot transmit packet: long packet TX is not implemented, payload length %u exceeds TX FIFO limit %u",
static_cast<unsigned>(len), static_cast<unsigned>(TX_FIFO_SIZE));
return CC1101Error::PARAMS;
}
@@ -834,19 +1096,60 @@ void CC1101Component::set_bs_post_kp(BsPostKp value) {
}
}
void CC1101Component::set_packet_mode(bool value) {
this->state_.PKT_FORMAT =
static_cast<uint8_t>(value ? PacketFormat::PACKET_FORMAT_FIFO : PacketFormat::PACKET_FORMAT_ASYNC_SERIAL);
if (value) {
// Configure GDO0 for FIFO status (asserts on RX FIFO threshold or end of packet)
this->state_.GDO0_CFG = 0x01;
// Set max RX FIFO threshold to ensure we only trigger on end-of-packet
this->state_.FIFO_THR = 15;
// Don't append status bytes to FIFO - we read from registers instead
this->state_.APPEND_STATUS = 0;
} else {
// Configure GDO0 for serial data (async serial mode)
void CC1101Component::configure_packet_mode_() {
#ifdef USE_CC1101_LONG_PACKET
// Ends a long reception in progress, also when switching to a short packet mode
this->high_freq_.stop();
this->packet_.clear();
#endif
if (!this->packet_mode_) {
this->state_.PKT_FORMAT = static_cast<uint8_t>(PacketFormat::PACKET_FORMAT_ASYNC_SERIAL);
this->state_.GDO0_CFG = 0x0D;
} else {
this->state_.PKT_FORMAT = static_cast<uint8_t>(PacketFormat::PACKET_FORMAT_FIFO);
this->state_.APPEND_STATUS = 0;
#ifdef USE_CC1101_LONG_PACKET
if (this->is_long_packet_mode_()) {
// Threshold-only signal, reasserts after each partial FIFO drain
this->state_.GDO0_CFG = 0x00;
this->state_.FIFO_THR = 7;
// Reserve once so receiving never allocates; a lambda may read one FIFO drain past MAX_PACKET_LENGTH
this->packet_.reserve(this->packet_length_func_ != nullptr ? MAX_PACKET_LENGTH + RX_FIFO_SIZE
: this->packet_length_);
this->reset_long_packet_rx_();
} else
#endif
{
this->state_.GDO0_CFG = 0x01;
this->state_.FIFO_THR = 15;
if (this->packet_length_ == 0) {
this->state_.LENGTH_CONFIG = static_cast<uint8_t>(LengthConfig::LENGTH_CONFIG_VARIABLE);
} else {
this->state_.LENGTH_CONFIG = static_cast<uint8_t>(LengthConfig::LENGTH_CONFIG_FIXED);
this->state_.PKTLEN = static_cast<uint8_t>(this->packet_length_);
}
}
}
if (this->initialized_) {
this->write_(Register::PKTCTRL0);
this->write_(Register::PKTCTRL1);
this->write_(Register::PKTLEN);
this->write_(Register::IOCFG0);
this->write_(Register::FIFOTHR);
}
}
void CC1101Component::set_packet_mode(bool value) {
this->packet_mode_ = value;
#ifdef USE_CC1101_LONG_PACKET
// Long packet RX must drop the FIFO along with a partial packet, so go through IDLE and restart RX
if (this->initialized_ && this->is_long_packet_mode_()) {
this->reconfigure_packet_length_();
} else
#endif
{
this->configure_packet_mode_();
}
if (this->initialized_) {
if (this->gdo0_pin_ != nullptr) {
@@ -856,24 +1159,41 @@ void CC1101Component::set_packet_mode(bool value) {
this->gdo0_pin_->detach_interrupt();
}
}
this->write_(Register::PKTCTRL0);
this->write_(Register::PKTCTRL1);
this->write_(Register::IOCFG0);
this->write_(Register::FIFOTHR);
}
}
void CC1101Component::set_packet_length(uint8_t value) {
if (value == 0) {
this->state_.LENGTH_CONFIG = static_cast<uint8_t>(LengthConfig::LENGTH_CONFIG_VARIABLE);
} else {
this->state_.LENGTH_CONFIG = static_cast<uint8_t>(LengthConfig::LENGTH_CONFIG_FIXED);
this->state_.PKTLEN = value;
void CC1101Component::set_packet_length(uint16_t value) {
#ifndef USE_CC1101_LONG_PACKET
if (value > RX_FIFO_SIZE) {
ESP_LOGW(TAG, "Packet length %u needs a configured packet_length above %u", value,
static_cast<unsigned>(RX_FIFO_SIZE));
return;
}
if (this->initialized_) {
this->write_(Register::PKTCTRL0);
this->write_(Register::PKTLEN);
#else
this->packet_length_func_ = nullptr;
#endif
this->packet_length_ = value;
this->reconfigure_packet_length_();
}
#ifdef USE_CC1101_LONG_PACKET
void CC1101Component::set_packet_length_lambda(packet_length_func_t func) {
this->packet_length_func_ = func;
this->reconfigure_packet_length_();
}
#endif
void CC1101Component::reconfigure_packet_length_() {
// While asleep the writes wait for wake_up() and the radio stays asleep, like set_frequency()
if (!this->initialized_ || this->sleeping_) {
this->configure_packet_mode_();
return;
}
// Like the other runtime setters: go through IDLE, and flush bytes of a reception in progress
this->enter_idle_();
this->strobe_(Command::FRX);
this->configure_packet_mode_();
this->enter_rx_();
}
void CC1101Component::set_crc_enable(bool value) {
+33 -2
View File
@@ -2,6 +2,7 @@
#include "esphome/core/component.h"
#include "esphome/core/hal.h"
#include "esphome/core/helpers.h"
#include "esphome/components/spi/spi.h"
#include "esphome/core/automation.h"
#include "cc1101defs.h"
@@ -10,6 +11,7 @@
namespace esphome::cc1101 {
enum class CC1101Error { NONE = 0, TIMEOUT, PARAMS, CRC_ERROR, FIFO_OVERFLOW, PLL_LOCK };
using packet_length_func_t = int32_t (*)(const std::vector<uint8_t> &);
class CC1101Listener {
public:
@@ -86,7 +88,10 @@ class CC1101Component final : public Component,
// Packet mode settings
void set_packet_mode(bool value);
void set_packet_length(uint8_t value);
void set_packet_length(uint16_t value);
#ifdef USE_CC1101_LONG_PACKET
void set_packet_length_lambda(packet_length_func_t func);
#endif
void set_crc_enable(bool value);
void set_whitening(bool value);
@@ -101,6 +106,7 @@ class CC1101Component final : public Component,
protected:
uint16_t chip_id_{0};
bool initialized_{false};
bool packet_mode_{false};
bool sleeping_{false};
bool registers_dirty_{false};
@@ -112,13 +118,38 @@ class CC1101Component final : public Component,
// GDO pin for packet reception
InternalGPIOPin *gdo0_pin_{nullptr};
static void gpio_intr(CC1101Component *arg);
// Inline like App.get_loop_component_start_time(): on RP2040 an out-of-line IRAM_ATTR function in the same
// file as that inline one fails with a section type conflict
static void IRAM_ATTR gpio_intr(CC1101Component *arg) { arg->enable_loop_soon_any_context(); }
// Packet handling
void call_listeners_(const std::vector<uint8_t> &packet, float freq_offset, float rssi, uint8_t lqi);
void configure_packet_mode_();
void reconfigure_packet_length_();
float symbol_rate_() const;
#ifdef USE_CC1101_LONG_PACKET
bool is_long_packet_mode_() const;
void arm_length_(uint16_t length);
void reset_long_packet_rx_();
void restart_long_packet_rx_();
void loop_long_packet_();
void handle_long_packet_(uint8_t rx_bytes);
void finish_long_packet_();
void maybe_switch_long_packet_to_fixed_();
#endif
Trigger<std::vector<uint8_t>, float, float, uint8_t> packet_trigger_;
std::vector<uint8_t> packet_;
std::vector<CC1101Listener *> listeners_;
#ifdef USE_CC1101_LONG_PACKET
packet_length_func_t packet_length_func_{nullptr};
uint32_t packet_last_byte_ms_{0};
#endif
uint16_t packet_length_{0};
#ifdef USE_CC1101_LONG_PACKET
uint16_t packet_expected_length_{0};
int8_t long_packet_rssi_{0}; // raw RSSI register
HighFrequencyLoopRequester high_freq_;
#endif
// Low-level Helpers
uint8_t strobe_(Command cmd);
+5
View File
@@ -15,6 +15,11 @@ static constexpr uint8_t PLL_LOCK_RETRIES = 3;
static constexpr uint8_t STATUS_CRC_OK_MASK = 0x80;
static constexpr uint8_t STATUS_LQI_MASK = 0x7F;
static constexpr uint16_t MAX_PACKET_LENGTH = 1024;
static constexpr uint16_t PACKET_IDLE_TIMEOUT_BYTES = 64;
static constexpr uint32_t PACKET_IDLE_TIMEOUT_MIN_MS = 5;
static constexpr uint8_t RXBYTES_STABLE_RETRIES = 4;
static constexpr uint8_t BUS_BURST = 0x40;
static constexpr uint8_t BUS_READ = 0x80;
static constexpr uint8_t BUS_WRITE = 0x00;
+2 -2
View File
@@ -1,6 +1,7 @@
#include "cse7761.h"
#include "esphome/core/log.h"
#include "esphome/core/helpers.h"
namespace esphome::cse7761 {
@@ -104,8 +105,7 @@ void CSE7761Component::write_(uint8_t reg, uint16_t data) {
buffer[2] = data & 0xFF;
len = 3;
} else {
buffer[2] = (data >> 8) & 0xFF;
buffer[3] = data & 0xFF;
put_be16(buffer + 2, data);
len = 4;
}
buffer[len] = ~sum_bytes(buffer, len);
@@ -1,36 +1,15 @@
from esphome import pins
import esphome.codegen as cg
from esphome.components import i2c, touchscreen
import esphome.config_validation as cv
from esphome.const import CONF_ID, CONF_INTERRUPT_PIN, CONF_RESET_PIN
from esphome.components import cstxxx
from esphome.types import ConfigType
from .. import cst226_ns
CST226Touchscreen = cst226_ns.class_(
"CST226Touchscreen",
touchscreen.Touchscreen,
i2c.I2CDevice,
)
AUTO_LOAD = ["cstxxx"]
CST226Touchscreen = cst226_ns.class_("CST226Touchscreen", cstxxx.CSTTouchscreen)
CST226ButtonListener = cst226_ns.class_("CST226ButtonListener")
CONFIG_SCHEMA = (
touchscreen.touchscreen_schema("100ms")
.extend(
{
cv.GenerateID(): cv.declare_id(CST226Touchscreen),
cv.Optional(CONF_INTERRUPT_PIN): pins.internal_gpio_input_pin_schema,
cv.Optional(CONF_RESET_PIN): pins.gpio_output_pin_schema,
}
)
.extend(i2c.i2c_device_schema(0x5A))
)
CONFIG_SCHEMA = cstxxx.cst_touchscreen_schema(CST226Touchscreen, 0x5A)
async def to_code(config: ConfigType) -> None:
var = cg.new_Pvariable(config[CONF_ID])
await touchscreen.register_touchscreen(var, config)
await i2c.register_i2c_device(var, config)
await cg.add_pin(var.set_interrupt_pin, config.get(CONF_INTERRUPT_PIN))
await cg.add_pin(var.set_reset_pin, config.get(CONF_RESET_PIN))
await cstxxx.new_cst_touchscreen(config)
@@ -14,6 +14,10 @@ void CST226Touchscreen::setup() {
}
void CST226Touchscreen::update_touches() {
if (!this->setup_complete_) {
this->skip_update_ = true;
return;
}
uint8_t data[28];
if (!this->status_comm_result(this->read_bytes(CST226_REG_STATUS, data, sizeof data))) {
this->skip_update_ = true;
@@ -24,56 +28,39 @@ void CST226Touchscreen::update_touches() {
return;
}
this->update_button_state_(false);
if (data[6] != 0xAB || data[0] == 0xAB || data[5] == 0x80) {
if (data[cstxxx::SYNC_IDX] != cstxxx::SYNC_BYTE || data[0] == cstxxx::SYNC_BYTE ||
data[cstxxx::FINGER_COUNT_IDX] == 0x80) {
this->skip_update_ = true;
return;
}
uint8_t num_of_touches = data[5] & 0x7F;
uint8_t num_of_touches = data[cstxxx::FINGER_COUNT_IDX] & 0x7F;
if (num_of_touches == 0 || num_of_touches > 5) {
this->write_byte(0, 0xAB);
this->write_byte(CST226_REG_STATUS, cstxxx::SYNC_BYTE);
return;
}
size_t index = 0;
for (uint8_t i = 0; i != num_of_touches; i++) {
uint8_t id = data[index] >> 4;
int16_t x = (data[index + 1] << 4) | ((data[index + 3] >> 4) & 0x0F);
int16_t y = (data[index + 2] << 4) | (data[index + 3] & 0x0F);
int16_t z = data[index + 4];
this->add_raw_touch_position_(id, x, y, z);
ESP_LOGV(TAG, "Read touch %d: %d/%d", id, x, y);
index += 5;
if (i == 0)
index += 2;
auto touch = cstxxx::decode_touch(data, i);
this->add_raw_touch_position_(touch.id, touch.x, touch.y, touch.z);
ESP_LOGV(TAG, "Read touch %d: %d/%d", touch.id, touch.x, touch.y);
}
}
bool CST226Touchscreen::read16_(uint16_t addr, uint8_t *data, size_t len) {
if (this->read_register16(addr, data, len) != i2c::ERROR_OK) {
ESP_LOGE(TAG, "Read data from 0x%04X failed", addr);
this->mark_failed();
return false;
}
return true;
}
void CST226Touchscreen::continue_setup_() {
uint8_t buffer[8];
if (this->interrupt_pin_ != nullptr) {
this->interrupt_pin_->setup();
this->attach_interrupt_(this->interrupt_pin_, gpio::INTERRUPT_FALLING_EDGE);
}
if (!this->setup_check(this->write_byte_reg16(0xD1, 0xD1), LOG_STR("Write byte to 0xD1 failed")))
this->setup_interrupt_pin_(gpio::INTERRUPT_FALLING_EDGE);
if (!this->enter_command_mode_())
return;
delay(10);
if (this->read16_(0xD204, buffer, 4)) {
uint16_t chip_id = buffer[2] + (buffer[3] << 8);
uint16_t project_id = buffer[0] + (buffer[1] << 8);
ESP_LOGCONFIG(TAG, "Chip ID %X, project ID %x", chip_id, project_id);
}
if (!this->check_firmware_())
return;
if (!this->setup_check(this->read_words_(cstxxx::REG_CHIP_INFO, this->project_id_, this->chip_id_),
LOG_STR("Failed to read chip ID")))
return;
if (this->x_raw_max_ == 0 || this->y_raw_max_ == 0) {
if (this->read16_(0xD1F8, buffer, 4)) {
this->x_raw_max_ = buffer[0] + (buffer[1] << 8);
this->y_raw_max_ = buffer[2] + (buffer[3] << 8);
uint16_t x_max, y_max;
if (this->read_words_(cstxxx::REG_RESOLUTION, x_max, y_max)) {
this->x_raw_max_ = x_max;
this->y_raw_max_ = y_max;
if (this->swap_x_y_)
std::swap(this->x_raw_max_, this->y_raw_max_);
} else {
@@ -81,8 +68,10 @@ void CST226Touchscreen::continue_setup_() {
this->y_raw_max_ = this->display_->get_native_height();
}
}
this->status_comm_check(this->write_register16(cstxxx::REG_NORMAL_MODE, nullptr, 0) == i2c::ERROR_OK);
this->setup_complete_ = true;
}
void CST226Touchscreen::update_button_state_(bool state) {
if (this->button_touched_ == state)
return;
@@ -96,6 +85,10 @@ void CST226Touchscreen::dump_config() {
LOG_I2C_DEVICE(this);
LOG_PIN(" Interrupt Pin: ", this->interrupt_pin_);
LOG_PIN(" Reset Pin: ", this->reset_pin_);
ESP_LOGCONFIG(TAG,
" Chip ID: 0x%04X, Project ID: 0x%04X\n"
" X/Y raw max: %d/%d",
this->chip_id_, this->project_id_, this->x_raw_max_, this->y_raw_max_);
}
} // namespace esphome::cst226
@@ -1,11 +1,12 @@
#pragma once
#include "esphome/components/i2c/i2c.h"
#include "esphome/components/touchscreen/touchscreen.h"
#include "esphome/components/cstxxx/cstxxx.h"
#include "esphome/core/component.h"
#include "esphome/core/hal.h"
#include "esphome/core/log.h"
#include <vector>
namespace esphome::cst226 {
static const uint8_t CST226_REG_STATUS = 0x00;
@@ -15,28 +16,23 @@ class CST226ButtonListener {
virtual void update_button(bool state) = 0;
};
class CST226Touchscreen final : public touchscreen::Touchscreen, public i2c::I2CDevice {
class CST226Touchscreen final : public cstxxx::CSTTouchscreen {
public:
void setup() override;
void update_touches() override;
void dump_config() override;
void set_interrupt_pin(InternalGPIOPin *pin) { this->interrupt_pin_ = pin; }
void set_reset_pin(GPIOPin *pin) { this->reset_pin_ = pin; }
bool can_proceed() override { return this->setup_complete_ || this->is_failed(); }
void register_button_listener(CST226ButtonListener *listener) { this->button_listeners_.push_back(listener); }
protected:
bool read16_(uint16_t addr, uint8_t *data, size_t len);
void continue_setup_();
void update_button_state_(bool state);
InternalGPIOPin *interrupt_pin_{};
GPIOPin *reset_pin_{};
uint8_t chip_id_{};
bool setup_complete_{};
std::vector<CST226ButtonListener *> button_listeners_;
bool button_touched_{};
uint16_t chip_id_{};
uint16_t project_id_{};
std::vector<CST226ButtonListener *> button_listeners_;
};
} // namespace esphome::cst226
+7
View File
@@ -0,0 +1,7 @@
import esphome.codegen as cg
CODEOWNERS = ["@tpruvot"]
DEPENDENCIES = ["i2c"]
DOMAIN = "cst3240"
cst3240_ns = cg.esphome_ns.namespace("cst3240")
@@ -0,0 +1,14 @@
from esphome.components import cstxxx
from esphome.types import ConfigType
from .. import cst3240_ns
AUTO_LOAD = ["cstxxx"]
CST3240Touchscreen = cst3240_ns.class_("CST3240Touchscreen", cstxxx.CSTTouchscreen)
CONFIG_SCHEMA = cstxxx.cst_touchscreen_schema(CST3240Touchscreen, 0x5A)
async def to_code(config: ConfigType) -> None:
await cstxxx.new_cst_touchscreen(config)
@@ -0,0 +1,112 @@
#include "cst3240_touchscreen.h"
#include "esphome/core/helpers.h"
#include "esphome/core/log.h"
#include <utility>
namespace esphome::cst3240 {
ESPHOME_LOG_TAG(TAG, "cst3240.touchscreen");
void CST3240Touchscreen::setup() {
if (this->reset_pin_ == nullptr) {
this->continue_setup_();
return;
}
pulse_reset(this->reset_pin_, {.high_before_ms = 5, .low_ms = 5});
this->set_timeout(30, [this] { this->continue_setup_(); });
}
void CST3240Touchscreen::continue_setup_() {
if (!this->enter_command_mode_())
return;
if (!this->setup_check(this->read_words_(cstxxx::REG_CHIP_INFO, this->project_id_, this->chip_id_),
LOG_STR("Failed to read chip ID")))
return;
// Only warn: the chip ID has not been confirmed on enough boards to fail setup on it
if (this->chip_id_ != CST3240_CHIP_ID) {
ESP_LOGW(TAG, "Unexpected chip ID 0x%04X", this->chip_id_);
}
this->read_words_(cstxxx::REG_FW_VERSION, this->fw_build_, this->fw_version_);
if (this->x_raw_max_ == this->x_raw_min_ || this->y_raw_max_ == this->y_raw_min_) {
uint16_t x_max, y_max;
if (this->read_words_(cstxxx::REG_RESOLUTION, x_max, y_max)) {
this->x_raw_max_ = x_max;
this->y_raw_max_ = y_max;
if (this->swap_x_y_)
std::swap(this->x_raw_max_, this->y_raw_max_);
} else {
this->x_raw_max_ = this->display_->get_native_width();
this->y_raw_max_ = this->display_->get_native_height();
}
}
this->status_comm_check(this->write_register16(cstxxx::REG_NORMAL_MODE, nullptr, 0) == i2c::ERROR_OK);
this->setup_interrupt_pin_(gpio::INTERRUPT_RISING_EDGE);
this->setup_complete_ = true;
}
void CST3240Touchscreen::update_touches() {
if (!this->setup_complete_) {
this->skip_update_ = true;
return;
}
uint8_t data[CST3240_REPORT_SIZE];
if (!this->status_comm_result(this->read_register16(cstxxx::REG_TOUCH_DATA, data, sizeof(data)) == i2c::ERROR_OK)) {
this->skip_update_ = true;
return;
}
const uint8_t sync = data[cstxxx::SYNC_IDX];
if (sync != cstxxx::SYNC_BYTE) {
this->skip_update_ = true;
if (sync != 0) {
ESP_LOGV(TAG, "Skipping report, sync byte 0x%02X", sync);
this->clear_report_();
}
return;
}
const uint8_t count = data[cstxxx::FINGER_COUNT_IDX] & 0x0F;
if (count <= CST3240_MAX_TOUCHES) {
for (uint8_t i = 0; i < count; i++) {
auto touch = cstxxx::decode_touch(data, i);
// A released finger is still listed once, with both press bits clear
if ((touch.event & TOUCH_EVENT_PRESSED) == 0)
continue;
this->add_raw_touch_position_(touch.id, touch.x, touch.y, touch.z);
}
}
if (this->interrupt_pin_ == nullptr) {
this->clear_report_();
} else if (!this->write_byte_reg16(cstxxx::REG_FINGER_COUNT, 0) ||
!this->write_byte_reg16(cstxxx::REG_TOUCH_DATA, cstxxx::SYNC_BYTE)) {
ESP_LOGW(TAG, "Failed to acknowledge the report");
}
}
void CST3240Touchscreen::clear_report_() {
// Built on the stack: write_register16() heap allocates a frame this long
uint8_t frame[2 + CST3240_REPORT_SIZE]{};
put_be16(frame, cstxxx::REG_TOUCH_DATA);
if (this->write(frame, sizeof(frame)) != i2c::ERROR_OK) {
ESP_LOGW(TAG, "Failed to clear the report");
}
}
void CST3240Touchscreen::dump_config() {
ESP_LOGCONFIG(TAG,
"CST3240 Touchscreen:\n"
" Chip ID: 0x%04X, Project ID: 0x%04X\n"
" FW version: %d.%d.%d\n"
" X/Y resolution: %d/%d",
this->chip_id_, this->project_id_, this->fw_version_ >> 8, this->fw_version_ & 0xFF, this->fw_build_,
this->x_raw_max_, this->y_raw_max_);
LOG_I2C_DEVICE(this);
LOG_PIN(" Interrupt Pin: ", this->interrupt_pin_);
LOG_PIN(" Reset Pin: ", this->reset_pin_);
}
} // namespace esphome::cst3240
@@ -0,0 +1,31 @@
#pragma once
#include "esphome/components/cstxxx/cstxxx.h"
#include "esphome/core/component.h"
#include "esphome/core/hal.h"
namespace esphome::cst3240 {
static constexpr uint16_t CST3240_CHIP_ID = 0x3240;
static constexpr uint8_t CST3240_MAX_TOUCHES = 5;
static constexpr uint8_t CST3240_REPORT_SIZE = cstxxx::report_size(CST3240_MAX_TOUCHES);
static constexpr uint8_t TOUCH_EVENT_PRESSED = 0x06;
class CST3240Touchscreen : public cstxxx::CSTTouchscreen {
public:
void setup() override;
void dump_config() override;
protected:
void update_touches() override;
void continue_setup_();
/// Zeroes the touch report block, which polling relies on to tell new reports from old.
void clear_report_();
uint16_t chip_id_{};
uint16_t project_id_{};
uint16_t fw_version_{};
uint16_t fw_build_{};
};
} // namespace esphome::cst3240
@@ -1,37 +1,15 @@
from esphome import pins
import esphome.codegen as cg
from esphome.components import i2c, touchscreen
import esphome.config_validation as cv
from esphome.const import CONF_ID, CONF_INTERRUPT_PIN, CONF_RESET_PIN
from esphome.components import cstxxx
from esphome.types import ConfigType
from .. import cst328_ns
CST328Touchscreen = cst328_ns.class_(
"CST328Touchscreen",
touchscreen.Touchscreen,
i2c.I2CDevice,
)
AUTO_LOAD = ["cstxxx"]
CST328Touchscreen = cst328_ns.class_("CST328Touchscreen", cstxxx.CSTTouchscreen)
CST328ButtonListener = cst328_ns.class_("CST328ButtonListener")
CONFIG_SCHEMA = (
touchscreen.touchscreen_schema("100ms")
.extend(
{
cv.GenerateID(): cv.declare_id(CST328Touchscreen),
cv.Optional(CONF_INTERRUPT_PIN): pins.internal_gpio_input_pin_schema,
cv.Optional(CONF_RESET_PIN): pins.gpio_output_pin_schema,
}
)
.extend(i2c.i2c_device_schema(0x1A))
)
CONFIG_SCHEMA = cstxxx.cst_touchscreen_schema(CST328Touchscreen, 0x1A)
async def to_code(config: ConfigType) -> None:
var = cg.new_Pvariable(config[CONF_ID])
await touchscreen.register_touchscreen(var, config)
await i2c.register_i2c_device(var, config)
await cg.add_pin(var.set_interrupt_pin, config.get(CONF_INTERRUPT_PIN))
await cg.add_pin(var.set_reset_pin, config.get(CONF_RESET_PIN))
await cstxxx.new_cst_touchscreen(config)
@@ -5,31 +5,8 @@ namespace esphome::cst328 {
ESPHOME_LOG_TAG(TAG, "cst328.touchscreen");
static const uint32_t CST328_BEFORE_RESET_TIMEOUT = 50; // 50 ms from datasheet
static const uint32_t CST328_TRANSITION_TIMEOUT = 300; // 200 ms from datasheet, but typically much less
static const uint16_t CST328_FW_CRC = 0xCACA; // Expected firmware CRC value
static const uint8_t CST328_SYNC_BYTE = 0xAB; // Sync byte used in communication
static const uint8_t ZERO_BYTE = 0;
#define I2C_WARN_ON_ERROR(x, log_tag, format, ...) \
do { \
i2c::ErrorCode err_rc_ = (x); \
if (err_rc_ != i2c::ERROR_OK) { \
ESP_LOGW(log_tag, "%s(%d): [error %d] " format, __FUNCTION__, __LINE__, err_rc_, ##__VA_ARGS__); \
this->status_set_warning(format); \
} \
} while (0)
#define I2C_FAIL_ON_ERROR(x, log_tag, format, ...) \
do { \
i2c::ErrorCode err_rc_ = (x); \
if (err_rc_ != i2c::ERROR_OK) { \
ESP_LOGE(log_tag, "%s(%d): [error %d] " format, __FUNCTION__, __LINE__, err_rc_, ##__VA_ARGS__); \
this->mark_failed(); \
return; \
} \
} while (0)
static constexpr uint32_t CST328_BEFORE_RESET_TIMEOUT = 50; // 50 ms from datasheet
static constexpr uint32_t CST328_TRANSITION_TIMEOUT = 300; // 200 ms from datasheet, but typically much less
void CST328Touchscreen::setup() {
ESP_LOGCONFIG(TAG, "Setting up CST328 Touchscreen...");
@@ -50,50 +27,36 @@ void CST328Touchscreen::reset_device_() {
void CST328Touchscreen::continue_setup_() {
ESP_LOGV(TAG, "Continuing CST328 setup...");
uint8_t data_byte{0};
uint8_t buf[24]{};
I2C_FAIL_ON_ERROR(this->write_register16(CST_WM_DEBUG_INFO, buf, 0), TAG, "Failed to enter debug/info mode");
I2C_FAIL_ON_ERROR(this->read_register16(CST_REG_FW_CRC_AND_BOOT_TIME, buf, 4), TAG,
"Failed to read FW CRC and boot time");
uint16_t fw_crc = buf[2] + (buf[3] << 8);
if (fw_crc != CST328_FW_CRC) {
ESP_LOGE(TAG, "Error: Firmware CRC mismatch, expected 0x%04X but got 0x%04X", CST328_FW_CRC, fw_crc);
this->mark_failed();
if (!this->enter_command_mode_() || !this->check_firmware_())
return;
if (!this->setup_check(this->read_words_(cstxxx::REG_CHIP_INFO, this->project_id_, this->chip_id_),
LOG_STR("Failed to read chip and project ID")))
return;
}
I2C_FAIL_ON_ERROR(this->read_register16(CST_REG_CHIP_TYPE_AND_PROJECT_ID, buf, 4), TAG,
"Failed to read chip and project ID");
this->chip_id_ = buf[2] + (buf[3] << 8);
this->project_id_ = buf[0] + (buf[1] << 8);
ESP_LOGD(TAG, "Chip ID %X, project ID %X", this->chip_id_, this->project_id_);
I2C_FAIL_ON_ERROR(this->read_register16(CST_REG_FW_REVISION, buf, 4), TAG, "Failed to read FW version");
this->fw_ver_major_ = buf[3];
this->fw_ver_minor_ = buf[2];
this->fw_build_ = buf[0] + (buf[1] << 8);
uint16_t fw_version;
if (!this->setup_check(this->read_words_(cstxxx::REG_FW_VERSION, this->fw_build_, fw_version),
LOG_STR("Failed to read FW version")))
return;
this->fw_ver_major_ = fw_version >> 8;
this->fw_ver_minor_ = fw_version & 0xFF;
ESP_LOGV(TAG, "FW version %d.%d.%d", this->fw_ver_major_, this->fw_ver_minor_, this->fw_build_);
if (i2c::ERROR_OK == this->read_register16(CST_REG_X_Y_RESOLUTION, buf, 4)) {
this->x_raw_max_ = buf[0] + (buf[1] << 8);
this->y_raw_max_ = buf[2] + (buf[3] << 8);
uint16_t x_max, y_max;
if (this->read_words_(cstxxx::REG_RESOLUTION, x_max, y_max)) {
this->x_raw_max_ = x_max;
this->y_raw_max_ = y_max;
} else {
this->x_raw_max_ = this->display_->get_native_width();
this->y_raw_max_ = this->display_->get_native_height();
}
I2C_WARN_ON_ERROR(this->write_register16(CST_WM_NORMAL, buf, 0), TAG, "Failed to enter normal mode");
I2C_WARN_ON_ERROR(this->read_register16(CST_REG_TOUCH_INFORMATION, &data_byte, 1), TAG, "Failed to read sync");
I2C_WARN_ON_ERROR(this->write_register16(CST_REG_TOUCH_INFORMATION, &CST328_SYNC_BYTE, 1), TAG,
"Failed to write sync");
uint8_t sync;
bool ok = this->write_register16(cstxxx::REG_NORMAL_MODE, nullptr, 0) == i2c::ERROR_OK;
ok &= this->read_byte_reg16(cstxxx::REG_TOUCH_DATA, &sync);
ok &= this->write_byte_reg16(cstxxx::REG_TOUCH_DATA, cstxxx::SYNC_BYTE);
this->status_comm_check(ok);
if (this->interrupt_pin_ != nullptr) {
this->interrupt_pin_->setup();
this->attach_interrupt_(this->interrupt_pin_, gpio::INTERRUPT_FALLING_EDGE);
}
this->setup_interrupt_pin_(gpio::INTERRUPT_FALLING_EDGE);
this->setup_complete_ = true;
ESP_LOGV(TAG, "CST328 setup complete");
@@ -142,21 +105,15 @@ void CST328Touchscreen::update_touches() {
} else {
this->update_button_state_(true);
uint8_t data_idx = 0;
for (uint8_t i = 0; i < touch_cnt; i++) {
uint8_t id = touch_data[data_idx] >> 4;
int16_t x = (touch_data[data_idx + 1] << 4) | ((touch_data[data_idx + 3] >> 4) & 0x0F);
int16_t y = (touch_data[data_idx + 2] << 4) | (touch_data[data_idx + 3] & 0x0F);
int16_t z = touch_data[data_idx + 4];
this->add_raw_touch_position_(id, x, y, z);
data_idx += (i == 0) ? 7 : 5;
auto touch = cstxxx::decode_touch(touch_data, i);
this->add_raw_touch_position_(touch.id, touch.x, touch.y, touch.z);
}
}
bool cleanup_error = false;
cleanup_error |= !this->write_byte_reg16(CST_REG_TOUCH_FINGER_NUMBER, ZERO_BYTE);
cleanup_error |= !this->write_byte_reg16(CST_REG_TOUCH_INFORMATION, CST328_SYNC_BYTE);
cleanup_error |= !this->write_byte_reg16(cstxxx::REG_FINGER_COUNT, 0);
cleanup_error |= !this->write_byte_reg16(cstxxx::REG_TOUCH_DATA, cstxxx::SYNC_BYTE);
if (cleanup_error) {
ESP_LOGW(TAG, "Failed to clean up touch registers");
@@ -1,61 +1,45 @@
#pragma once
#include "esphome/components/i2c/i2c.h"
#include "esphome/components/touchscreen/touchscreen.h"
#include "esphome/components/cstxxx/cstxxx.h"
#include "esphome/core/component.h"
#include "esphome/core/hal.h"
#include <vector>
namespace esphome::cst328 {
static const uint8_t CST328_TOUCH_MAX_POINTS = 5;
static const uint8_t CST328_TOUCH_DATA_SIZE = CST328_TOUCH_MAX_POINTS * 5 + 2;
static constexpr uint8_t CST328_TOUCH_MAX_POINTS = 5;
static constexpr uint8_t CST328_TOUCH_DATA_SIZE = cstxxx::report_size(CST328_TOUCH_MAX_POINTS);
static const uint16_t CST_REG_TOUCH_INFORMATION = 0xD000;
static const uint16_t CST_REG_TOUCH_FINGER_NUMBER = 0xD005;
static const uint16_t CST_REG_FINGER_COUNT_IDX = CST_REG_TOUCH_FINGER_NUMBER - CST_REG_TOUCH_INFORMATION;
static const uint16_t CST_REG_X_Y_RESOLUTION = 0xD1F8;
static const uint16_t CST_REG_FW_CRC_AND_BOOT_TIME = 0xD1FC;
static const uint16_t CST_REG_CHIP_TYPE_AND_PROJECT_ID = 0xD204;
static const uint16_t CST_REG_FW_REVISION = 0xD208;
static const uint16_t CST_WM_DEBUG_INFO = 0xD101;
static const uint16_t CST_WM_NORMAL = 0xD109;
static constexpr uint16_t CST_REG_TOUCH_INFORMATION = cstxxx::REG_TOUCH_DATA;
static constexpr uint16_t CST_REG_FINGER_COUNT_IDX = cstxxx::FINGER_COUNT_IDX;
static constexpr uint16_t CST_REG_X_Y_RESOLUTION = cstxxx::REG_RESOLUTION;
static constexpr uint16_t CST_REG_FW_CRC_AND_BOOT_TIME = cstxxx::REG_FW_CHECK_CODE;
class CST328ButtonListener {
public:
virtual void update_button(bool state) = 0;
};
class CST328Touchscreen : public touchscreen::Touchscreen, public i2c::I2CDevice {
class CST328Touchscreen : public cstxxx::CSTTouchscreen {
public:
void setup() override;
void register_button_listener(CST328ButtonListener *listener) { this->button_listeners_.push_back(listener); }
void dump_config() override;
void set_interrupt_pin(InternalGPIOPin *pin) { this->interrupt_pin_ = pin; }
void set_reset_pin(GPIOPin *pin) { this->reset_pin_ = pin; }
protected:
void update_touches() override;
void reset_device_();
void continue_setup_();
void update_button_state_(bool state);
InternalGPIOPin *interrupt_pin_{};
GPIOPin *reset_pin_{};
std::vector<CST328ButtonListener *> button_listeners_;
bool button_touched_{};
uint16_t chip_id_{};
uint16_t project_id_{};
uint8_t fw_ver_major_{};
uint8_t fw_ver_minor_{};
std::vector<CST328ButtonListener *> button_listeners_;
uint16_t chip_id_{};
uint16_t project_id_{};
uint16_t fw_build_{};
bool setup_complete_{};
};
} // namespace esphome::cst328
@@ -1,35 +1,14 @@
from esphome import pins
import esphome.codegen as cg
from esphome.components import i2c, touchscreen
import esphome.config_validation as cv
from esphome.const import CONF_ID, CONF_INTERRUPT_PIN, CONF_RESET_PIN
from esphome.components import cstxxx
from esphome.types import ConfigType
from .. import cst9220_ns
CST9220Touchscreen = cst9220_ns.class_(
"CST9220Touchscreen",
touchscreen.Touchscreen,
i2c.I2CDevice,
)
AUTO_LOAD = ["cstxxx"]
CONFIG_SCHEMA = (
touchscreen.touchscreen_schema("100ms")
.extend(
{
cv.GenerateID(): cv.declare_id(CST9220Touchscreen),
cv.Optional(CONF_INTERRUPT_PIN): pins.internal_gpio_input_pin_schema,
cv.Optional(CONF_RESET_PIN): pins.gpio_output_pin_schema,
}
)
.extend(i2c.i2c_device_schema(0x5A))
)
CST9220Touchscreen = cst9220_ns.class_("CST9220Touchscreen", cstxxx.CSTTouchscreen)
CONFIG_SCHEMA = cstxxx.cst_touchscreen_schema(CST9220Touchscreen, 0x5A)
async def to_code(config: ConfigType) -> None:
var = cg.new_Pvariable(config[CONF_ID])
await touchscreen.register_touchscreen(var, config)
await i2c.register_i2c_device(var, config)
await cg.add_pin(var.set_interrupt_pin, config.get(CONF_INTERRUPT_PIN))
await cg.add_pin(var.set_reset_pin, config.get(CONF_RESET_PIN))
await cstxxx.new_cst_touchscreen(config)
@@ -1,7 +1,4 @@
#include "cst9220_touchscreen.h"
#include "esphome/core/helpers.h"
#include <cinttypes>
namespace esphome::cst9220 {
@@ -16,55 +13,29 @@ void CST9220Touchscreen::setup() {
}
void CST9220Touchscreen::continue_setup_() {
uint8_t buffer[4];
this->setup_interrupt_pin_(gpio::INTERRUPT_FALLING_EDGE);
if (this->interrupt_pin_ != nullptr) {
this->interrupt_pin_->setup();
this->attach_interrupt_(this->interrupt_pin_, gpio::INTERRUPT_FALLING_EDGE);
}
// Enter command mode so the configuration registers can be read.
if (this->write_register16(REG_CMD_MODE, buffer, 0) != i2c::ERROR_OK) {
this->status_set_error(LOG_STR("Failed to enter command mode"));
this->mark_failed();
if (!this->enter_command_mode_())
return;
}
delay(10);
// The firmware check code confirms that valid firmware is loaded.
if (this->read_register16(REG_CHECKCODE, buffer, 4) != i2c::ERROR_OK) {
this->status_set_error(LOG_STR("Failed to read check code"));
this->mark_failed();
if (!this->check_firmware_())
return;
}
uint32_t checkcode = encode_uint32(buffer[3], buffer[2], buffer[1], buffer[0]);
if ((checkcode & 0xFFFF0000) != 0xCACA0000) {
ESP_LOGE(TAG, "Invalid firmware check code: 0x%08" PRIX32, checkcode);
this->status_set_error(LOG_STR("Invalid firmware check code"));
this->mark_failed();
return;
}
// Read the panel resolution unless the user supplied calibration values.
if (this->read_register16(REG_RESOLUTION, buffer, 4) == i2c::ERROR_OK) {
uint16_t x_max, y_max;
if (this->read_words_(cstxxx::REG_RESOLUTION, x_max, y_max)) {
if (this->x_raw_max_ == this->x_raw_min_)
this->x_raw_max_ = encode_value_le<uint16_t>(buffer);
this->x_raw_max_ = x_max;
if (this->y_raw_max_ == this->y_raw_min_)
this->y_raw_max_ = encode_value_le<uint16_t>(&buffer[2]);
this->y_raw_max_ = y_max;
}
// Read the chip type and project id and validate the controller.
if (this->read_register16(REG_CHIP_INFO, buffer, 4) != i2c::ERROR_OK) {
this->status_set_error(LOG_STR("Failed to read chip ID"));
this->mark_failed();
if (!this->setup_check(this->read_words_(cstxxx::REG_CHIP_INFO, this->project_id_, this->chip_id_),
LOG_STR("Failed to read chip ID")))
return;
}
this->chip_id_ = encode_value_le<uint16_t>(&buffer[2]);
this->project_id_ = encode_value_le<uint16_t>(buffer);
if (this->chip_id_ != CST9220_CHIP_ID && this->chip_id_ != CST9217_CHIP_ID) {
ESP_LOGE(TAG, "Unknown chip ID: 0x%04X", this->chip_id_);
this->status_set_error(LOG_STR("Unknown chip ID"));
this->mark_failed();
this->mark_failed(LOG_STR("Unknown chip ID"));
return;
}
@@ -84,7 +55,7 @@ void CST9220Touchscreen::update_touches() {
// Only an actual I2C failure should skip the update; a successful read with no
// touches is a real "all fingers lifted" state that must flow through so the
// base class can generate the release event.
if (!this->status_comm_result(this->read_register16(REG_TOUCH_DATA, data, sizeof(data)) == i2c::ERROR_OK)) {
if (!this->status_comm_result(this->read_register16(cstxxx::REG_TOUCH_DATA, data, sizeof(data)) == i2c::ERROR_OK)) {
this->skip_update_ = true;
return;
}
@@ -92,30 +63,23 @@ void CST9220Touchscreen::update_touches() {
// A valid report carries the marker at offset 6. Writing an acknowledge back makes the controller return
// invalid frames during a long press, so none is written. An invalid frame keeps the previous points; while
// a finger is down, read again shortly so a lost release frame does not leave the touch held.
if (data[6] != TOUCH_ACK) {
if (data[cstxxx::SYNC_IDX] != cstxxx::SYNC_BYTE) {
this->skip_update_ = true;
if (!this->touches_.empty())
this->set_timeout(REREAD_TIMEOUT_ID, REREAD_DELAY_MS, [this] { this->store_.touched = true; });
return;
}
uint8_t num_touches = data[5] & 0x7F;
uint8_t num_touches = data[cstxxx::FINGER_COUNT_IDX] & 0x7F;
if (num_touches > CST9220_MAX_TOUCHES)
num_touches = CST9220_MAX_TOUCHES;
for (uint8_t i = 0; i < num_touches; i++) {
// The first point starts at offset 0; subsequent points are offset by the
// two status bytes that follow it.
const uint8_t *p = data + i * 5 + (i == 0 ? 0 : 2);
uint8_t id = p[0] >> 4;
uint8_t event = p[0] & 0x0F;
if (event != TOUCH_EVENT_DOWN)
auto touch = cstxxx::decode_touch(data, i);
if (touch.event != TOUCH_EVENT_DOWN)
continue;
// p[3] is shared: high nibble holds the X LSBs, low nibble the Y LSBs.
uint16_t x = (p[1] << 4) | (p[3] >> 4);
uint16_t y = (p[2] << 4) | (p[3] & 0x0F);
ESP_LOGV(TAG, "Read touch %d: %d/%d", id, x, y);
this->add_raw_touch_position_(id, x, y);
ESP_LOGV(TAG, "Read touch %d: %d/%d", touch.id, touch.x, touch.y);
this->add_raw_touch_position_(touch.id, touch.x, touch.y);
}
}
@@ -1,7 +1,6 @@
#pragma once
#include "esphome/components/i2c/i2c.h"
#include "esphome/components/touchscreen/touchscreen.h"
#include "esphome/components/cstxxx/cstxxx.h"
#include "esphome/core/component.h"
#include "esphome/core/hal.h"
#include "esphome/core/log.h"
@@ -10,41 +9,26 @@ namespace esphome::cst9220 {
ESPHOME_LOG_TAG(TAG, "cst9220.touchscreen");
// The CST92xx family uses 16-bit (big-endian) register addresses.
static const uint16_t REG_TOUCH_DATA = 0xD000; // touch report
static const uint16_t REG_CMD_MODE = 0xD101; // enter command mode
static const uint16_t REG_CHECKCODE = 0xD1FC; // firmware check code
static const uint16_t REG_RESOLUTION = 0xD1F8; // panel resolution
static const uint16_t REG_CHIP_INFO = 0xD204; // chip type + project id
static constexpr uint8_t TOUCH_EVENT_DOWN = 0x06;
static const uint8_t TOUCH_ACK = 0xAB;
static const uint8_t TOUCH_EVENT_DOWN = 0x06;
static constexpr uint16_t CST9220_CHIP_ID = 0x9220;
static constexpr uint16_t CST9217_CHIP_ID = 0x9217;
static const uint16_t CST9220_CHIP_ID = 0x9220;
static const uint16_t CST9217_CHIP_ID = 0x9217;
// Maximum simultaneous touch points reported by the family.
static const uint8_t CST9220_MAX_TOUCHES = 5;
static constexpr uint8_t CST9220_MAX_TOUCHES = 5;
// Report layout: 5 bytes per touch point plus 5 bytes of status/ack overhead.
static const size_t CST9220_DATA_LENGTH = CST9220_MAX_TOUCHES * 5 + 5;
static constexpr size_t CST9220_DATA_LENGTH = CST9220_MAX_TOUCHES * 5 + 5;
class CST9220Touchscreen : public touchscreen::Touchscreen, public i2c::I2CDevice {
class CST9220Touchscreen : public cstxxx::CSTTouchscreen {
public:
void setup() override;
void dump_config() override;
void set_interrupt_pin(InternalGPIOPin *pin) { this->interrupt_pin_ = pin; }
void set_reset_pin(GPIOPin *pin) { this->reset_pin_ = pin; }
protected:
void update_touches() override;
void continue_setup_();
InternalGPIOPin *interrupt_pin_{};
GPIOPin *reset_pin_{};
uint16_t chip_id_{};
uint16_t project_id_{};
bool setup_complete_{};
};
} // namespace esphome::cst9220
+42
View File
@@ -0,0 +1,42 @@
from esphome import pins
import esphome.codegen as cg
from esphome.components import i2c, touchscreen
import esphome.config_validation as cv
from esphome.const import CONF_ID, CONF_INTERRUPT_PIN, CONF_RESET_PIN
from esphome.cpp_generator import MockObj, MockObjClass
from esphome.types import ConfigType
CODEOWNERS = ["@clydebarrow", "@latonita"]
DEPENDENCIES = ["i2c", "touchscreen"]
DOMAIN = "cstxxx"
cstxxx_ns = cg.esphome_ns.namespace("cstxxx")
CSTTouchscreen = cstxxx_ns.class_(
"CSTTouchscreen", touchscreen.Touchscreen, i2c.I2CDevice
)
def cst_touchscreen_schema(touchscreen_class: MockObjClass, address: int) -> cv.Schema:
"""Return the touchscreen schema of a Hynitron driver."""
return (
touchscreen.touchscreen_schema("100ms")
.extend(
{
cv.GenerateID(): cv.declare_id(touchscreen_class),
cv.Optional(CONF_INTERRUPT_PIN): pins.internal_gpio_input_pin_schema,
cv.Optional(CONF_RESET_PIN): pins.gpio_output_pin_schema,
}
)
.extend(i2c.i2c_device_schema(address))
)
async def new_cst_touchscreen(config: ConfigType) -> MockObj:
"""Create a Hynitron touchscreen and set its pins."""
var = cg.new_Pvariable(config[CONF_ID])
await touchscreen.register_touchscreen(var, config)
await i2c.register_i2c_device(var, config)
await cg.add_pin(var.set_interrupt_pin, config.get(CONF_INTERRUPT_PIN))
await cg.add_pin(var.set_reset_pin, config.get(CONF_RESET_PIN))
return var
+13
View File
@@ -0,0 +1,13 @@
#include "cstxxx.h"
#include "esphome/core/log.h"
namespace esphome::cstxxx {
ESPHOME_LOG_TAG(TAG, "cstxxx");
void CSTTouchscreen::fail_check_code_(uint16_t check_code) {
ESP_LOGE(TAG, "Firmware check code 0x%04X", check_code);
this->mark_failed(LOG_STR("Invalid firmware check code"));
}
} // namespace esphome::cstxxx
+92
View File
@@ -0,0 +1,92 @@
#pragma once
#include <cstddef>
#include <cstdint>
#include "esphome/components/i2c/i2c.h"
#include "esphome/components/touchscreen/touchscreen.h"
#include "esphome/core/gpio.h"
#include "esphome/core/hal.h"
#include "esphome/core/helpers.h"
#include "esphome/core/log.h"
namespace esphome::cstxxx {
static constexpr uint16_t REG_TOUCH_DATA = 0xD000;
static constexpr uint16_t REG_FINGER_COUNT = 0xD005;
static constexpr uint16_t REG_COMMAND_MODE = 0xD101;
static constexpr uint16_t REG_NORMAL_MODE = 0xD109;
static constexpr uint16_t REG_RESOLUTION = 0xD1F8;
static constexpr uint16_t REG_FW_CHECK_CODE = 0xD1FC;
static constexpr uint16_t REG_CHIP_INFO = 0xD204;
static constexpr uint16_t REG_FW_VERSION = 0xD208;
static constexpr uint8_t FINGER_COUNT_IDX = REG_FINGER_COUNT - REG_TOUCH_DATA;
static constexpr uint8_t SYNC_IDX = FINGER_COUNT_IDX + 1;
static constexpr uint8_t SYNC_BYTE = 0xAB;
static constexpr uint16_t FW_CHECK_CODE = 0xCACA;
/// Bytes of a touch report holding `points` records; two status bytes follow the first record.
constexpr size_t report_size(uint8_t points) { return points * 5 + 2; }
struct TouchRecord {
uint8_t id;
uint8_t event;
uint16_t x;
uint16_t y;
uint8_t z;
};
/// Decodes record `index` of a touch report.
inline TouchRecord decode_touch(const uint8_t *report, uint8_t index) {
const uint8_t *r = report + index * 5 + (index == 0 ? 0 : 2);
return {static_cast<uint8_t>(r[0] >> 4), static_cast<uint8_t>(r[0] & 0x0F),
static_cast<uint16_t>(r[1] << 4 | r[3] >> 4), static_cast<uint16_t>(r[2] << 4 | (r[3] & 0x0F)), r[4]};
}
class CSTTouchscreen : public touchscreen::Touchscreen, public i2c::I2CDevice {
public:
void set_interrupt_pin(InternalGPIOPin *pin) { this->interrupt_pin_ = pin; }
void set_reset_pin(GPIOPin *pin) { this->reset_pin_ = pin; }
protected:
/// Sets up the interrupt pin, if configured, to fire on `type`.
void setup_interrupt_pin_(gpio::InterruptType type) {
if (this->interrupt_pin_ == nullptr)
return;
this->interrupt_pin_->setup();
this->attach_interrupt_(this->interrupt_pin_, type);
}
/// Reads two little-endian words starting at `reg`.
bool ESPHOME_ALWAYS_INLINE read_words_(uint16_t reg, uint16_t &low, uint16_t &high) {
uint16_t words[2];
if (this->read_register16(reg, reinterpret_cast<uint8_t *>(words), sizeof(words)) != i2c::ERROR_OK)
return false;
low = convert_little_endian(words[0]);
high = convert_little_endian(words[1]);
return true;
}
/// Enters command mode, marking the component failed if the write fails.
bool enter_command_mode_() {
return this->setup_check(this->write_register16(REG_COMMAND_MODE, nullptr, 0) == i2c::ERROR_OK,
LOG_STR("Failed to enter command mode"));
}
/// Checks the firmware check code, marking the component failed if it is unreadable or wrong.
bool check_firmware_() {
uint16_t boot_time, check_code;
if (!this->setup_check(this->read_words_(REG_FW_CHECK_CODE, boot_time, check_code)))
return false;
if (check_code == FW_CHECK_CODE)
return true;
this->fail_check_code_(check_code);
return false;
}
/// Logs a wrong firmware check code and marks the component failed.
void fail_check_code_(uint16_t check_code);
InternalGPIOPin *interrupt_pin_{};
GPIOPin *reset_pin_{};
bool setup_complete_{};
};
} // namespace esphome::cstxxx
+3 -1
View File
@@ -1,6 +1,5 @@
import esphome.codegen as cg
from esphome.components import logger
from esphome.components.nrf52.framework import include_west_project
from esphome.components.zephyr import zephyr_add_prj_conf
from esphome.config_helpers import filter_source_files_from_platform
import esphome.config_validation as cv
@@ -53,6 +52,9 @@ CONFIG_SCHEMA = cv.All(
async def to_code(config: ConfigType) -> None:
if CORE.using_zephyr:
# Imported here so configs for other platforms do not load the nrf52 package
from esphome.components.nrf52.framework import include_west_project
zephyr_add_prj_conf("HWINFO", True)
# gdb thread support
zephyr_add_prj_conf("DEBUG_THREAD_INFO", True)
+1 -1
View File
@@ -173,7 +173,7 @@ void DFPlayer::loop() {
}
// Parse valid received command
uint8_t cmd = this->read_buffer_[3];
uint16_t argument = (this->read_buffer_[5] << 8) | this->read_buffer_[6];
uint16_t argument = encode_uint16(this->read_buffer_[5], this->read_buffer_[6]);
ESP_LOGV(TAG, "Received message cmd: %#02x arg %#04x", cmd, argument);
+1 -1
View File
@@ -22,7 +22,7 @@ void EE895Component::setup() {
uint8_t serial_number[20];
this->read(serial_number, 20);
crc16_check = (serial_number[19] << 8) + serial_number[18];
crc16_check = encode_value_le<uint16_t>(serial_number + 18);
if (!this->setup_check(crc16_check == calc_crc16_(serial_number, 18), LOG_STR("CRC check failed")))
return;
#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
@@ -10,7 +10,7 @@ from esphome.components.const import CONF_PROVIDER, CONF_REMOTE_ID
from esphome.components.packet_interface import (
CONF_PACKET_INTERFACE,
final_validate_interface,
interface_layers,
interface_has_layer,
interface_packet_size,
)
from esphome.components.packet_interface.layers import CONF_SESSION
@@ -103,11 +103,13 @@ CONFIG_SCHEMA = cv.Schema(
def _final_validate(config: ConfigType) -> ConfigType:
"""With a session layer, which clears the states when the peer is lost, nothing would refresh an unchanged state."""
layers = interface_layers(config[CONF_PACKET_INTERFACE])
if CONF_TIMEOUT in config and CONF_SESSION in layers:
if CONF_TIMEOUT in config and interface_has_layer(
config[CONF_PACKET_INTERFACE], CONF_SESSION
):
raise cv.Invalid(
f"Not allowed with a '{CONF_SESSION}' layer, which already clears the states when the other device "
"cannot be reached; unchanged states may never be sent again, so they would time out on a working link",
f"Not allowed with a '{CONF_SESSION}' layer, or a link that does its job, which already clears the "
"states when the other device cannot be reached; unchanged states may never be sent again, so they "
"would time out on a working link",
path=[CONF_TIMEOUT],
)
return config
@@ -4,6 +4,7 @@
#include <cstring>
#include "esphome/core/application.h"
#include "esphome/core/log.h"
#include "esphome/core/helpers.h"
namespace esphome::entity_transport {
@@ -373,8 +374,7 @@ size_t EntityTransport::write_record_(const LocalEntity &entity, uint8_t *record
#endif
uint16_t tag =
entity.number | (type << TAG_TYPE_SHIFT) | (payload << TAG_PAYLOAD_SHIFT) | (value ? TAG_VALUE_BIT : 0);
record[0] = tag;
record[1] = tag >> 8;
put_le16(record, tag);
return size;
}
+3 -1
View File
@@ -56,7 +56,6 @@ from esphome.const import (
from esphome.core import CORE, EsphomeError, HexInt
from esphome.core.config import BOARD_MAX_LENGTH
from esphome.coroutine import CoroPriority, coroutine_with_priority
from esphome.espidf import sbom
from esphome.espidf.component import IDFComponent, generate_idf_components
import esphome.final_validate as fv
from esphome.helpers import copy_file_if_changed, rmtree, write_file_if_changed
@@ -4033,6 +4032,9 @@ def copy_files():
CORE.relative_build_path("version.txt"),
__version__,
)
# Imported here: sbom loads git and urllib helpers that config validation does not need
from esphome.espidf import sbom
sbom.write_manifests()
# Remote extra build files are fetched into the shared download cache in
@@ -24,7 +24,7 @@ ESPHOME_LOG_TAG(TAG, "espnow");
ESPNowComponent *global_esp_now = nullptr; // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
static const LogString *espnow_error_to_str(esp_err_t error) {
const LogString *espnow_error_to_str(esp_err_t error) {
switch (error) {
case ESP_ERR_ESPNOW_FAILED:
return LOG_STR("ESPNow is in fail mode");
@@ -25,6 +25,9 @@ namespace esphome::espnow {
using peer_address_t = std::array<uint8_t, ESP_NOW_ETH_ALEN>;
/// A short description of an ESP-NOW error code, for logging.
const LogString *espnow_error_to_str(esp_err_t error);
enum class ESPNowTriggers : uint8_t {
TRIGGER_NONE = 0,
ON_NEW_PEER = 1,
@@ -123,6 +126,7 @@ class ESPNowComponent final : public Component {
uint8_t get_wifi_channel();
void set_auto_add_peer(bool value) { this->auto_add_peer_ = value; }
bool get_auto_add_peer() const { return this->auto_add_peer_; }
#if defined(USE_WIFI) && defined(USE_WIFI_CONNECT_STATE_LISTENERS)
// WiFiConnectStateListener interface: refresh the cached channel after each (re)connect
@@ -148,6 +152,10 @@ class ESPNowComponent final : public Component {
return this->send(peer_address, payload.data(), payload.size(), std::move(callback));
}
esp_err_t send(const uint8_t *peer_address, const uint8_t *payload, size_t size, send_callback_t callback = nullptr);
/// How many more packets send() can queue now; they share one pool.
size_t get_send_queue_free() const {
return MAX_ESP_NOW_SEND_QUEUE_SIZE - 1 - this->send_packet_queue_.size() - (this->current_send_packet_ != nullptr);
}
void register_receive_handler(ESPNowReceivedPacketHandler *handler) { this->receive_handlers_.push_back(handler); }
void register_unknown_peer_handler(ESPNowUnknownPeerHandler *handler) {
@@ -0,0 +1,98 @@
import esphome.codegen as cg
from esphome.components import packet_interface
from esphome.components.packet_interface import (
CONF_MAX_PACKET_SIZE,
new_packet_interface,
packet_interface_schema,
)
from esphome.components.packet_interface.layers import (
CONF_ADDRESSING,
check_broadcast_link,
)
import esphome.config_validation as cv
from esphome.const import CONF_ID
from esphome.core import HexInt, MACAddress
import esphome.final_validate as fv
from esphome.types import ConfigType
from .. import (
CONF_MAX_PAYLOAD_SIZE,
DOMAIN as ESPNOW_DOMAIN,
ESPNowComponent,
espnow_ns,
)
CODEOWNERS = ["@clydebarrow"]
DEPENDENCIES = ["espnow"]
CONF_ESPNOW_ID = "espnow_id"
CONF_PEER_ADDRESS = "peer_address"
# The ESP-NOW v1 payload; a larger max_payload_size on the espnow component allows a larger max_packet_size
MAX_PACKET_SIZE = 250
BROADCAST_MAC = "FF:FF:FF:FF:FF:FF"
ESPNowPacketInterface = espnow_ns.class_(
"ESPNowPacketInterface", packet_interface.PacketInterface
)
def _is_broadcast(config: ConfigType) -> bool:
return str(config[CONF_PEER_ADDRESS]) == BROADCAST_MAC
def _peer_mac(value: object) -> MACAddress:
"""A device's own address, or the broadcast address; a group or all-zero address names no one device."""
mac = cv.mac_address(value)
if str(mac) != BROADCAST_MAC and (mac.parts[0] & 1 or not any(mac.parts)):
raise cv.Invalid(
f"'{mac}' is not the address of a device; use a device's MAC address, or {BROADCAST_MAC}"
)
return mac
def _validate_addressing(config: ConfigType) -> ConfigType:
if _is_broadcast(config):
check_broadcast_link(config)
elif CONF_ADDRESSING in config:
raise cv.Invalid(
f"Packets to one '{CONF_PEER_ADDRESS}' are already addressed, so '{CONF_ADDRESSING}' is only "
"for broadcast",
path=[CONF_ADDRESSING],
)
return config
CONFIG_SCHEMA = cv.All(
packet_interface_schema(ESPNowPacketInterface, MAX_PACKET_SIZE, 1470).extend(
{
cv.GenerateID(CONF_ESPNOW_ID): cv.use_id(ESPNowComponent),
cv.Optional(CONF_PEER_ADDRESS, default=BROADCAST_MAC): _peer_mac,
}
),
_validate_addressing,
)
def _validate_packet_size(config: ConfigType) -> ConfigType:
payload = fv.full_config.get()[ESPNOW_DOMAIN][CONF_MAX_PAYLOAD_SIZE]
if config[CONF_MAX_PACKET_SIZE] > payload:
raise cv.Invalid(
f"Must not be larger than the espnow {CONF_MAX_PAYLOAD_SIZE} of {payload}",
path=[CONF_MAX_PACKET_SIZE],
)
return config
FINAL_VALIDATE_SCHEMA = _validate_packet_size
async def to_code(config: ConfigType) -> None:
parent = await cg.get_variable(config[CONF_ESPNOW_ID])
peer = [HexInt(x) for x in config[CONF_PEER_ADDRESS].parts]
# Added now, also the broadcast address, so no peer is added after setup
cg.add(parent.add_peer(peer))
tx_buffer = cg.static_buffer(
config[CONF_ID], cg.uint8, config[CONF_MAX_PACKET_SIZE]
)
await new_packet_interface(config, parent, tx_buffer, peer)
@@ -0,0 +1,159 @@
#include "espnow_packet_interface.h"
#if defined(USE_ESP32) || defined(USE_ESP8266)
#include <cstring>
#include "esphome/core/application.h"
#include "esphome/core/helpers.h"
#include "esphome/core/log.h"
namespace esphome::espnow {
using packet_interface::PacketBuffer;
using packet_interface::PacketMetaData;
ESPHOME_LOG_TAG(TAG, "espnow.packet_interface");
static constexpr uint32_t WARNING_INTERVAL_MS = 60000;
ESPNowPacketInterface::ESPNowPacketInterface(ESPNowComponent *parent, std::span<uint8_t> tx_buffer,
peer_address_t peer_address)
: packet_interface::PacketInterface(tx_buffer.size()),
parent_(parent),
tx_buffer_(tx_buffer),
peer_address_(peer_address) {
if (!this->is_broadcast_())
this->capabilities_ = packet_interface::CAPABILITY_ADDRESSING;
}
void ESPNowPacketInterface::setup() {
// Each mode hears only its own kind of packet, so a peer link and a broadcast link can share the component
if (!this->is_broadcast_() || !ESPNOW_REPORTS_DESTINATION)
this->parent_->register_receive_handler(this);
if (this->is_broadcast_()) {
this->parent_->register_broadcast_handler(this);
this->parent_->register_unknown_peer_handler(this);
}
}
void ESPNowPacketInterface::dump_config() {
char peer_buf[MAC_ADDRESS_PRETTY_BUFFER_SIZE];
format_mac_addr_upper(this->peer_address_.data(), peer_buf);
ESP_LOGCONFIG(TAG,
"ESP-NOW Packet Interface '%s':\n"
" Peer: %s\n"
" Max Packet Size: %zu",
this->name_, peer_buf, this->max_packet_size_);
}
bool ESPNowPacketInterface::send_to_interface(const PacketBuffer &data, const PacketMetaData &meta_data) {
// Layers above are set up first, and may send while setup waits for another component
if (!this->is_ready())
return false;
size_t size = data.size();
if (size > this->max_packet_size_) {
ESP_LOGW(TAG, "%s: Packet of %zu bytes is larger than %zu", this->name_, size, this->max_packet_size_);
return false;
}
const uint8_t *payload;
if (data.is_contiguous()) {
payload = data.as_span().data();
} else {
data.copy_to(this->tx_buffer_.data(), size);
payload = this->tx_buffer_.data();
}
// Only a unicast send learns whether the peer received it
esp_err_t err = this->is_broadcast_()
? this->parent_->send(this->peer_address_.data(), payload, size)
: this->parent_->send(this->peer_address_.data(), payload, size, [this](esp_err_t status) {
if (status != ESP_OK)
this->delivery_failed_();
});
if (err != ESP_OK) {
this->send_failed_(err);
return false;
}
return true;
}
// A full send queue is logged by the espnow component, and ESP-NOW is not running before setup or while disabled.
// Other errors, such as a peer that could not be added, repeat on every send, so warn now and then
void ESPNowPacketInterface::send_failed_(esp_err_t err) {
uint32_t now = App.get_loop_component_start_time();
if (err == ESP_ERR_ESPNOW_NO_MEM || err == ESP_ERR_ESPNOW_NOT_INIT ||
(this->send_warned_ && now - this->last_send_warning_ms_ < WARNING_INTERVAL_MS)) {
ESP_LOGV(TAG, "%s: Send failed: %s", this->name_, LOG_STR_ARG(espnow_error_to_str(err)));
return;
}
this->send_warned_ = true;
this->last_send_warning_ms_ = now;
ESP_LOGW(TAG, "%s: Send failed: %s", this->name_, LOG_STR_ARG(espnow_error_to_str(err)));
}
// A peer that is off, out of range or has another address never acknowledges; without a reliability layer above,
// nothing else would report that, so warn now and then
void ESPNowPacketInterface::delivery_failed_() {
uint32_t now = App.get_loop_component_start_time();
if (this->delivery_warned_ && now - this->last_delivery_warning_ms_ < WARNING_INTERVAL_MS) {
ESP_LOGV(TAG, "%s: Packet not acknowledged by the peer", this->name_);
return;
}
this->delivery_warned_ = true;
this->last_delivery_warning_ms_ = now;
ESP_LOGW(TAG, "%s: Packet not acknowledged by the peer; it may be off, out of range, or have another address",
this->name_);
}
// Every larger packet from a peer whose max_packet_size is larger is lost, so warn now and then
void ESPNowPacketInterface::oversized_(uint16_t size) {
uint32_t now = App.get_loop_component_start_time();
if (this->size_warned_ && now - this->last_size_warning_ms_ < WARNING_INTERVAL_MS) {
ESP_LOGV(TAG, "%s: Packet of %u bytes is larger than %zu, dropped", this->name_, size, this->max_packet_size_);
return;
}
this->size_warned_ = true;
this->last_size_warning_ms_ = now;
ESP_LOGW(TAG, "%s: Packet of %u bytes is larger than %zu, dropped; set the same max_packet_size on both devices",
this->name_, size, this->max_packet_size_);
}
bool ESPNowPacketInterface::on_receive(const ESPNowRecvInfo &info, const uint8_t *data, uint16_t size) {
this->receive_(info, data, size);
return false;
}
bool ESPNowPacketInterface::on_broadcast(const ESPNowRecvInfo &info, const uint8_t *data, uint16_t size) {
this->receive_(info, data, size);
return false;
}
bool ESPNowPacketInterface::on_unknown_peer(const ESPNowRecvInfo &info, const uint8_t *data, uint16_t size) {
// Only known peers reach the other handlers; with auto_add_peer this sender is added and arrives there
if (this->parent_->get_auto_add_peer())
return false;
if (!ESPNOW_REPORTS_DESTINATION || memcmp(info.des_addr, ESPNOW_BROADCAST_ADDR, ESP_NOW_ETH_ALEN) == 0)
this->receive_(info, data, size);
return false;
}
void ESPNowPacketInterface::receive_(const ESPNowRecvInfo &info, const uint8_t *data, uint16_t size) {
if (size == 0)
return;
if (!this->is_broadcast_() && memcmp(info.src_addr, this->peer_address_.data(), ESP_NOW_ETH_ALEN) != 0)
return;
if (size > this->max_packet_size_) {
this->oversized_(size);
return;
}
PacketMetaData meta_data;
memcpy(meta_data.mac_address, info.src_addr, ESP_NOW_ETH_ALEN);
#ifdef USE_ESP32
meta_data.rssi = info.rx_ctrl->rssi;
#endif
this->on_receive_from_interface_(PacketBuffer(data, size), meta_data);
}
} // namespace esphome::espnow
#endif // USE_ESP32 || USE_ESP8266
@@ -0,0 +1,67 @@
#pragma once
#include "../espnow_component.h"
#if defined(USE_ESP32) || defined(USE_ESP8266)
#include <cstring>
#include <span>
#include "esphome/components/packet_interface/packet_interface.h"
namespace esphome::espnow {
/**
* A packet interface link over ESP-NOW.
*
* With a peer address other than broadcast, packets go to that device only, and only packets sent to this device by
* it are received, so the link provides the addressing capability itself. With the broadcast address, packets go to
* every device on the channel and every broadcast packet is received, from known and unknown senders; an addressing
* layer then tells the devices apart. ESP8266 does not report a packet's destination, so there a broadcast link also
* receives packets sent to this device, and a peer link also receives the peer's broadcasts.
*
* ESP-NOW queues each packet and reports later whether it was delivered; a reliability layer above resends what is
* lost.
*/
class ESPNowPacketInterface : public packet_interface::PacketInterface,
public ESPNowReceivedPacketHandler,
public ESPNowBroadcastHandler,
public ESPNowUnknownPeerHandler {
public:
/// @param tx_buffer Joins packets split across buffers; its size is the largest packet, and it must outlive the link
ESPNowPacketInterface(ESPNowComponent *parent, std::span<uint8_t> tx_buffer, peer_address_t peer_address);
void setup() override;
void dump_config() override;
bool send_to_interface(const packet_interface::PacketBuffer &data,
const packet_interface::PacketMetaData &meta_data) override;
/// The free slots in the ESP-NOW send queue, which every link on this device shares.
size_t get_send_capacity() const override { return this->parent_->get_send_queue_free(); }
bool on_receive(const ESPNowRecvInfo &info, const uint8_t *data, uint16_t size) override;
bool on_broadcast(const ESPNowRecvInfo &info, const uint8_t *data, uint16_t size) override;
bool on_unknown_peer(const ESPNowRecvInfo &info, const uint8_t *data, uint16_t size) override;
protected:
bool is_broadcast_() const {
return memcmp(this->peer_address_.data(), ESPNOW_BROADCAST_ADDR, ESP_NOW_ETH_ALEN) == 0;
}
void receive_(const ESPNowRecvInfo &info, const uint8_t *data, uint16_t size);
void send_failed_(esp_err_t err);
void delivery_failed_();
void oversized_(uint16_t size);
ESPNowComponent *parent_;
const std::span<uint8_t> tx_buffer_;
uint32_t last_send_warning_ms_{0};
uint32_t last_delivery_warning_ms_{0};
uint32_t last_size_warning_ms_{0};
peer_address_t peer_address_;
bool send_warned_{false};
bool delivery_warned_{false};
bool size_warned_{false};
};
} // namespace esphome::espnow
#endif // USE_ESP32 || USE_ESP8266
@@ -7,6 +7,8 @@
#include "esphome/core/automation.h"
#include "esphome/components/network/ip_address.h"
#include <atomic>
#ifdef USE_ETHERNET
#ifdef USE_ESP32
@@ -366,6 +368,9 @@ class EthernetComponent final : public Component {
#ifdef USE_ETHERNET_IP_STATE_LISTENERS
StaticVector<EthernetIPStateListener *, ESPHOME_ETHERNET_IP_STATE_LISTENERS> ip_state_listeners_;
#ifdef USE_ESP32
std::atomic<uint8_t> ip_state_pending_{0};
#endif
#endif
#ifdef USE_ETHERNET_CONNECT_TRIGGER
@@ -129,6 +129,14 @@ void EthernetComponent::log_error_and_mark_failed_(esp_err_t err, const char *me
void EthernetComponent::loop() {
const uint32_t now = App.get_loop_component_start_time();
#ifdef USE_ETHERNET_IP_STATE_LISTENERS
// The IP events arrive on the event task; the listeners publish states, so notify them here
if (this->ip_state_pending_.load(std::memory_order_acquire) != 0) {
this->ip_state_pending_.store(0, std::memory_order_relaxed);
this->notify_ip_state_listeners_();
}
#endif
switch (this->state_) {
case EthernetComponentState::STOPPED:
if (this->started_) {
@@ -770,7 +778,8 @@ void EthernetComponent::eth_event_handler(void *arg, esp_event_base_t event_base
event_name = "ETH connected";
// For static IP configurations, GOT_IP event may not fire, so notify IP listeners here
#if defined(USE_ETHERNET_IP_STATE_LISTENERS) && defined(USE_ETHERNET_MANUAL_IP)
global_eth_component->notify_ip_state_listeners_();
global_eth_component->ip_state_pending_.store(1, std::memory_order_release);
global_eth_component->enable_loop_soon_any_context();
#endif
#if USE_NETWORK_IPV6
// Start SLAAC on link-up, not after the DHCPv4 lease. This also restores the
@@ -798,6 +807,9 @@ void EthernetComponent::got_ip_event_handler(void *arg, esp_event_base_t event_b
const esp_netif_ip_info_t *ip_info = &event->ip_info;
ESP_LOGV(TAG, "[Ethernet event] ETH Got IP " IPSTR, IP2STR(&ip_info->ip));
global_eth_component->got_ipv4_address_ = true;
#ifdef USE_ETHERNET_IP_STATE_LISTENERS
global_eth_component->ip_state_pending_.store(1, std::memory_order_release);
#endif
#if USE_NETWORK_IPV6 && (USE_NETWORK_MIN_IPV6_ADDR_COUNT > 0)
global_eth_component->connected_ = global_eth_component->ipv6_count_ >= USE_NETWORK_MIN_IPV6_ADDR_COUNT;
global_eth_component->enable_loop_soon_any_context(); // Enable loop when connection state changes
@@ -805,9 +817,6 @@ void EthernetComponent::got_ip_event_handler(void *arg, esp_event_base_t event_b
global_eth_component->connected_ = true;
global_eth_component->enable_loop_soon_any_context(); // Enable loop when connection state changes
#endif /* USE_NETWORK_IPV6 */
#ifdef USE_ETHERNET_IP_STATE_LISTENERS
global_eth_component->notify_ip_state_listeners_();
#endif
}
#if USE_NETWORK_IPV6
@@ -819,6 +828,9 @@ void EthernetComponent::got_ip6_event_handler(void *arg, esp_event_base_t event_
// after a link flap fires another event for the same address.
struct esp_ip6_addr if_ip6s[CONFIG_LWIP_IPV6_NUM_ADDRESSES];
global_eth_component->ipv6_count_ = esp_netif_get_all_ip6(global_eth_component->eth_netif_, if_ip6s);
#ifdef USE_ETHERNET_IP_STATE_LISTENERS
global_eth_component->ip_state_pending_.store(1, std::memory_order_release);
#endif
#if (USE_NETWORK_MIN_IPV6_ADDR_COUNT > 0)
global_eth_component->connected_ =
global_eth_component->got_ipv4_address_ && (global_eth_component->ipv6_count_ >= USE_NETWORK_MIN_IPV6_ADDR_COUNT);
@@ -827,9 +839,6 @@ void EthernetComponent::got_ip6_event_handler(void *arg, esp_event_base_t event_
global_eth_component->connected_ = global_eth_component->got_ipv4_address_;
global_eth_component->enable_loop_soon_any_context(); // Enable loop when connection state changes
#endif
#ifdef USE_ETHERNET_IP_STATE_LISTENERS
global_eth_component->notify_ip_state_listeners_();
#endif
}
#endif /* USE_NETWORK_IPV6 */
@@ -1,5 +1,6 @@
#include "inkbird_ibsth1_mini.h"
#include "esphome/core/log.h"
#include "esphome/core/helpers.h"
namespace esphome::inkbird_ibsth1_mini {
@@ -82,7 +83,7 @@ bool InkbirdIbstH1Mini::parse_device(const ble_device_base::ESPBTDevice &device)
}
auto battery_level = mnf_data.data[5];
auto humidity = ((mnf_data.data[1] << 8) + mnf_data.data[0]) / 100.0f;
auto humidity = encode_value_le<uint16_t>(mnf_data.data.data()) / 100.0f;
// Send temperature only if the value is set
if (!std::isnan(temperature) && this->temperature_sensor_ != nullptr) {
+45
View File
@@ -0,0 +1,45 @@
"""LZSS compression with a preset dictionary, for short blocks of data such as packets."""
from dataclasses import dataclass
import esphome.codegen as cg
from esphome.core import CORE, ID
from esphome.cpp_generator import MockObj
CODEOWNERS = ["@clydebarrow"]
DOMAIN = "lzss"
# Offsets are sized by a history of at most this many bytes (WINDOW in lzss.h), so a longer dictionary would not help
MAX_DICTIONARY_SIZE = 512
lzss_ns = cg.esphome_ns.namespace("lzss")
Lzss = lzss_ns.class_("Lzss")
@dataclass
class LzssData:
chains: MockObj | None = None
def _get_data() -> LzssData:
if DOMAIN not in CORE.data:
CORE.data[DOMAIN] = LzssData()
return CORE.data[DOMAIN]
def shared_chains() -> MockObj:
"""The working space for compress(), one for every user, as compress() needs it only while it runs."""
data = _get_data()
if data.chains is None:
buffer = cg.static_buffer(
ID("lzss_chains", is_declaration=True, type=cg.uint16),
cg.uint16,
Lzss.static_("CHAIN_WORDS"),
psram=True,
)
# With PSRAM the buffer is an allocation, so it is made once and kept
data.chains = cg.variable(
ID("lzss_chains_ptr", is_declaration=True, type=cg.uint16.operator("ptr")),
buffer,
)
return data.chains
+209
View File
@@ -0,0 +1,209 @@
#include "lzss.h"
#include <algorithm>
#include <bit>
#include "esphome/core/hal.h"
#include "esphome/core/helpers.h"
namespace esphome::lzss {
// Gamma codes up to this many bits after the first, so lengths up to 65536
static constexpr uint8_t MAX_GAMMA_ZEROS = 15;
static_assert(Lzss::MAX_MATCH == size_t{1} << (MAX_GAMMA_ZEROS + 1));
static constexpr size_t LITERAL_BITS = 9;
static constexpr uint16_t NO_POSITION = 0xFFFF;
static size_t gamma_bits(size_t value) { return 2 * std::bit_width(value) - 1; }
namespace {
// Writes bits from bit 7 of each byte, and stops writing once the output is full
class BitWriter {
public:
BitWriter(uint8_t *out, size_t capacity) : out_(out), capacity_(capacity) {}
void put(uint32_t value, size_t count) {
while (count-- != 0) {
if (this->used_ == 0) {
if (this->length_ == this->capacity_) {
this->full_ = true;
return;
}
this->out_[this->length_] = 0;
}
if ((value >> count) & 1)
this->out_[this->length_] |= 0x80 >> this->used_;
if (++this->used_ == 8) {
this->used_ = 0;
this->length_++;
}
}
}
void put_gamma(uint32_t value) {
size_t width = std::bit_width(value);
this->put(0, width - 1);
this->put(value, width);
}
bool is_full() const { return this->full_; }
/// Pads the last byte with 1 bits; returns the length, or 0 if the output was too small.
size_t finish() {
if (this->full_)
return 0;
if (this->used_ != 0)
this->out_[this->length_++] |= 0xFF >> this->used_;
return this->length_;
}
protected:
uint8_t *out_;
size_t capacity_;
size_t length_{0};
uint8_t used_{0};
bool full_{false};
};
class BitReader {
public:
BitReader(const uint8_t *data, size_t size) : data_(data), end_(size) {}
size_t left() const { return (this->end_ - this->pos_) * 8 - this->used_; }
/// Only call with no more than left() bits.
uint32_t get(size_t count) {
uint32_t value = 0;
while (count-- != 0) {
if (this->used_ == 0)
this->byte_ = this->data_[this->pos_];
value = value << 1 | ((this->byte_ >> (7 - this->used_)) & 1);
if (++this->used_ == 8) {
this->used_ = 0;
this->pos_++;
}
}
return value;
}
protected:
const uint8_t *data_;
size_t pos_{0};
size_t end_;
uint8_t byte_{0};
uint8_t used_{0};
};
} // namespace
uint8_t Lzss::byte_at_(const uint8_t *data, size_t pos) const {
return pos < this->dictionary_size_ ? progmem_read_byte(this->dictionary_ + pos) : data[pos - this->dictionary_size_];
}
size_t Lzss::compress(const uint8_t *in, size_t size, uint8_t *out, size_t capacity, uint16_t *chains) const {
BitWriter writer(out, capacity);
size_t total = this->dictionary_size_ + size;
// For each hash, the latest position with it; for each of the last WINDOW positions, the one before it with the
// same hash
uint16_t *head = chains;
uint16_t *previous = chains + (size_t{1} << HASH_BITS);
auto hash = [&](size_t pos) {
return ((this->byte_at_(in, pos) << 8 | this->byte_at_(in, pos + 1)) * 0x9E3779B1u) >> (32 - HASH_BITS);
};
auto insert = [&](size_t pos) {
if (pos + 1 >= total)
return;
size_t h = hash(pos);
previous[pos & (WINDOW - 1)] = head[h];
head[h] = pos;
};
std::fill_n(head, size_t{1} << HASH_BITS, NO_POSITION);
// A match reaches back at most WINDOW bytes, so earlier dictionary bytes are never used
for (size_t pos = this->dictionary_size_ > WINDOW ? this->dictionary_size_ - WINDOW : 0; pos < this->dictionary_size_;
pos++)
insert(pos);
size_t i = 0;
while (i < size && !writer.is_full()) {
size_t pos = this->dictionary_size_ + i;
size_t longest = clamp_at_most(size - i, MAX_MATCH);
size_t best_length = 0;
size_t best_offset = 0;
if (longest >= 2) {
// The chain runs from the nearest, so of two matches of the same length the nearer is kept
size_t tries = MAX_CHAIN;
for (uint16_t ref = head[hash(pos)]; ref != NO_POSITION && pos - ref <= WINDOW && tries-- != 0;) {
size_t length = 0;
// A match may run on past pos, copying bytes the expander has just written
while (length < longest && this->byte_at_(in, ref + length) == in[i + length])
length++;
if (length > best_length) {
best_length = length;
best_offset = pos - ref;
if (length == longest)
break;
}
// A slot reused by a later position ends the chain
uint16_t next = previous[ref & (WINDOW - 1)];
if (next >= ref)
break;
ref = next;
}
}
size_t step = 1;
const size_t offset_bits = std::bit_width(clamp_at_most(pos, WINDOW) - 1);
if (best_length >= 2 && 1 + offset_bits + gamma_bits(best_length - 1) < LITERAL_BITS * best_length) {
writer.put(0, 1);
writer.put(best_offset - 1, offset_bits);
writer.put_gamma(best_length - 1);
step = best_length;
} else {
writer.put(1, 1);
writer.put(in[i], 8);
}
for (size_t end = pos + step; pos != end; pos++)
insert(pos);
i += step;
}
return writer.finish();
}
size_t Lzss::expand(const uint8_t *in, size_t size, uint8_t *out, size_t capacity) const {
BitReader reader(in, size);
size_t length = 0;
while (reader.left() != 0) {
if (reader.get(1) != 0) {
size_t left = reader.left();
if (left < 8) {
// The padding: the rest must be 1 bits
return reader.get(left) == (1u << left) - 1 ? length : SIZE_MAX;
}
if (length == capacity)
return SIZE_MAX;
out[length++] = reader.get(8);
continue;
}
size_t behind = this->dictionary_size_ + length;
if (behind == 0)
return SIZE_MAX;
size_t offset_bits = std::bit_width(clamp_at_most(behind, WINDOW) - 1);
if (reader.left() < offset_bits)
return SIZE_MAX;
size_t distance = reader.get(offset_bits) + 1;
if (distance > behind)
return SIZE_MAX;
uint8_t zeros = 0;
for (;;) {
if (reader.left() == 0 || zeros > MAX_GAMMA_ZEROS)
return SIZE_MAX;
if (reader.get(1) != 0)
break;
zeros++;
}
if (reader.left() < zeros)
return SIZE_MAX;
size_t count = ((size_t{1} << zeros) | reader.get(zeros)) + 1;
if (count > capacity - length)
return SIZE_MAX;
// One byte at a time, as the match may overlap the bytes it is writing
for (; count != 0; count--, length++)
out[length] = this->byte_at_(out, this->dictionary_size_ + length - distance);
}
return length;
}
} // namespace esphome::lzss
+57
View File
@@ -0,0 +1,57 @@
#pragma once
#include <cstddef>
#include <cstdint>
namespace esphome::lzss {
/**
* LZSS compression of a block of data on its own, with a preset dictionary: text that both ends hold, which the
* block may copy from as if it came just before the block. Short blocks gain most from a dictionary that looks like
* them.
*
* The compressed data is a stream of bits, the first in bit 7 of each byte:
* - a 1 bit and 8 bits of a byte to copy;
* - a 0 bit, an offset back from the current position, and a length from 2 to MAX_MATCH. The offset less 1 takes
* as many bits as the number of bytes behind the current position, counting the dictionary but at most WINDOW,
* less 1 needs, so near the start of a block it takes few bits. The length less 1 is an Elias gamma code: one 0
* bit for each bit after the first, then the value.
* The last byte is padded with 1 bits, which read as the start of a byte to copy with too few bits left.
*/
class Lzss {
public:
/// The compressor finds earlier positions starting with the same two bytes through a hash table of this many bits.
static constexpr uint8_t HASH_BITS = 8;
/// How many earlier positions the compressor tries for each match; more finds longer matches, but takes longer.
static constexpr size_t MAX_CHAIN = 32;
/// Part of the format: a match reaches back at most this far, and offsets take the bits that the bytes behind the
/// current position need, counting at most this many; a power of 2.
static constexpr size_t WINDOW = 512;
/// The longest match, as the decoder reads a length code of at most 16 bits after the first.
static constexpr size_t MAX_MATCH = 65536;
/// The working space compress() needs: the latest position for each hash, then the previous one for each position
/// in the window.
static constexpr size_t CHAIN_WORDS = (size_t{1} << HASH_BITS) + WINDOW;
/// @param dictionary The preset dictionary, in flash; may be null when \p dictionary_size is 0
Lzss(const uint8_t *dictionary, size_t dictionary_size)
: dictionary_(dictionary), dictionary_size_(dictionary_size) {}
size_t dictionary_size() const { return this->dictionary_size_; }
/// Compress \p size bytes into \p out, which holds \p capacity bytes, using \p chains (CHAIN_WORDS words) as working
/// space; returns the length, or 0 if it does not fit.
size_t compress(const uint8_t *in, size_t size, uint8_t *out, size_t capacity, uint16_t *chains) const;
/// Expand \p size bytes into \p out, which holds \p capacity bytes; returns the length, or SIZE_MAX if the data is
/// malformed or expands to more than \p capacity.
size_t expand(const uint8_t *in, size_t size, uint8_t *out, size_t capacity) const;
protected:
/// The byte at \p pos counting from the start of the dictionary, with \p data following it.
uint8_t byte_at_(const uint8_t *data, size_t pos) const;
const uint8_t *dictionary_;
size_t dictionary_size_;
};
} // namespace esphome::lzss
+2 -1
View File
@@ -1,4 +1,5 @@
#include "modbus_helpers.h"
#include "esphome/core/helpers.h"
#include "esphome/core/log.h"
#include <algorithm>
@@ -471,7 +472,7 @@ PduBuffer create_client_pdu(FunctionCode function_code, uint16_t start_address,
values[1]);
return pdu;
}
append_pdu_header(pdu, function_code, start_address, uint16_t((values[0] << 8) | values[1]));
append_pdu_header(pdu, function_code, start_address, encode_uint16(values[0], values[1]));
return pdu;
}
// The quantity is spec-bounded above, so the data length just has to agree with it exactly
+303
View File
@@ -0,0 +1,303 @@
from collections.abc import Callable
from esphome import automation
import esphome.codegen as cg
from esphome.components import i2c
from esphome.components.const import CONF_CHARGE_CURRENT, CONF_ENABLED
import esphome.config_validation as cv
from esphome.const import CONF_DURATION, CONF_ID, CONF_MODE, CONF_VOLTAGE
from esphome.types import ConfigType
CODEOWNERS = ["@tomaszduda23"]
DEPENDENCIES = ["i2c"]
DOMAIN = "npm1300"
MULTI_CONF = True
CONF_NPM1300_ID = "npm1300_id"
CONF_VBUS_CURRENT_LIMIT = "vbus_current_limit"
CONF_THERMISTOR_RESISTANCE = "thermistor_resistance"
CONF_THERMISTOR_BETA = "thermistor_beta"
CONF_CHARGER = "charger"
CONF_TERMINATION_VOLTAGE = "termination_voltage"
CONF_WARM_TERMINATION_VOLTAGE = "warm_termination_voltage"
CONF_TERMINATION_CURRENT = "termination_current"
CONF_TRICKLE_VOLTAGE = "trickle_voltage"
CONF_DISCHARGE_CURRENT_LIMIT = "discharge_current_limit"
CONF_RECHARGE = "recharge"
CONF_BUCK1 = "buck1"
CONF_BUCK2 = "buck2"
CONF_LDO1 = "ldo1"
CONF_LDO2 = "ldo2"
npm1300_ns = cg.esphome_ns.namespace("npm1300")
NPM1300Component = npm1300_ns.class_(
"NPM1300Component", cg.PollingComponent, i2c.I2CDevice
)
NPM1300Output = npm1300_ns.enum("NPM1300Output", is_class=True)
NPM1300OutputConfig = npm1300_ns.struct("NPM1300OutputConfig")
NPM1300ChargerConfig = npm1300_ns.struct("NPM1300ChargerConfig")
NPM1300Config = npm1300_ns.struct("NPM1300Config")
NPM1300_CHILD_SCHEMA = cv.Schema(
{cv.GenerateID(CONF_NPM1300_ID): cv.use_id(NPM1300Component)}
)
# Status registers read on each update: VBUSINSTATUS, BCHGCHARGESTATUS and BCHGERRREASON
STATUS_PUBLISHER = cg.HubFunction(
"status",
cg.void,
[
(cg.uint8, "vbus_status"),
(cg.uint8, "charge_status"),
(cg.uint8, "error_reason"),
],
define="USE_NPM1300_STATUS_PUBLISHER",
)
VBUS_STATUS = STATUS_PUBLISHER.param("vbus_status")
CHARGE_STATUS = STATUS_PUBLISHER.param("charge_status")
ERROR_REASON = STATUS_PUBLISHER.param("error_reason")
# The ADC results and the amperes per code of the battery current
DATA_PUBLISHER = cg.HubFunction(
"data",
cg.void,
[(cg.uint8.operator("const").operator("ptr"), "adc"), (cg.float_, "ibat_scale")],
define="USE_NPM1300_DATA_PUBLISHER",
)
ADC = DATA_PUBLISHER.param("adc")
IBAT_SCALE = DATA_PUBLISHER.param("ibat_scale")
# The dump lines of the children decoded by the two functions above
DUMP = cg.HubFunction("dump", cg.void, [(cg.const_char_ptr, "tag")])
DUMP_TAG = DUMP.param("tag")
# Config key of each regulator and its NPM1300Output enumerator
OUTPUTS = NPM1300Output.options(
CONF_BUCK1, CONF_BUCK2, CONF_LDO1, CONF_LDO2, prefix="NPM1300_OUTPUT_"
)
# Written for a field the YAML leaves out
NPM1300_UNSET = 0xFF
# ADCNTCRSEL codes, by kiloohms
THERMISTOR_RESISTANCES = {10: 1, 47: 2, 100: 3}
LDO_MODES = {"load_switch": 0, "ldo": 1}
TERMINATION_CURRENTS = {"10%": 0, "20%": 1}
# BCHGVTRICKLESEL, by millivolts
TRICKLE_VOLTAGES = {2900: 0, 2500: 1}
# BCHGISETDISCHARGE codes, by milliamperes
DISCHARGE_CURRENT_LIMITS = {200: 84, 1000: 415}
# BCHGVTERM: 3.50 V to 3.65 V, then 4.00 V to 4.45 V, both in 50 mV steps
TERMINATION_VOLTAGES = [3500 + 50 * i for i in range(4)] + [
4000 + 50 * i for i in range(10)
]
# The wake-up timer counts 16 ms ticks in a 24-bit register
HIBERNATE_TICK_MS = 16
HIBERNATE_MAX_TICKS = 0xFFFFFF
def _millis(value: float) -> int:
return round(value * 1000)
def _one_of_units(
validator: Callable[[object], float],
allowed: list[int],
unit: str,
scale: float = 1000,
) -> Callable[[object], float]:
"""Validate a quantity with `validator` and accept only the listed values, given in units * `scale`."""
def validate(value: object) -> float:
value = validator(value)
if round(value * scale) not in allowed:
options = ", ".join(f"{v / scale:g}{unit}" for v in allowed)
raise cv.Invalid(f"Must be one of {options}")
return value
return validate
def _stepped(
validator: Callable[[object], float],
minimum: int,
maximum: int,
step: int,
unit: str,
) -> Callable[[object], float]:
"""Validate a quantity in a range of milli-units, in steps of `step`."""
allowed = list(range(minimum, maximum + 1, step))
in_range = cv.All(validator, cv.Range(min=minimum / 1000, max=maximum / 1000))
def validate(value: object) -> float:
value = in_range(value)
if _millis(value) not in allowed:
raise cv.Invalid(f"Must be a multiple of {step}m{unit}")
return value
return validate
OUTPUT_VOLTAGE = _stepped(cv.voltage, 1000, 3300, 100, "V")
VBUS_CURRENT_LIMIT = _stepped(cv.current, 100, 1500, 100, "A")
BUCK_SCHEMA = cv.Schema(
{
cv.Optional(CONF_VOLTAGE): OUTPUT_VOLTAGE,
cv.Optional(CONF_ENABLED): cv.boolean,
}
)
LDO_SCHEMA = BUCK_SCHEMA.extend(
{
cv.Optional(CONF_MODE): cv.enum(LDO_MODES, lower=True),
}
)
CHARGER_SCHEMA = cv.Schema(
{
cv.Required(CONF_CHARGE_CURRENT): _stepped(cv.current, 32, 800, 2, "A"),
cv.Optional(CONF_TERMINATION_VOLTAGE, default="4.2V"): _one_of_units(
cv.voltage, TERMINATION_VOLTAGES, "V"
),
cv.Optional(CONF_WARM_TERMINATION_VOLTAGE): _one_of_units(
cv.voltage, TERMINATION_VOLTAGES, "V"
),
cv.Optional(CONF_TERMINATION_CURRENT, default="10%"): cv.enum(
TERMINATION_CURRENTS
),
cv.Optional(CONF_TRICKLE_VOLTAGE, default="2.9V"): _one_of_units(
cv.voltage, list(TRICKLE_VOLTAGES), "V"
),
cv.Optional(CONF_DISCHARGE_CURRENT_LIMIT, default="1000mA"): _one_of_units(
cv.current, list(DISCHARGE_CURRENT_LIMITS), "A"
),
cv.Optional(CONF_RECHARGE, default=True): cv.boolean,
cv.Optional(CONF_ENABLED, default=True): cv.boolean,
}
)
CONFIG_SCHEMA = (
cv.Schema(
{
cv.GenerateID(): cv.declare_id(NPM1300Component),
cv.Optional(CONF_VBUS_CURRENT_LIMIT): VBUS_CURRENT_LIMIT,
cv.Optional(CONF_THERMISTOR_RESISTANCE): _one_of_units(
cv.resistance, list(THERMISTOR_RESISTANCES), "kOhm", scale=0.001
),
cv.Optional(CONF_THERMISTOR_BETA, default=3380): cv.int_range(
min=1, max=65535
),
cv.Optional(CONF_CHARGER): CHARGER_SCHEMA,
cv.Optional(CONF_BUCK1): BUCK_SCHEMA,
cv.Optional(CONF_BUCK2): BUCK_SCHEMA,
cv.Optional(CONF_LDO1): LDO_SCHEMA,
cv.Optional(CONF_LDO2): LDO_SCHEMA,
}
)
.extend(cv.polling_component_schema("60s"))
.extend(i2c.i2c_device_schema(0x6B))
)
def _termination_voltage_code(volts: float) -> int:
return TERMINATION_VOLTAGES.index(_millis(volts))
def _vbus_current_limit_code(amps: float) -> int:
"""VBUSINILIM0: 100 mA per step of the code."""
return _millis(amps) // 100
def _charger_config(config: ConfigType) -> cg.StructInitializer:
termination = _termination_voltage_code(config[CONF_TERMINATION_VOLTAGE])
warm = config.get(CONF_WARM_TERMINATION_VOLTAGE)
return cg.StructInitializer(
NPM1300ChargerConfig,
("current", _millis(config[CONF_CHARGE_CURRENT]) // 2),
(
"discharge_limit",
DISCHARGE_CURRENT_LIMITS[_millis(config[CONF_DISCHARGE_CURRENT_LIMIT])],
),
("termination_voltage", termination),
(
"warm_termination_voltage",
termination if warm is None else _termination_voltage_code(warm),
),
("trickle_voltage", TRICKLE_VOLTAGES[_millis(config[CONF_TRICKLE_VOLTAGE])]),
("termination_current", TERMINATION_CURRENTS[config[CONF_TERMINATION_CURRENT]]),
("recharge", config[CONF_RECHARGE]),
("enabled", config[CONF_ENABLED]),
)
def _output_config(config: ConfigType | None) -> cg.StructInitializer:
config = config or {}
voltage = config.get(CONF_VOLTAGE)
mode = config.get(CONF_MODE)
enabled = config.get(CONF_ENABLED)
return cg.StructInitializer(
NPM1300OutputConfig,
(
"voltage",
NPM1300_UNSET if voltage is None else (_millis(voltage) - 1000) // 100,
),
("ldo_mode", NPM1300_UNSET if mode is None else LDO_MODES[mode]),
("enabled", NPM1300_UNSET if enabled is None else int(enabled)),
)
def _config(config: ConfigType) -> cg.StructInitializer:
charger = config.get(CONF_CHARGER)
resistance = config.get(CONF_THERMISTOR_RESISTANCE)
return cg.StructInitializer(
NPM1300Config,
(
"outputs",
cg.ArrayInitializer(*(_output_config(config.get(key)) for key in OUTPUTS)),
),
("charger", None if charger is None else _charger_config(charger)),
("thermistor_beta", config[CONF_THERMISTOR_BETA]),
(
"thermistor",
NPM1300_UNSET
if resistance is None
else THERMISTOR_RESISTANCES[round(resistance / 1000)],
),
("charger_configured", charger is not None),
)
async def to_code(config: ConfigType) -> None:
# In flash: only setup() and dump_config() read it
table = cg.shared_progmem_array(
"npm1300_config", NPM1300Config, cg.ArrayInitializer(_config(config))
)
var = await i2c.new_i2c_component(config, table)
if (limit := config.get(CONF_VBUS_CURRENT_LIMIT)) is not None:
cg.add(var.set_vbus_current_limit(_vbus_current_limit_code(limit)))
automation.register_apply_action(
"npm1300.enter_ship_mode",
automation.maybe_simple_id({cv.Required(CONF_ID): cv.use_id(NPM1300Component)}),
automation.ApplyCall("enter_ship_mode()"),
)
automation.register_apply_action(
"npm1300.hibernate",
cv.Schema(
{
cv.Required(CONF_ID): cv.use_id(NPM1300Component),
cv.Required(CONF_DURATION): cv.templatable(
cv.All(
cv.positive_time_period_milliseconds,
cv.Range(
min=cv.TimePeriod(milliseconds=HIBERNATE_TICK_MS),
max=cv.TimePeriod(
milliseconds=HIBERNATE_TICK_MS * HIBERNATE_MAX_TICKS
),
),
)
),
}
),
automation.ApplyField(CONF_DURATION, "hibernate", cg.uint32),
)
+106
View File
@@ -0,0 +1,106 @@
from dataclasses import dataclass
from esphome.automation import parent_ref
import esphome.codegen as cg
from esphome.components import binary_sensor
import esphome.config_validation as cv
from esphome.const import (
DEVICE_CLASS_BATTERY_CHARGING,
DEVICE_CLASS_POWER,
DEVICE_CLASS_PROBLEM,
ENTITY_CATEGORY_DIAGNOSTIC,
)
from esphome.cpp_generator import HexIntLiteral
from esphome.types import ConfigType
from . import (
CHARGE_STATUS,
CONF_NPM1300_ID,
DUMP,
DUMP_TAG,
ERROR_REASON,
NPM1300_CHILD_SCHEMA,
STATUS_PUBLISHER,
VBUS_STATUS,
)
DEPENDENCIES = ["npm1300"]
@dataclass(frozen=True, kw_only=True)
class _StatusBits:
"""On when any bit of mask is set in the status register."""
key: str
register: cg.MockObj
mask: int
name: str
device_class: str = cv.UNDEFINED
entity_category: str = cv.UNDEFINED
_FIELDS = (
_StatusBits(
key="vbus_present",
register=VBUS_STATUS,
mask=0x01,
name="VBUS Present",
device_class=DEVICE_CLASS_POWER,
),
_StatusBits(
key="vbus_current_limit_active",
register=VBUS_STATUS,
mask=0x02,
name="VBUS Current Limit Active",
entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
),
# Trickle, constant current or constant voltage charging
_StatusBits(
key="charging",
register=CHARGE_STATUS,
mask=0x1C,
name="Charging",
device_class=DEVICE_CLASS_BATTERY_CHARGING,
),
_StatusBits(
key="charge_complete",
register=CHARGE_STATUS,
mask=0x02,
name="Charge Complete",
),
_StatusBits(
key="charger_error",
register=ERROR_REASON,
mask=0xFF,
name="Charger Error",
device_class=DEVICE_CLASS_PROBLEM,
entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
),
)
CONFIG_SCHEMA = NPM1300_CHILD_SCHEMA.extend(
{
cv.Optional(field.key): binary_sensor.binary_sensor_schema(
device_class=field.device_class, entity_category=field.entity_category
)
for field in _FIELDS
}
)
async def to_code(config: ConfigType) -> None:
hub = await cg.get_variable(config[CONF_NPM1300_ID])
sensors = binary_sensor.sub_binary_sensors(config)
for field in _FIELDS:
if (var := await sensors(field.key, None)) is not None:
state = (field.register & HexIntLiteral(field.mask)) != 0
STATUS_PUBLISHER.add(hub, parent_ref(var).publish_state(state))
DUMP.add(
hub,
binary_sensor.binary_sensor_ns.log_binary_sensor(
DUMP_TAG,
" ",
cg.RawExpression(f'LOG_STR_LITERAL("{field.name}")'),
parent_ref(var),
),
)
+483
View File
@@ -0,0 +1,483 @@
#include "npm1300.h"
#include <algorithm>
#include <cinttypes>
#include <cmath>
#include "esphome/core/hal.h"
#include "esphome/core/log.h"
#ifdef USE_TEXT_SENSOR
#include "esphome/core/progmem.h"
#endif
namespace esphome::npm1300 {
ESPHOME_LOG_TAG(TAG, "npm1300");
// Registers: the base address of the peripheral in the high byte, the offset in the low byte
static constexpr uint16_t REG_VBUSIN_TASK_UPDATE_ILIM = 0x0200;
static constexpr uint16_t REG_VBUSIN_ILIM0 = 0x0201;
static constexpr uint16_t REG_VBUSIN_ILIM_STARTUP = 0x0202;
static constexpr uint16_t REG_VBUSIN_STATUS = 0x0207;
static constexpr uint16_t REG_BCHG_TASK_RELEASE_ERR = 0x0300;
static constexpr uint16_t REG_BCHG_TASK_CLEAR_CHG_ERR = 0x0301;
static constexpr uint16_t REG_BCHG_ENABLE_SET = 0x0304;
static constexpr uint16_t REG_BCHG_ENABLE_CLR = 0x0305;
static constexpr uint16_t REG_BCHG_DISABLE_SET = 0x0306;
static constexpr uint16_t REG_BCHG_DISABLE_CLR = 0x0307;
static constexpr uint16_t REG_BCHG_ISET_MSB = 0x0308;
static constexpr uint16_t REG_BCHG_ISET_DISCHARGE_MSB = 0x030A;
static constexpr uint16_t REG_BCHG_VTERM = 0x030C;
static constexpr uint16_t REG_BCHG_VTERM_R = 0x030D;
static constexpr uint16_t REG_BCHG_VTRICKLE_SEL = 0x030E;
static constexpr uint16_t REG_BCHG_ITERM_SEL = 0x030F;
static constexpr uint16_t REG_BCHG_CHARGE_STATUS = 0x0334;
static constexpr uint16_t REG_BCHG_ERR_REASON = 0x0336;
static constexpr uint16_t REG_BUCK1_ENA_SET = 0x0400;
static constexpr uint16_t REG_BUCK1_NORM_VOUT = 0x0408;
static constexpr uint16_t REG_BUCK_SW_CTRL_SEL = 0x040F;
static constexpr uint16_t REG_BUCK_STATUS = 0x0434;
static constexpr uint16_t REG_ADC_TASK_VBAT = 0x0500;
static constexpr uint16_t REG_ADC_TASK_VBUS = 0x0507;
static constexpr uint16_t REG_ADC_NTC_R_SEL = 0x050A;
static constexpr uint16_t REG_ADC_TASK_AUTO_TIM_UPDATE = 0x050C;
static constexpr uint16_t REG_ADC_RESULTS = 0x0510;
static constexpr uint16_t REG_ADC_IBAT_MEAS_EN = 0x0524;
static constexpr uint16_t REG_TIMER_TARGET_STROBE = 0x0703;
static constexpr uint16_t REG_TIMER_CONFIG = 0x0705;
static constexpr uint16_t REG_TIMER_HI_BYTE = 0x0708;
static constexpr uint16_t REG_LDSW1_TASK_SET = 0x0800;
static constexpr uint16_t REG_LDSW_STATUS = 0x0804;
static constexpr uint16_t REG_LDSW1_LDO_SEL = 0x0808;
static constexpr uint16_t REG_LDSW1_VOUT_SEL = 0x080C;
static constexpr uint16_t REG_SHIP_TASK_HIBERNATE = 0x0B00;
static constexpr uint16_t REG_SHIP_TASK_SHIP_MODE = 0x0B02;
// VBUSINSTATUS
static constexpr uint8_t VBUS_PRESENT = 0x01;
// BCHGCHARGESTATUS; bit 0 (battery detected) is reserved since C00 silicon
static constexpr uint8_t CHARGE_STATUS_COMPLETED = 0x02;
static constexpr uint8_t CHARGE_STATUS_TRICKLE = 0x04;
static constexpr uint8_t CHARGE_STATUS_CONSTANT_CURRENT = 0x08;
static constexpr uint8_t CHARGE_STATUS_CONSTANT_VOLTAGE = 0x10;
static constexpr uint8_t CHARGE_STATUS_DIE_TEMP_HIGH = 0x40;
// BCHGDISABLESET and BCHGDISABLECLR
static constexpr uint8_t CHARGER_DISABLE_RECHARGE = 0x01;
static constexpr uint8_t CHARGER_DISABLE_NTC = 0x02;
// BUCKSTATUS power good, LDSWSTATUS powered up as load switch or as LDO
static constexpr uint8_t BUCK_POWER_GOOD[2] = {0x04, 0x40};
static constexpr uint8_t LDSW_POWERED[2] = {0x03, 0x0C};
// TIMERCONFIG: wake-up timer with the 16 ms prescaler
static constexpr uint8_t TIMER_CONFIG_WAKEUP = 0x04;
static constexpr uint32_t TIMER_TICK_MS = 16;
static constexpr uint32_t TIMER_MAX_TICKS = 0xFFFFFF;
// BCHGISETDISCHARGE codes up to this one select the 200 mA discharge limit, the others 1000 mA
static constexpr uint16_t DISCHARGE_LIMIT_200MA_CODE = 84;
static uint16_t discharge_limit_ma(uint16_t code) { return code <= DISCHARGE_LIMIT_200MA_CODE ? 200 : 1000; }
// BCHGISET and BCHGISETDISCHARGE hold a 9-bit code: the high 8 bits, then bit 0 in the next register
static void split_9bit(uint16_t code, uint8_t *out) {
out[0] = code >> 1;
out[1] = code & 1;
}
#ifdef USE_NPM1300_DATA_PUBLISHER
static uint16_t join_9bit(const uint8_t *in) { return (in[0] << 1) | (in[1] & 1); }
// ADCIBATMEASSTATUS
static constexpr uint8_t IBAT_MEAS_INVALID = 0x10;
static constexpr uint8_t IBAT_MODE_SHIFT = 2;
static constexpr uint8_t IBAT_MODE_DISCHARGE = 0x01;
static constexpr uint8_t IBAT_MODE_CHARGE = 0x03;
// Full scale of the battery current measurement per milliampere of the charge and discharge limits
static constexpr float CHARGE_FULL_SCALE_FACTOR = 1.25f;
static constexpr float DISCHARGE_FULL_SCALE_FACTOR = 1.12f;
static constexpr float ADC_MAX_CODE = 1023.0f;
// Five conversions of 250 us each; the loop runs the timeout later than this anyway
static constexpr uint32_t CONVERSION_TIME_MS = 2;
static constexpr uint32_t READ_TIMEOUT_ID = 0;
float ntc_temperature(uint16_t code, float inv_beta) {
if (code == 0)
return NAN;
// The NTC divider gives code = 1024 * R / (R + R_nominal)
return 1.0f / (1.0f / 298.15f - logf(1024.0f / code - 1.0f) * inv_beta) - 273.15f;
}
#endif
#ifdef USE_TEXT_SENSOR
PROGMEM_STRING_TABLE(ChargerStatusStrings, "Error", "Paused, Die Too Hot", "Charge Complete", "Trickle Charge",
"Constant Current", "Constant Voltage", "Discharging", "Not Charging");
// BCHGCHARGESTATUS bits in order of priority; bit i is reported as string i + 1
static const uint8_t CHARGER_STATUS_BITS[] PROGMEM = {CHARGE_STATUS_DIE_TEMP_HIGH, CHARGE_STATUS_COMPLETED,
CHARGE_STATUS_TRICKLE, CHARGE_STATUS_CONSTANT_CURRENT,
CHARGE_STATUS_CONSTANT_VOLTAGE};
static uint8_t charger_status_index(uint8_t vbus_status, uint8_t charge_status, uint8_t error_reason) {
if (error_reason != 0)
return 0;
for (size_t i = 0; i < sizeof(CHARGER_STATUS_BITS); i++) {
if ((charge_status & progmem_read_byte(&CHARGER_STATUS_BITS[i])) != 0)
return i + 1;
}
return (vbus_status & VBUS_PRESENT) == 0 ? 6 : 7;
}
void publish_charger_status(text_sensor::TextSensor *sensor, uint8_t &last, uint8_t vbus_status, uint8_t charge_status,
uint8_t error_reason) {
const uint8_t index = charger_status_index(vbus_status, charge_status, error_reason);
if (index == last)
return;
last = index;
sensor->publish_state(ChargerStatusStrings::get_progmem_str(index, ChargerStatusStrings::LAST_INDEX));
}
#endif
NPM1300Config NPM1300Component::load_config_() const {
NPM1300Config config;
progmem_memcpy(&config, this->config_, sizeof(config));
return config;
}
void NPM1300Component::setup() {
uint8_t status;
if (!this->setup_check(this->read_byte_reg16(REG_BCHG_CHARGE_STATUS, &status)))
return;
// Raise the VBUS current limit before anything turns on a regulator: at the power-on limit of 100 mA the
// inrush current of a regulator can trip the over-current protection and brown out the board
if (this->vbus_current_limit_ != NPM1300_UNSET &&
!this->setup_check(this->write_byte_reg16(REG_VBUSIN_ILIM_STARTUP, this->vbus_current_limit_) &&
this->apply_vbus_current_limit_()))
return;
const NPM1300Config config = this->load_config_();
if (config.thermistor != NPM1300_UNSET &&
!this->setup_check(this->write_byte_reg16(REG_ADC_NTC_R_SEL, config.thermistor)))
return;
if (config.charger_configured && !this->setup_check(this->configure_charger_(config)))
return;
for (uint8_t i = 0; i < NPM1300_OUTPUT_COUNT; i++) {
if (!this->setup_check(this->configure_output_(i, config.outputs[i])))
return;
}
#ifdef USE_NPM1300_DATA_PUBLISHER
if (this->data_publisher_ != nullptr) {
// The battery current is measured after every battery voltage measurement
if (!this->setup_check(this->write_byte_reg16(REG_ADC_IBAT_MEAS_EN, 1)))
return;
if (config.charger_configured) {
this->charge_code_ = config.charger.current;
this->discharge_limit_high_ = discharge_limit_ma(config.charger.discharge_limit) == 1000;
} else if (!this->setup_check(this->read_charge_currents_())) {
return;
}
}
#endif
this->update();
}
bool NPM1300Component::apply_vbus_current_limit_() {
return this->write_byte_reg16(REG_VBUSIN_ILIM0, this->vbus_current_limit_) &&
this->write_byte_reg16(REG_VBUSIN_TASK_UPDATE_ILIM, 1);
}
bool NPM1300Component::configure_charger_(const NPM1300Config &config) {
const NPM1300ChargerConfig &charger = config.charger;
// The charge settings are only taken while the charger is off
if (!this->write_byte_reg16(REG_BCHG_ENABLE_CLR, 1))
return false;
uint8_t current[2];
uint8_t discharge[2];
split_9bit(charger.current, current);
split_9bit(charger.discharge_limit, discharge);
uint8_t disable = charger.recharge ? 0 : CHARGER_DISABLE_RECHARGE;
// Without a thermistor the charger reports an NTC error and does not charge
if (config.thermistor == NPM1300_UNSET)
disable |= CHARGER_DISABLE_NTC;
const uint8_t enable = (CHARGER_DISABLE_RECHARGE | CHARGER_DISABLE_NTC) & ~disable;
if (this->write_register16(REG_BCHG_ISET_MSB, current, sizeof(current)) != i2c::ERROR_OK ||
this->write_register16(REG_BCHG_ISET_DISCHARGE_MSB, discharge, sizeof(discharge)) != i2c::ERROR_OK ||
!this->write_byte_reg16(REG_BCHG_VTERM, charger.termination_voltage) ||
!this->write_byte_reg16(REG_BCHG_VTERM_R, charger.warm_termination_voltage) ||
!this->write_byte_reg16(REG_BCHG_VTRICKLE_SEL, charger.trickle_voltage) ||
!this->write_byte_reg16(REG_BCHG_ITERM_SEL, charger.termination_current) ||
!this->write_byte_reg16(REG_BCHG_DISABLE_SET, disable) || !this->write_byte_reg16(REG_BCHG_DISABLE_CLR, enable) ||
// Measure the battery temperature automatically while charging
!this->write_byte_reg16(REG_ADC_TASK_AUTO_TIM_UPDATE, 1))
return false;
return !charger.enabled || this->set_charger_enabled(true);
}
bool NPM1300Component::configure_output_(uint8_t index, const NPM1300OutputConfig &config) {
const uint8_t channel = index & 1;
if (index < 2) {
// The software voltage replaces the one set by the VSET pin only once its SWCTRLSEL bit is set
if (config.voltage != NPM1300_UNSET &&
(!this->write_byte_reg16(REG_BUCK1_NORM_VOUT + channel * 2, config.voltage) ||
!this->update_register16(REG_BUCK_SW_CTRL_SEL, 1 << channel, 1 << channel)))
return false;
} else if ((config.voltage != NPM1300_UNSET &&
!this->write_byte_reg16(REG_LDSW1_VOUT_SEL + channel, config.voltage)) ||
(config.ldo_mode != NPM1300_UNSET &&
!this->write_byte_reg16(REG_LDSW1_LDO_SEL + channel, config.ldo_mode))) {
return false;
}
return config.enabled == NPM1300_UNSET ||
this->set_output_enabled(static_cast<NPM1300Output>(index), config.enabled != 0);
}
#ifdef USE_NPM1300_DATA_PUBLISHER
bool NPM1300Component::read_charge_currents_() {
uint8_t charge[2];
uint8_t discharge[2];
if (this->read_register16(REG_BCHG_ISET_MSB, charge, sizeof(charge)) != i2c::ERROR_OK ||
this->read_register16(REG_BCHG_ISET_DISCHARGE_MSB, discharge, sizeof(discharge)) != i2c::ERROR_OK)
return false;
this->charge_code_ = join_9bit(charge);
this->discharge_limit_high_ = discharge_limit_ma(join_9bit(discharge)) == 1000;
return true;
}
#endif
bool NPM1300Component::set_charger_enabled(bool enabled) {
if (this->is_failed())
return false;
if (!enabled)
return this->write_byte_reg16(REG_BCHG_ENABLE_CLR, 1);
// A charger error stops the charger until the error is cleared and the charger released
return this->write_byte_reg16(REG_BCHG_TASK_CLEAR_CHG_ERR, 1) &&
this->write_byte_reg16(REG_BCHG_TASK_RELEASE_ERR, 1) && this->write_byte_reg16(REG_BCHG_ENABLE_SET, 1);
}
bool NPM1300Component::set_output_enabled(NPM1300Output output, bool enabled) {
if (this->is_failed())
return false;
const uint8_t index = static_cast<uint8_t>(output);
// A pair of SET and CLR task registers per output
const uint16_t base = index < 2 ? REG_BUCK1_ENA_SET : REG_LDSW1_TASK_SET;
const uint16_t reg = base + (index & 1) * 2 + (enabled ? 0 : 1);
if (!this->write_byte_reg16(reg, 1)) {
ESP_LOGW(TAG, "Turning output %u %s failed", index, enabled ? LOG_STR_LITERAL("on") : LOG_STR_LITERAL("off"));
return false;
}
return true;
}
void NPM1300Component::enter_ship_mode() {
ESP_LOGI(TAG, "Entering ship mode");
this->write_byte_reg16(REG_SHIP_TASK_SHIP_MODE, 1);
}
void NPM1300Component::hibernate(uint32_t duration_ms) {
// A zero period would never wake the chip
const uint32_t ticks = std::clamp<uint32_t>(duration_ms / TIMER_TICK_MS, 1, TIMER_MAX_TICKS);
uint8_t timer[3];
put_be24(timer, ticks);
ESP_LOGI(TAG, "Hibernating for %" PRIu32 " ms", ticks * TIMER_TICK_MS);
if (!this->write_byte_reg16(REG_TIMER_CONFIG, TIMER_CONFIG_WAKEUP) ||
this->write_register16(REG_TIMER_HI_BYTE, timer, sizeof(timer)) != i2c::ERROR_OK ||
!this->write_byte_reg16(REG_TIMER_TARGET_STROBE, 1)) {
ESP_LOGW(TAG, "Setting the wake-up timer failed");
return;
}
// The timer needs a moment to load the new period
delay(1);
this->write_byte_reg16(REG_SHIP_TASK_HIBERNATE, 1);
}
void NPM1300Component::update() {
uint8_t vbus_status;
uint8_t charge_status;
uint8_t error_reason;
if (!this->status_comm_check(this->read_byte_reg16(REG_VBUSIN_STATUS, &vbus_status) &&
this->read_byte_reg16(REG_BCHG_CHARGE_STATUS, &charge_status) &&
this->read_byte_reg16(REG_BCHG_ERR_REASON, &error_reason)))
return;
// The chip goes back to its default VBUS current limit whenever VBUS is removed
const bool vbus_present = (vbus_status & VBUS_PRESENT) != 0;
if (vbus_present && !this->vbus_present_ && this->vbus_current_limit_ != NPM1300_UNSET &&
!this->status_comm_check(this->apply_vbus_current_limit_()))
return;
this->vbus_present_ = vbus_present;
if (error_reason != this->last_error_reason_) {
this->last_error_reason_ = error_reason;
if (error_reason != 0) {
ESP_LOGW(TAG, "Charger error, BCHGERRREASON 0x%02X", error_reason);
}
}
#ifdef USE_NPM1300_STATUS_PUBLISHER
if (this->status_publisher_ != nullptr)
this->status_publisher_(vbus_status, charge_status, error_reason);
#endif
#ifdef USE_SWITCH
if (!this->status_comm_check(this->publish_switches_()))
return;
#endif
#ifdef USE_SENSOR
if (this->vbus_current_limit_sensor_ != nullptr) {
uint8_t code;
if (!this->status_comm_check(this->read_byte_reg16(REG_VBUSIN_ILIM0, &code)))
return;
// 100 mA per step of the code, but code 0 is 500 mA
const uint16_t milliamps = code == 0 ? 500 : code * 100;
this->vbus_current_limit_sensor_->publish_state(milliamps / 1000.0f);
}
#endif
#ifdef USE_NPM1300_DATA_PUBLISHER
if (this->data_publisher_ != nullptr) {
// Start the battery voltage (followed by the battery current), NTC, die temperature and system voltage
// conversions, then the VBUS one
static constexpr uint8_t START[4] = {1, 1, 1, 1};
if (!this->status_comm_check(this->write_register16(REG_ADC_TASK_VBAT, START, sizeof(START)) == i2c::ERROR_OK &&
this->write_byte_reg16(REG_ADC_TASK_VBUS, 1)))
return;
this->set_timeout(READ_TIMEOUT_ID, CONVERSION_TIME_MS, [this]() { this->read_measurements_(); });
return;
}
#endif
this->status_comm_result(true);
}
#ifdef USE_SWITCH
bool NPM1300Component::publish_switches_() {
uint8_t value;
bool ok = true;
if (this->charger_switch_ != nullptr) {
if (this->read_byte_reg16(REG_BCHG_ENABLE_SET, &value)) {
this->charger_switch_->publish_state((value & 1) != 0);
} else {
ok = false;
}
}
switch_::Switch *const bucks[2] = {this->buck1_switch_, this->buck2_switch_};
if (bucks[0] != nullptr || bucks[1] != nullptr) {
if (this->read_byte_reg16(REG_BUCK_STATUS, &value)) {
for (uint8_t i = 0; i < 2; i++)
PUBLISH_STATE(bucks[i], (value & BUCK_POWER_GOOD[i]) != 0);
} else {
ok = false;
}
}
switch_::Switch *const ldos[2] = {this->ldo1_switch_, this->ldo2_switch_};
if (ldos[0] != nullptr || ldos[1] != nullptr) {
if (this->read_byte_reg16(REG_LDSW_STATUS, &value)) {
for (uint8_t i = 0; i < 2; i++)
PUBLISH_STATE(ldos[i], (value & LDSW_POWERED[i]) != 0);
} else {
ok = false;
}
}
return ok;
}
#endif
#ifdef USE_NPM1300_DATA_PUBLISHER
void NPM1300Component::read_measurements_() {
// ADCIBATMEASSTATUS, then the VBAT, NTC, TEMP and VSYS results, their low bits, VBAT0 to VBAT3 (VBAT2 holds the
// battery current and VBAT3 the VBUS voltage) and their low bits
uint8_t adc[11];
if (!this->status_comm_result(this->read_register16(REG_ADC_RESULTS, adc, sizeof(adc)) == i2c::ERROR_OK))
return;
// Amperes per code of the battery current, positive while charging and negative while discharging
float ibat_scale = NAN;
// Any other mode means the system runs from VBUS and the battery current is not measured
const uint8_t mode = (adc[0] >> IBAT_MODE_SHIFT) & 0x03;
if ((adc[0] & IBAT_MEAS_INVALID) == 0) {
if (mode == IBAT_MODE_CHARGE) {
ibat_scale = this->charge_code_ * (2 * CHARGE_FULL_SCALE_FACTOR) / (ADC_MAX_CODE * 1000.0f);
} else if (mode == IBAT_MODE_DISCHARGE) {
ibat_scale = -(this->discharge_limit_high_ ? 1000 : 200) * DISCHARGE_FULL_SCALE_FACTOR / (ADC_MAX_CODE * 1000.0f);
}
}
if (this->data_publisher_ != nullptr)
this->data_publisher_(adc, ibat_scale);
}
#endif
// BCHGVTERM: 3.50 V to 3.65 V, then 4.00 V to 4.45 V, both in 50 mV steps
static uint16_t termination_voltage_mv(uint8_t code) { return code < 4 ? 3500 + 50 * code : 4000 + 50 * (code - 4); }
static const LogString *output_name(uint8_t index) {
switch (static_cast<NPM1300Output>(index)) {
case NPM1300Output::NPM1300_OUTPUT_BUCK1:
return LOG_STR("BUCK1");
case NPM1300Output::NPM1300_OUTPUT_BUCK2:
return LOG_STR("BUCK2");
case NPM1300Output::NPM1300_OUTPUT_LDO1:
return LOG_STR("LDO1");
default:
return LOG_STR("LDO2");
}
}
void NPM1300Component::dump_config() {
ESP_LOGCONFIG(TAG, "nPM1300:");
LOG_I2C_DEVICE(this);
LOG_UPDATE_INTERVAL(this);
if (this->vbus_current_limit_ != NPM1300_UNSET) {
// 100 mA per step of the code
ESP_LOGCONFIG(TAG, " VBUS current limit: %u mA", this->vbus_current_limit_ * 100u);
}
const NPM1300Config config = this->load_config_();
if (config.charger_configured) {
const NPM1300ChargerConfig &charger = config.charger;
ESP_LOGCONFIG(TAG,
" Charger:\n"
" Current: %u mA\n"
" Discharge limit: %u mA\n"
" Termination voltage: %u mV\n"
" Warm termination voltage: %u mV\n"
" Termination current: %u%%\n"
" Trickle voltage: %u mV\n"
" Enabled: %s\n"
" Recharge: %s",
charger.current * 2u, discharge_limit_ma(charger.discharge_limit),
termination_voltage_mv(charger.termination_voltage),
termination_voltage_mv(charger.warm_termination_voltage), charger.termination_current ? 20u : 10u,
charger.trickle_voltage ? 2500u : 2900u, YESNO(charger.enabled), YESNO(charger.recharge));
}
for (uint8_t i = 0; i < NPM1300_OUTPUT_COUNT; i++) {
const NPM1300OutputConfig &output = config.outputs[i];
if (output.voltage == NPM1300_UNSET && output.ldo_mode == NPM1300_UNSET && output.enabled == NPM1300_UNSET)
continue;
ESP_LOGCONFIG(TAG, " %s:", LOG_STR_ARG(output_name(i)));
if (output.voltage != NPM1300_UNSET) {
ESP_LOGCONFIG(TAG, " Voltage: %u mV", 1000u + output.voltage * 100u);
}
if (output.ldo_mode != NPM1300_UNSET) {
ESP_LOGCONFIG(TAG, " Mode: %s",
output.ldo_mode != 0 ? LOG_STR_LITERAL("LDO") : LOG_STR_LITERAL("load switch"));
}
if (output.enabled != NPM1300_UNSET) {
ESP_LOGCONFIG(TAG, " Enabled at boot: %s", YESNO(output.enabled != 0));
}
}
if (config.thermistor != NPM1300_UNSET) {
ESP_LOGCONFIG(TAG, " Thermistor B constant: %u", config.thermistor_beta);
}
#ifdef USE_SENSOR
LOG_SENSOR(" ", "VBUS Current Limit", this->vbus_current_limit_sensor_);
#endif
#ifdef USE_SWITCH
LOG_SWITCH(" ", "Charger", this->charger_switch_);
LOG_SWITCH(" ", "BUCK1", this->buck1_switch_);
LOG_SWITCH(" ", "BUCK2", this->buck2_switch_);
LOG_SWITCH(" ", "LDO1", this->ldo1_switch_);
LOG_SWITCH(" ", "LDO2", this->ldo2_switch_);
#endif
#if defined(USE_NPM1300_STATUS_PUBLISHER) || defined(USE_NPM1300_DATA_PUBLISHER)
if (this->dump_publisher_ != nullptr)
this->dump_publisher_(TAG);
#endif
}
} // namespace esphome::npm1300
+145
View File
@@ -0,0 +1,145 @@
#pragma once
// Product specification: https://docs.nordicsemi.com/bundle/ps_npm1300/page/keyfeatures_html5.html
#include "esphome/components/i2c/i2c.h"
#include "esphome/core/component.h"
#include "esphome/core/defines.h"
#include "esphome/core/helpers.h"
#ifdef USE_SENSOR
#include "esphome/components/sensor/sensor.h"
#endif
#ifdef USE_TEXT_SENSOR
#include "esphome/components/text_sensor/text_sensor.h"
#endif
#ifdef USE_SWITCH
#include "esphome/components/switch/switch.h"
#endif
namespace esphome::npm1300 {
/// The regulators, in the order of their enable task registers
enum class NPM1300Output : uint8_t {
NPM1300_OUTPUT_BUCK1 = 0,
NPM1300_OUTPUT_BUCK2 = 1,
NPM1300_OUTPUT_LDO1 = 2,
NPM1300_OUTPUT_LDO2 = 3,
};
static constexpr uint8_t NPM1300_OUTPUT_COUNT = 4;
/// A configuration field the YAML leaves out, so the chip keeps its own value
static constexpr uint8_t NPM1300_UNSET = 0xFF;
/// Register codes for one regulator, NPM1300_UNSET where the YAML leaves the field out
struct NPM1300OutputConfig {
uint8_t voltage; // VOUT: (millivolts - 1000) / 100
uint8_t ldo_mode; // LDSWxLDOSEL, LDO1 and LDO2 only: 1 LDO, 0 load switch
uint8_t enabled; // turned on (1) or off (0) at boot
};
/// Register codes for the battery charger
struct NPM1300ChargerConfig {
uint16_t current; // BCHGISET: milliamperes / 2
uint16_t discharge_limit; // BCHGISETDISCHARGE: 84 for 200 mA, 415 for 1000 mA
uint8_t termination_voltage; // BCHGVTERM
uint8_t warm_termination_voltage; // BCHGVTERMR
uint8_t trickle_voltage; // BCHGVTRICKLESEL: 0 for 2.9 V, 1 for 2.5 V
uint8_t termination_current; // BCHGITERMSEL: 0 for 10 %, 1 for 20 %
bool recharge;
bool enabled;
};
/// The settings applied in setup(), built by code generation into a PROGMEM table
struct NPM1300Config {
NPM1300OutputConfig outputs[NPM1300_OUTPUT_COUNT];
NPM1300ChargerConfig charger; // only applied when charger_configured
uint16_t thermistor_beta;
uint8_t thermistor; // ADCNTCRSEL code: 1 for 10 kOhm, 2 for 47 kOhm, 3 for 100 kOhm, or NPM1300_UNSET
bool charger_configured;
};
#ifdef USE_NPM1300_DATA_PUBLISHER
/// The 10-bit ADC result whose high 8 bits are adc[msb] and low 2 bits are at `shift` in adc[lsbs]
inline uint16_t adc_code(const uint8_t *adc, uint8_t msb, uint8_t lsbs, uint8_t shift) {
return (adc[msb] << 2) | ((adc[lsbs] >> shift) & 0x03);
}
/// Battery temperature in degrees Celsius from the NTC code and 1 / B constant of the thermistor
float ntc_temperature(uint16_t code, float inv_beta);
#endif
#ifdef USE_TEXT_SENSOR
/// Publish the charger status text, only when it differs from `last`
void publish_charger_status(text_sensor::TextSensor *sensor, uint8_t &last, uint8_t vbus_status, uint8_t charge_status,
uint8_t error_reason);
#endif
class NPM1300Component : public PollingComponent, public i2c::I2CDevice {
#ifdef USE_SENSOR
SUB_SENSOR(vbus_current_limit)
#endif
#ifdef USE_SWITCH
SUB_SWITCH(charger)
SUB_SWITCH(buck1)
SUB_SWITCH(buck2)
SUB_SWITCH(ldo1)
SUB_SWITCH(ldo2)
#endif
public:
/// `config` points into PROGMEM
explicit NPM1300Component(const NPM1300Config *config) : config_(config) {}
void setup() override;
void update() override;
void dump_config() override;
// Right after the I2C bus: the regulators may power other peripherals
float get_setup_priority() const override { return setup_priority::BUS - 1.0f; }
#ifdef USE_NPM1300_STATUS_PUBLISHER
HUB_PUBLISHER(status, uint8_t, uint8_t, uint8_t)
#endif
#ifdef USE_NPM1300_DATA_PUBLISHER
HUB_PUBLISHER(data, const uint8_t *, float)
#endif
#if defined(USE_NPM1300_STATUS_PUBLISHER) || defined(USE_NPM1300_DATA_PUBLISHER)
HUB_PUBLISHER(dump, const char *)
#endif
/// VBUSINILIM0 code: 100 mA per step (code 0, the reset value, is 500 mA)
void set_vbus_current_limit(uint8_t code) { this->vbus_current_limit_ = code; }
/// Turn the battery charger on or off; turning it on also clears a charger error
bool set_charger_enabled(bool enabled);
/// Turn a regulator on or off
bool set_output_enabled(NPM1300Output output, bool enabled);
/// Enter ship mode: every output is turned off until the SHPHLD button is pressed or VBUS is connected
void enter_ship_mode();
/// Enter hibernate mode: every output is turned off for `duration_ms`, or until the SHPHLD button is
/// pressed or VBUS is connected
void hibernate(uint32_t duration_ms);
protected:
NPM1300Config load_config_() const;
bool apply_vbus_current_limit_();
bool configure_charger_(const NPM1300Config &config);
bool configure_output_(uint8_t index, const NPM1300OutputConfig &config);
#ifdef USE_NPM1300_DATA_PUBLISHER
bool read_charge_currents_();
void read_measurements_();
#endif
#ifdef USE_SWITCH
/// Returns false when a status read failed
bool publish_switches_();
#endif
const NPM1300Config *config_;
#ifdef USE_NPM1300_DATA_PUBLISHER
// BCHGISET code and discharge limit, for the full scale of the battery current measurement
uint16_t charge_code_{0};
bool discharge_limit_high_{false};
#endif
uint8_t vbus_current_limit_{NPM1300_UNSET};
uint8_t last_error_reason_{0};
bool vbus_present_{false};
};
} // namespace esphome::npm1300
+151
View File
@@ -0,0 +1,151 @@
from esphome.automation import parent_ref
import esphome.codegen as cg
from esphome.components import sensor
import esphome.config_validation as cv
from esphome.const import (
CONF_BATTERY_VOLTAGE,
CONF_ID,
DEVICE_CLASS_CURRENT,
DEVICE_CLASS_TEMPERATURE,
DEVICE_CLASS_VOLTAGE,
ENTITY_CATEGORY_DIAGNOSTIC,
STATE_CLASS_MEASUREMENT,
UNIT_AMPERE,
UNIT_CELSIUS,
UNIT_VOLT,
)
from esphome.core import CORE
import esphome.final_validate as fv
from esphome.types import ConfigType
from . import (
ADC,
CONF_NPM1300_ID,
CONF_THERMISTOR_BETA,
CONF_THERMISTOR_RESISTANCE,
CONF_VBUS_CURRENT_LIMIT,
DATA_PUBLISHER,
DOMAIN,
DUMP,
DUMP_TAG,
IBAT_SCALE,
NPM1300_CHILD_SCHEMA,
npm1300_ns,
)
DEPENDENCIES = ["npm1300"]
CONF_BATTERY_CURRENT = "battery_current"
CONF_BATTERY_TEMPERATURE = "battery_temperature"
CONF_DIE_TEMPERATURE = "die_temperature"
CONF_SYSTEM_VOLTAGE = "system_voltage"
CONF_VBUS_VOLTAGE = "vbus_voltage"
ADC_MAX_CODE = 1023
def _adc(msb: int, lsbs: int, shift: int) -> cg.MockObj:
"""The 10-bit result in adc[msb] and bits shift..shift+1 of adc[lsbs]."""
return npm1300_ns.adc_code(ADC, msb, lsbs, shift)
# The decoded value and the dump name of each ADC sensor but the battery temperature, which needs the hub config.
# Voltages scale by their full scale (product specification, section ADC).
STATES = {
CONF_BATTERY_VOLTAGE: (_adc(1, 5, 0) * (5.0 / ADC_MAX_CODE), "Battery Voltage"),
CONF_BATTERY_CURRENT: (_adc(8, 10, 4) * IBAT_SCALE, "Battery Current"),
# Product specification: T = 394.67 - 0.7926 * code
CONF_DIE_TEMPERATURE: (394.67 - 0.7926 * _adc(3, 5, 4), "Die Temperature"),
CONF_SYSTEM_VOLTAGE: (_adc(4, 5, 6) * (6.375 / ADC_MAX_CODE), "System Voltage"),
CONF_VBUS_VOLTAGE: (_adc(9, 10, 6) * (7.5 / ADC_MAX_CODE), "VBUS Voltage"),
}
def _voltage_schema() -> cv.Schema:
return sensor.sensor_schema(
unit_of_measurement=UNIT_VOLT,
accuracy_decimals=3,
device_class=DEVICE_CLASS_VOLTAGE,
state_class=STATE_CLASS_MEASUREMENT,
)
def _temperature_schema(**extra: str) -> cv.Schema:
return sensor.sensor_schema(
unit_of_measurement=UNIT_CELSIUS,
accuracy_decimals=1,
device_class=DEVICE_CLASS_TEMPERATURE,
state_class=STATE_CLASS_MEASUREMENT,
**extra,
)
CONFIG_SCHEMA = NPM1300_CHILD_SCHEMA.extend(
{
cv.Optional(CONF_BATTERY_VOLTAGE): _voltage_schema(),
cv.Optional(CONF_BATTERY_CURRENT): sensor.sensor_schema(
unit_of_measurement=UNIT_AMPERE,
accuracy_decimals=3,
device_class=DEVICE_CLASS_CURRENT,
state_class=STATE_CLASS_MEASUREMENT,
),
cv.Optional(CONF_BATTERY_TEMPERATURE): _temperature_schema(),
cv.Optional(CONF_DIE_TEMPERATURE): _temperature_schema(
entity_category=ENTITY_CATEGORY_DIAGNOSTIC
),
cv.Optional(CONF_SYSTEM_VOLTAGE): _voltage_schema(),
cv.Optional(CONF_VBUS_VOLTAGE): _voltage_schema(),
cv.Optional(CONF_VBUS_CURRENT_LIMIT): sensor.sensor_schema(
unit_of_measurement=UNIT_AMPERE,
accuracy_decimals=1,
device_class=DEVICE_CLASS_CURRENT,
entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
),
}
)
def _final_validate(config: ConfigType) -> None:
if CONF_BATTERY_TEMPERATURE not in config:
return
hub = fv.get_declaring_config(config[CONF_NPM1300_ID])
if CONF_THERMISTOR_RESISTANCE not in hub:
raise cv.Invalid(
f"'{CONF_BATTERY_TEMPERATURE}' needs '{CONF_THERMISTOR_RESISTANCE}' "
"set on the npm1300 component",
path=[CONF_BATTERY_TEMPERATURE],
)
FINAL_VALIDATE_SCHEMA = _final_validate
def _add_adc_sensor(
hub: cg.MockObj, var: cg.MockObj, state: cg.MockObj, name: str
) -> None:
DATA_PUBLISHER.add(hub, parent_ref(var).publish_state(state))
DUMP.add(
hub,
sensor.sensor_ns.log_sensor(
DUMP_TAG,
" ",
cg.RawExpression(f'LOG_STR_LITERAL("{name}")'),
parent_ref(var),
),
)
async def to_code(config: ConfigType) -> None:
hub_id = config[CONF_NPM1300_ID]
hub = await cg.get_variable(hub_id)
sensors = sensor.sub_sensors(config)
for key, (state, name) in STATES.items():
if (var := await sensors(key, None)) is not None:
_add_adc_sensor(hub, var, state, name)
if (var := await sensors(CONF_BATTERY_TEMPERATURE, None)) is not None:
hub_config = next(c for c in CORE.config[DOMAIN] if c[CONF_ID] == hub_id)
state = npm1300_ns.ntc_temperature(
_adc(2, 5, 2), 1.0 / hub_config[CONF_THERMISTOR_BETA]
)
_add_adc_sensor(hub, var, state, "Battery Temperature")
await sensors(CONF_VBUS_CURRENT_LIMIT, hub.set_vbus_current_limit_sensor)
+95
View File
@@ -0,0 +1,95 @@
import esphome.codegen as cg
from esphome.components import switch
import esphome.config_validation as cv
from esphome.const import ENTITY_CATEGORY_CONFIG
import esphome.final_validate as fv
from esphome.types import ConfigType
from . import (
CONF_BUCK1,
CONF_BUCK2,
CONF_CHARGER,
CONF_LDO1,
CONF_LDO2,
CONF_NPM1300_ID,
CONF_THERMISTOR_RESISTANCE,
NPM1300_CHILD_SCHEMA,
OUTPUTS,
)
DEPENDENCIES = ["npm1300"]
def _switch_schema() -> cv.Schema:
# The switches show the state of the chip, so nothing is restored at boot
return switch.switch_schema(
switch.ApplySwitch,
default_restore_mode="DISABLED",
entity_category=ENTITY_CATEGORY_CONFIG,
)
CONFIG_SCHEMA = NPM1300_CHILD_SCHEMA.extend(
{
cv.Optional(CONF_CHARGER): _switch_schema(),
cv.Optional(CONF_BUCK1): _switch_schema(),
cv.Optional(CONF_BUCK2): _switch_schema(),
cv.Optional(CONF_LDO1): _switch_schema(),
cv.Optional(CONF_LDO2): _switch_schema(),
}
)
def _final_validate(config: ConfigType) -> None:
if CONF_CHARGER not in config:
return
hub = fv.get_declaring_config(config[CONF_NPM1300_ID])
# Only the charger block turns off the NTC check, without which the charger never starts
if CONF_CHARGER not in hub and CONF_THERMISTOR_RESISTANCE not in hub:
raise cv.Invalid(
f"The '{CONF_CHARGER}' switch needs a '{CONF_CHARGER}' block or "
f"'{CONF_THERMISTOR_RESISTANCE}' on the npm1300 component",
path=[CONF_CHARGER],
)
FINAL_VALIDATE_SCHEMA = _final_validate
def _output_apply(key: str) -> str:
return f"set_output_enabled({OUTPUTS[key]}, state)"
async def to_code(config: ConfigType) -> None:
hub = await cg.get_variable(config[CONF_NPM1300_ID])
switches = switch.sub_switches(config, parent=hub)
await switches(
CONF_CHARGER,
hub.set_charger_switch,
apply="set_charger_enabled(state)",
publish="on_success",
)
await switches(
CONF_BUCK1,
hub.set_buck1_switch,
apply=_output_apply(CONF_BUCK1),
publish="on_success",
)
await switches(
CONF_BUCK2,
hub.set_buck2_switch,
apply=_output_apply(CONF_BUCK2),
publish="on_success",
)
await switches(
CONF_LDO1,
hub.set_ldo1_switch,
apply=_output_apply(CONF_LDO1),
publish="on_success",
)
await switches(
CONF_LDO2,
hub.set_ldo2_switch,
apply=_output_apply(CONF_LDO2),
publish="on_success",
)
+63
View File
@@ -0,0 +1,63 @@
from esphome.automation import parent_ref
import esphome.codegen as cg
from esphome.components import text_sensor
import esphome.config_validation as cv
from esphome.const import ICON_BATTERY
from esphome.cpp_generator import (
AssignmentExpression,
HexIntLiteral,
VariableDeclarationExpression,
)
from esphome.types import ConfigType
from . import (
CHARGE_STATUS,
CONF_NPM1300_ID,
DUMP,
DUMP_TAG,
ERROR_REASON,
NPM1300_CHILD_SCHEMA,
STATUS_PUBLISHER,
VBUS_STATUS,
npm1300_ns,
)
DEPENDENCIES = ["npm1300"]
CONF_CHARGER_STATUS = "charger_status"
CONFIG_SCHEMA = NPM1300_CHILD_SCHEMA.extend(
{
cv.Optional(CONF_CHARGER_STATUS): text_sensor.text_sensor_schema(
icon=ICON_BATTERY,
),
}
)
async def to_code(config: ConfigType) -> None:
hub = await cg.get_variable(config[CONF_NPM1300_ID])
text_sensors = text_sensor.sub_text_sensors(config)
if (var := await text_sensors(CONF_CHARGER_STATUS, None)) is None:
return
last = cg.MockObj(f"esphome__{var}__last")
# 0xFF so the first update publishes
declaration = VariableDeclarationExpression(cg.uint8, "", last, static=True)
STATUS_PUBLISHER.add(
hub, AssignmentExpression(None, None, declaration, HexIntLiteral(0xFF))
)
STATUS_PUBLISHER.add(
hub,
npm1300_ns.publish_charger_status(
parent_ref(var), last, VBUS_STATUS, CHARGE_STATUS, ERROR_REASON
),
)
DUMP.add(
hub,
text_sensor.text_sensor_ns.log_text_sensor(
DUMP_TAG,
" ",
cg.RawExpression('LOG_STR_LITERAL("Charger Status")'),
parent_ref(var),
),
)
+80 -16
View File
@@ -1,4 +1,4 @@
from collections.abc import Callable
from collections.abc import Callable, Iterator
import importlib
import pkgutil
from typing import Any
@@ -6,7 +6,7 @@ from typing import Any
import esphome.codegen as cg
from esphome.components.const import CONF_MAX_PACKET_SIZE
import esphome.config_validation as cv
from esphome.const import CONF_ID
from esphome.const import CONF_ID, CONF_TIMEOUT
from esphome.core import CORE, ID
from esphome.cpp_generator import MockObj, MockObjClass
import esphome.final_validate as fv
@@ -19,16 +19,20 @@ from .layers import (
CONF_ADDRESSING,
CONF_DESTINATION,
CONF_PEERS,
CONF_RELIABILITY,
CONF_SESSION,
STACK_ORDER,
PacketInterface,
build_stack,
check_packet_sizes,
check_session,
check_single_peer,
layer_needing_session,
packet_interface_ns,
stack_auto_load,
stack_schema,
)
from .layers.hdlc_reliability import DEFAULT_TIMEOUT, check_ack_delay
CODEOWNERS = ["@clydebarrow"]
DOMAIN = "packet_interface"
@@ -40,6 +44,9 @@ CONF_PACKET_INTERFACE = "packet_interface"
for module_info in pkgutil.iter_modules(layers.__path__):
importlib.import_module(f".layers.{module_info.name}", package=__package__)
# The layer keys that each link class does itself, by class name
_PROVIDED_LAYERS: dict[str, tuple[str, ...]] = {}
LINK_LAYER_SCHEMAS = {
cv.Optional(CONF_ADDRESSING): ADDRESSING.schema(),
**stack_schema(),
@@ -48,6 +55,7 @@ LINK_LAYER_SCHEMAS = {
__all__ = [
"CONF_MAX_PACKET_SIZE",
"CONF_PACKET_INTERFACE",
"interface_has_layer",
"interface_layers",
"interface_packet_size",
"PacketInterface",
@@ -64,7 +72,7 @@ def AUTO_LOAD(config: list[ConfigType] | None = None) -> list[str]:
Without a config, as tooling that lists dependencies calls it, everything a layer could load.
"""
if config is None:
return ["binary_sensor", "xxtea"]
return ["binary_sensor", "lzss", "xxtea"]
loads: set[str] = set()
for interface in config:
loads |= stack_auto_load(interface)
@@ -142,6 +150,14 @@ def interface_packet_size(interface_id: ID) -> int:
return check_packet_sizes(layers_config, size)
def interface_has_layer(interface_id: ID, key: str) -> bool:
"""During final validation, whether the packet interface with this id has the layer, configured or done by its link."""
link, layers_config = _find_interface(interface_id, fv.full_config.get())
return key in layers_config or key in _PROVIDED_LAYERS.get(
str(link[CONF_ID].type), ()
)
def final_validate_interface(key: str) -> Callable[[ConfigType], ConfigType]:
"""Final validation for an application: a link with peers must be used through one of the peers."""
@@ -158,25 +174,73 @@ def final_validate_interface(key: str) -> Callable[[ConfigType], ConfigType]:
return validator
def _check_provided_session(config: ConfigType) -> ConfigType:
"""A link's own session does not send packets through the layers, so none can need them from the peer."""
if key := layer_needing_session(config):
raise cv.Invalid(
f"This '{key}' needs packets from the peer, which this link does not send through its layers, "
"so it cannot be used on this link",
path=[key],
)
return config
def reliability_layers(config: ConfigType) -> Iterator[tuple[list, ConfigType]]:
"""The reliability layers on a link and in its peers, each with its path in the link's configuration."""
if (layer := config.get(CONF_RELIABILITY)) is not None:
yield [CONF_RELIABILITY], layer
for index, peer in enumerate(config.get(CONF_ADDRESSING, {}).get(CONF_PEERS, [])):
if (layer := peer.get(CONF_RELIABILITY)) is not None:
yield [CONF_ADDRESSING, CONF_PEERS, index, CONF_RELIABILITY], layer
def _check_default_ack_delays(config: ConfigType) -> ConfigType:
"""A reliability layer without a timeout uses the default one on this link."""
for path, layer in reliability_layers(config):
if CONF_TIMEOUT not in layer:
try:
check_ack_delay(layer, DEFAULT_TIMEOUT)
except cv.Invalid as err:
err.prepend(path)
raise
return config
def packet_interface_schema(
class_: MockObjClass,
default_max_packet_size: int,
max_packet_size_limit: int = 4096,
provides: tuple[str, ...] = (),
chooses_reliability_timeout: bool = False,
) -> cv.Schema:
"""Schema for a link platform, with the layers that can be stacked on it."""
return (
cv.Schema(
{
cv.GenerateID(): cv.declare_id(class_),
cv.Optional(
CONF_MAX_PACKET_SIZE, default=default_max_packet_size
): cv.int_range(16, max_packet_size_limit),
**LINK_LAYER_SCHEMAS,
}
"""Schema for a link platform; provides names the layer keys, such as reliability, that the link does itself.
chooses_reliability_timeout is for a link that works out a reliability timeout of its own, when none is set.
"""
if provides:
_PROVIDED_LAYERS[str(class_)] = provides
link_layers = {
key: (
cv.invalid(f"This link provides '{key}' itself, so it cannot be configured")
if key in provides
else schema
)
.extend(cv.COMPONENT_SCHEMA)
.add_extra(_validate_layers)
)
for key, schema in LINK_LAYER_SCHEMAS.items()
}
schema = cv.Schema(
{
cv.GenerateID(): cv.declare_id(class_),
cv.Optional(
CONF_MAX_PACKET_SIZE, default=default_max_packet_size
): cv.int_range(16, max_packet_size_limit),
**link_layers,
}
).extend(cv.COMPONENT_SCHEMA)
if CONF_SESSION in provides:
schema = schema.add_extra(_check_provided_session)
if not chooses_reliability_timeout:
schema = schema.add_extra(_check_default_ack_delays)
return schema.add_extra(_validate_layers)
async def new_packet_interface(config: ConfigType, *args: Any) -> MockObj:
@@ -60,6 +60,7 @@ class AddressingPort : public PacketInterface {
* packet to this device's own address is refused, as every receiver drops it.
*/
bool send_to_interface(const PacketBuffer &data, const PacketMetaData &meta_data) override;
size_t get_send_capacity() const override { return this->addressing_->get_link()->get_send_capacity(); }
uint16_t get_destination() const { return this->destination_; }
protected:
@@ -55,7 +55,7 @@ void BasicFragmentation::dump_config() {
" Fragments in the Largest Packet: %zu",
this->name_, this->max_packet_size_, this->fragment_size_(), fragments);
if (this->queue_too_short_) {
ESP_LOGW(TAG, " The reliability queue is too short for the largest packets, which cannot be sent");
ESP_LOGW(TAG, " The layer below has room for too few fragments for the largest packets, which cannot be sent");
}
}
@@ -88,8 +88,12 @@ bool BasicFragmentation::send_(const PacketBuffer &data, const PacketMetaData &m
header[1] = index | (index + 1 == fragments ? LAST_FRAGMENT : 0);
PacketBuffer body(this->tx_buffer_, length);
if (!this->lower_->send_to_interface(PacketBuffer(header, HEADER_SIZE, &body, nullptr, 0), meta_data)) {
// The peer drops the part already sent when the next packet starts
ESP_LOGV(TAG, "%s: Fragment %zu of %zu not accepted", this->name_, index, fragments);
if (index == 0) {
ESP_LOGV(TAG, "%s: Fragment 0 of %zu not accepted", this->name_, fragments);
} else {
// The peer drops the part already sent when the next packet starts
ESP_LOGW(TAG, "%s: Packet cut short, fragment %zu of %zu not accepted", this->name_, index, fragments);
}
return false;
}
}
@@ -161,7 +161,7 @@ bool HdlcReliability::send_supervisory_(uint8_t type) {
// components run between frames: on a radio, sending blocks, and the peer's frames are received in between. If the
// lower layer refuses the frame, it is sent again shortly.
bool HdlcReliability::send_pending_() {
if (this->vn_ == this->vs_)
if (this->vn_ == this->vs_ || (this->resend_held_ && this->vn_ != this->va_))
return true;
uint8_t control = (this->vn_ << 1) | (this->vr_ << 5);
if (!this->send_frame_(control, this->slot_(this->vn_), this->tx_lengths_[this->slot_index_(this->vn_)])) {
@@ -178,6 +178,15 @@ bool HdlcReliability::send_pending_() {
}
void HdlcReliability::resend_outstanding_() {
this->resend_held_ = false;
this->vn_ = this->va_;
this->send_pending_();
}
// Resending the whole queue after every timeout lets two peers whose acknowledgements were lost keep sending long
// bursts that collide again. The peer answers the oldest frame with its N(R), which also covers frames it already has.
void HdlcReliability::resend_oldest_() {
this->resend_held_ = true;
this->vn_ = this->va_;
this->send_pending_();
}
@@ -213,8 +222,8 @@ void HdlcReliability::on_timeout_() {
return;
}
this->retries_++;
ESP_LOGV(TAG, "%s: Timeout, resending %u frames", this->name_, this->outstanding_());
this->resend_outstanding_();
ESP_LOGV(TAG, "%s: Timeout, resending frame %u, %u unacknowledged", this->name_, this->va_, this->outstanding_());
this->resend_oldest_();
this->start_timer_();
}
@@ -228,6 +237,7 @@ void HdlcReliability::start_reset_() {
this->vr_ = 0;
this->retries_ = 0;
this->rej_sent_ = false;
this->resend_held_ = false;
this->ack_sent_();
this->cancel_timeout(RETRANSMIT_TIMER_ID);
this->request_loop_();
@@ -262,6 +272,11 @@ void HdlcReliability::process_ack_(uint8_t nr) {
this->head_ = (this->head_ + acked) % this->max_queue_length_;
this->va_ = nr;
this->retries_ = 0;
if (this->resend_held_) {
this->resend_held_ = false;
if (this->vn_ != this->vs_)
this->request_loop_();
}
if (this->outstanding_() == 0) {
this->cancel_timeout(RETRANSMIT_TIMER_ID);
} else {
@@ -283,7 +298,7 @@ void HdlcReliability::receive_(const PacketBuffer &data, const PacketMetaData &m
size_t length = frame.size() - FRAME_OVERHEAD;
uint8_t control = frame[0];
const uint8_t *payload = frame.data() + 1;
uint16_t crc = frame[length + 1] | (frame[length + 2] << 8);
uint16_t crc = encode_value_le<uint16_t>(frame.data() + length + 1);
if (frame_crc(control, payload, length) != crc) {
ESP_LOGV(TAG, "%s: CRC error, frame dropped", this->name_);
this->note_received_(false);
@@ -17,7 +17,8 @@ namespace esphome::packet_interface {
* - SABM resets both peers' sequence numbers, and UA answers it.
*
* Each frame is the HDLC control byte, the payload, then a CRC-16 of both in little endian order.
* Unacknowledged frames are resent after the timeout; after max_retries the link is reset.
* After the timeout the oldest unacknowledged frame is resent, and the rest follow once the peer answers it, so
* a lost acknowledgement costs one frame of airtime. After max_retries the link is reset.
*/
class HdlcReliability : public PacketInterface {
public:
@@ -63,6 +64,7 @@ class HdlcReliability : public PacketInterface {
bool send_supervisory_(uint8_t type);
bool send_pending_();
void resend_outstanding_();
void resend_oldest_();
void retry_send_();
/// An RR is owed: at once, or after the ack delay unless an I-frame carries it first.
void owe_ack_(bool now);
@@ -96,6 +98,7 @@ class HdlcReliability : public PacketInterface {
bool ack_pending_ : 1 {false}; // an RR is owed
bool ack_due_ : 1 {false}; // and should be sent now
bool rej_sent_ : 1 {false};
bool resend_held_ : 1 {false}; // only the oldest frame is resent until the peer acknowledges something
bool peer_frame_seen_ : 1 {false}; // a numbered frame has arrived since the link came up
bool oversize_warned_ : 1 {false};
bool reset_wait_logged_ : 1 {false}; // the queue filled while waiting for this reset to be answered
@@ -16,7 +16,13 @@ from typing import Any
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.const import CONF_ENCRYPTION, CONF_FRAGMENTATION, CONF_KEY, CONF_TYPE
from esphome.const import (
CONF_COMPRESSION,
CONF_ENCRYPTION,
CONF_FRAGMENTATION,
CONF_KEY,
CONF_TYPE,
)
from esphome.cpp_generator import Expression, MockObj
from esphome.types import ConfigType
@@ -166,9 +172,11 @@ ADDRESSING = LayerKind(CONF_ADDRESSING, "basic")
ENCRYPTION = LayerKind(CONF_ENCRYPTION, "xxtea", shorthand=CONF_KEY)
RELIABILITY = LayerKind(CONF_RELIABILITY, "hdlc")
FRAGMENTATION = LayerKind(CONF_FRAGMENTATION, "basic")
COMPRESSION = LayerKind(CONF_COMPRESSION, "lzss")
SESSION = LayerKind(CONF_SESSION, "basic")
# The kinds stacked above the link, or above each port of an addressing layer, from the bottom up
STACK_ORDER = (ENCRYPTION, RELIABILITY, FRAGMENTATION, SESSION)
# The kinds stacked above the link, or above each port of an addressing layer, from the bottom up. Compression is
# above encryption, as encrypted data does not compress, and above fragmentation, so a whole packet is compressed.
STACK_ORDER = (ENCRYPTION, RELIABILITY, FRAGMENTATION, COMPRESSION, SESSION)
def stack_schema() -> dict:
@@ -176,19 +184,24 @@ def stack_schema() -> dict:
return {cv.Optional(kind.key): kind.schema() for kind in STACK_ORDER}
def check_session(config: ConfigType) -> None:
"""Layers that need packets back from the peer need a session layer, whose keep-alives send them."""
if CONF_SESSION in config:
return
def layer_needing_session(config: ConfigType) -> str | None:
"""The key of the first layer in this stack that needs packets back from the peer, if any."""
for kind in STACK_ORDER:
if (layer := config.get(kind.key)) is not None and kind.get_type(
layer
).needs_session(layer):
raise cv.Invalid(
f"This '{kind.key}' needs packets from the peer, so it needs a '{CONF_SESSION}' layer, whose "
"keep-alives make sure they are sent",
path=[kind.key],
)
return kind.key
return None
def check_session(config: ConfigType) -> None:
"""Layers that need packets back from the peer need a session layer, whose keep-alives send them."""
if CONF_SESSION not in config and (key := layer_needing_session(config)):
raise cv.Invalid(
f"This '{key}' needs packets from the peer, so it needs a '{CONF_SESSION}' layer, whose "
"keep-alives make sure they are sent",
path=[key],
)
def check_single_peer(config: ConfigType, destination: int) -> None:
@@ -235,6 +248,21 @@ def check_packet_sizes(config: ConfigType, size: int) -> int:
return size
def check_broadcast_link(config: ConfigType) -> None:
"""On a link that every device hears, layers that keep state for one peer need an addressing layer."""
if CONF_ADDRESSING in config:
return
for kind in STACK_ORDER:
if (layer := config.get(kind.key)) is not None and kind.get_type(
layer
).single_peer(layer):
raise cv.Invalid(
f"This '{kind.key}' works between two devices only, but every device hears this link, so it needs "
f"'{CONF_ADDRESSING}' with a '{CONF_DESTINATION}'",
path=[kind.key],
)
def stack_auto_load(config: ConfigType) -> set[str]:
"""The components that the layers configured in config need loaded."""
loads: set[str] = set()
@@ -22,18 +22,25 @@ CONF_MAX_RETRIES = "max_retries"
# The control byte and the CRC-16
FRAME_OVERHEAD = 3
# Unless the link works out a longer one from how long its packets take, as a radio link does
DEFAULT_TIMEOUT = cv.TimePeriodMilliseconds(milliseconds=200)
HdlcReliability = packet_interface_ns.class_("HdlcReliability", PacketInterface)
def _ack_delay_within_timeout(config: ConfigType) -> ConfigType:
def check_ack_delay(config: ConfigType, timeout: cv.TimePeriod) -> None:
"""The peer, configured the same, must hear the acknowledgement before its timeout."""
if (
config[CONF_ACK_DELAY].total_milliseconds
>= config[CONF_TIMEOUT].total_milliseconds
):
if config[CONF_ACK_DELAY].total_milliseconds >= timeout.total_milliseconds:
raise cv.Invalid(
f"Must be shorter than '{CONF_TIMEOUT}'", path=[CONF_ACK_DELAY]
f"Must be shorter than '{CONF_TIMEOUT}', which is {timeout.total_milliseconds}ms",
path=[CONF_ACK_DELAY],
)
def _ack_delay_within_timeout(config: ConfigType) -> ConfigType:
# Without a timeout, the link checks against the one it chooses
if (timeout := config.get(CONF_TIMEOUT)) is not None:
check_ack_delay(config, timeout)
return config
@@ -42,7 +49,7 @@ HDLC_SCHEMA = cv.All(
{
cv.GenerateID(): cv.declare_id(HdlcReliability),
# Retransmitting more often than the main loop runs would exhaust the retries at once
cv.Optional(CONF_TIMEOUT, default="200ms"): cv.All(
cv.Optional(CONF_TIMEOUT): cv.All(
cv.positive_time_period_milliseconds,
cv.Range(min=cv.TimePeriod(milliseconds=50)),
),
@@ -76,7 +83,7 @@ async def build_hdlc(
psram=True,
)
var = cg.new_Pvariable(config[CONF_ID], lower, tx_slots, queue_length)
cg.add(var.set_ack_timeout(config[CONF_TIMEOUT]))
cg.add(var.set_ack_timeout(config.get(CONF_TIMEOUT, DEFAULT_TIMEOUT)))
cg.add(var.set_ack_delay(config[CONF_ACK_DELAY]))
cg.add(var.set_max_retries(config[CONF_MAX_RETRIES]))
await cg.register_component(var, config)
@@ -0,0 +1,112 @@
"""Compression layer using LZSS with a preset dictionary, compressing each packet on its own."""
import zlib
import esphome.codegen as cg
from esphome.components.const import CONF_MAX_PACKET_SIZE
from esphome.components.lzss import MAX_DICTIONARY_SIZE, shared_chains
import esphome.config_validation as cv
from esphome.const import CONF_ID
from esphome.cpp_generator import MockObj
from esphome.types import ConfigType
from . import (
COMPRESSION,
Layer,
PacketInterface,
PacketSize,
packet_interface_ns,
remaining_packet_size,
)
CONF_DICTIONARY = "dictionary"
# Whether the packet is compressed, and the dictionary check
HEADER_SIZE = 1
# The smallest max_packet_size, which a packet sent as it is must also fit
MIN_ROOM = 16
# Pieces common in JSON, for when no dictionary is given. One made from a typical packet of the application does much
# better, as most of a short packet is then copied from it.
DEFAULT_DICTIONARY = (
'{"name":"","value":,"state":"ON","OFF","unit":"","id":"","type":"temperature","humidity",'
'"time":"","status":"ok","error":null,"enabled":true,"false},{"":[{""}]}'
)
LzssCompression = packet_interface_ns.class_("LzssCompression", PacketInterface)
LZSS_SCHEMA = cv.Schema(
{
cv.GenerateID(): cv.declare_id(LzssCompression),
# Text that both ends hold, which packets copy from; both ends must have the same
cv.Optional(CONF_DICTIONARY, default=DEFAULT_DICTIONARY): cv.All(
cv.string_strict, cv.ByteLength(max=MAX_DICTIONARY_SIZE)
),
# A packet larger than the layer below takes is sent only if it compresses enough
cv.Optional(CONF_MAX_PACKET_SIZE): cv.int_range(MIN_ROOM, 16384),
}
).extend(cv.COMPONENT_SCHEMA)
def _packet_size(config: ConfigType, size: int) -> int:
return config.get(CONF_MAX_PACKET_SIZE, remaining_packet_size(size, HEADER_SIZE))
def _check_lower(config: ConfigType, size: int, capacity: int | None) -> None:
if size <= HEADER_SIZE:
raise cv.Invalid("The layers below leave no room for compressed packets")
# Layers above are sized by max_packet_size, and a packet that does not compress is sent as it is
if CONF_MAX_PACKET_SIZE in config and size - HEADER_SIZE < MIN_ROOM:
raise cv.Invalid(
f"With '{CONF_MAX_PACKET_SIZE}', the layers below must leave at least {MIN_ROOM} bytes after the "
"header, so packets that do not compress can still be sent",
path=[CONF_MAX_PACKET_SIZE],
)
def dictionary_check(dictionary: bytes) -> int:
"""Seven bits that differ between most dictionaries, sent in every header."""
return zlib.crc32(dictionary) & 0x7F
@COMPRESSION.register(
"lzss",
schema=LZSS_SCHEMA,
packet_size=_packet_size,
check_lower=_check_lower,
auto_load=lambda config: ["lzss"],
)
async def build_lzss(
config: ConfigType, lower: MockObj, lower_size: PacketSize
) -> Layer:
cg.add_define("USE_PACKET_INTERFACE_LZSS")
dictionary = config[CONF_DICTIONARY].encode()
table = (
cg.shared_progmem_array(
"packet_interface_dictionary", cg.uint8, list(dictionary)
)
if dictionary
else cg.nullptr
)
max_packet_size = config.get(CONF_MAX_PACKET_SIZE, 0)
buffers = cg.static_buffer(
config[CONF_ID],
cg.uint8,
LzssCompression.static_("buffer_size")(lower_size, max_packet_size),
psram=True,
)
chains = shared_chains()
var = cg.new_Pvariable(
config[CONF_ID],
lower,
max_packet_size,
table,
len(dictionary),
dictionary_check(dictionary),
buffers,
chains,
)
await cg.register_component(var, config)
if (size := config.get(CONF_MAX_PACKET_SIZE)) is not None:
return var, size
return var, LzssCompression.static_("packet_size")(lower_size)
@@ -0,0 +1,64 @@
#pragma once
#include <cstdint>
namespace esphome::packet_interface {
/**
* Decides whether a half-duplex radio link may send while its radio reports that it is receiving a packet.
*
* Sending is refused while the radio is busy, so the packet being received is not lost. A busy period starts when a
* send first finds the radio busy, and ends when a send finds it free or end_busy() is called. Once a busy period has
* lasted max_busy_ms, sends go ahead, so a busy flag that never clears cannot stop sending for good, however often
* sends are tried. Code generation sets max_busy_ms from the time the radio takes to receive the largest packet.
*
* On a link whose peer replies, sending also takes turns: after a send, a send in a later loop pass waits up to
* turnaround_ms, the time the peer takes to start a reply and the radio to notice it, unless a packet arrives first.
* Without this, the next frame of a burst goes out on top of the peer's acknowledgement. Sends in the same loop pass,
* such as the fragments of one packet, are not held back.
*/
class ListenBeforeTalk {
public:
static constexpr uint32_t DEFAULT_MAX_BUSY_MS = 2000;
void set_max_busy(uint32_t max_busy_ms) { this->max_busy_ms_ = max_busy_ms; }
uint32_t get_max_busy() const { return this->max_busy_ms_; }
void set_turnaround(uint32_t turnaround_ms) { this->turnaround_ms_ = turnaround_ms; }
/// True if a packet may be sent at \p now, in the loop pass that started at \p pass; \p busy says whether the
/// radio is receiving.
bool may_send(bool busy, uint32_t now, uint32_t pass) {
if (!busy) {
this->busy_ = false;
return !this->turn_held_ || pass == this->sent_pass_ || now - this->sent_ms_ >= this->turnaround_ms_;
}
if (!this->busy_) {
this->busy_ = true;
this->busy_since_ms_ = now;
}
return now - this->busy_since_ms_ >= this->max_busy_ms_;
}
/// Ends the busy period, when the radio is seen to be free other than by a send.
void end_busy() { this->busy_ = false; }
/// A packet was sent, ending at \p now, in the loop pass that started at \p pass.
void sent(uint32_t now, uint32_t pass) {
this->turn_held_ = this->turnaround_ms_ != 0;
this->sent_ms_ = now;
this->sent_pass_ = pass;
}
/// A packet arrived, so the peer has taken its turn.
void received() { this->turn_held_ = false; }
/// How long the current busy period has lasted at \p now.
uint32_t busy_for(uint32_t now) const { return now - this->busy_since_ms_; }
protected:
uint32_t busy_since_ms_{0};
uint32_t max_busy_ms_{DEFAULT_MAX_BUSY_MS};
uint32_t sent_ms_{0};
uint32_t sent_pass_{0};
uint32_t turnaround_ms_{0};
bool busy_{false};
bool turn_held_{false};
};
} // namespace esphome::packet_interface
@@ -0,0 +1,116 @@
#include "lzss_compression.h"
#ifdef USE_PACKET_INTERFACE_LZSS
#include "esphome/core/helpers.h"
#include "esphome/core/log.h"
namespace esphome::packet_interface {
ESPHOME_LOG_TAG(TAG, "packet_interface.lzss");
LzssCompression::LzssCompression(PacketInterface *lower, size_t max_packet_size, const uint8_t *dictionary,
size_t dictionary_size, uint8_t check, uint8_t *buffers, uint16_t *chains)
: PacketInterface(max_packet_size != 0 ? max_packet_size : packet_size(lower->get_max_packet_size())),
check_(check & HEADER_CHECK_MASK),
lower_(lower),
codec_(dictionary, dictionary_size),
tx_input_(buffers),
chains_(chains) {
this->stack_on_(lower, CAPABILITY_COMPRESSION);
}
void LzssCompression::setup() {
size_t lower_size = this->lower_->get_max_packet_size();
if (!this->setup_check(this->max_packet_size_ != 0 && lower_size > HEADER_SIZE,
LOG_STR("max_packet_size too small for the configured layers")))
return;
if (!this->setup_check(this->tx_input_ != nullptr && this->chains_ != nullptr,
LOG_STR("Not enough memory for the packet buffers")))
return;
this->rx_output_ = this->tx_input_ + this->max_packet_size_;
this->tx_output_ = this->rx_output_ + this->max_packet_size_;
this->lower_->add_packet_interface_listener(
[this](const PacketBuffer &data, const PacketMetaData &meta_data) { this->receive_(data, meta_data); });
}
void LzssCompression::dump_config() {
ESP_LOGCONFIG(TAG,
"LZSS Compression on '%s':\n"
" Max Packet Size: %zu\n"
" Dictionary Size: %zu\n"
" Dictionary Check: 0x%02X",
this->name_, this->max_packet_size_, this->codec_.dictionary_size(), this->check_);
}
bool LzssCompression::send_to_interface(const PacketBuffer &data, const PacketMetaData &meta_data) {
return this->send_exclusive_([&] { return this->send_(data, meta_data); });
}
bool LzssCompression::send_(const PacketBuffer &data, const PacketMetaData &meta_data) {
if (this->tx_output_ == nullptr)
return false;
size_t size = data.size();
if (size > this->max_packet_size_) {
ESP_LOGW(TAG, "%s: Packet of %zu bytes is larger than %zu", this->name_, size, this->max_packet_size_);
return false;
}
const uint8_t *in = this->tx_input_;
if (data.is_contiguous()) {
in = data.as_span().data();
} else {
data.copy_to(this->tx_input_, size);
}
size_t room = this->lower_->get_max_packet_size() - HEADER_SIZE;
// Compressed only if that makes it smaller
size_t length = size > 1 ? this->codec_.compress(in, size, this->tx_output_ + HEADER_SIZE,
clamp_at_most(room, size - 1), this->chains_)
: 0;
if (length != 0) {
ESP_LOGV(TAG, "%s: Packet of %zu bytes compressed to %zu", this->name_, size, length);
this->tx_output_[0] = HEADER_COMPRESSED | this->check_;
return this->lower_->send_to_interface(PacketBuffer(this->tx_output_, length + HEADER_SIZE), meta_data);
}
if (size > room) {
ESP_LOGW(TAG, "%s: Packet of %zu bytes does not compress to %zu", this->name_, size, room);
return false;
}
uint8_t header = this->check_;
return this->lower_->send_to_interface(PacketBuffer(&header, HEADER_SIZE, &data, nullptr, 0), meta_data);
}
void LzssCompression::receive_(const PacketBuffer &data, const PacketMetaData &meta_data) {
// Lower layers deliver packets in one piece
if (!data.is_contiguous()) {
ESP_LOGW(TAG, "%s: Packet split across buffers is not supported", this->name_);
this->note_received_(false);
return;
}
auto packet = data.as_span();
if (packet.size() < HEADER_SIZE || (packet[0] & HEADER_CHECK_MASK) != this->check_) {
ESP_LOGV(TAG, "%s: Packet of %zu bytes with another dictionary dropped", this->name_, packet.size());
this->note_received_(false);
return;
}
const uint8_t *body = packet.data() + HEADER_SIZE;
size_t size = packet.size() - HEADER_SIZE;
if ((packet[0] & HEADER_COMPRESSED) == 0) {
if (size > this->max_packet_size_) {
ESP_LOGV(TAG, "%s: Packet of %zu bytes is larger than %zu", this->name_, size, this->max_packet_size_);
this->note_received_(false);
return;
}
this->note_received_(true);
this->on_receive_from_interface_(PacketBuffer(body, size), meta_data);
return;
}
size_t length = this->codec_.expand(body, size, this->rx_output_, this->max_packet_size_);
if (length == SIZE_MAX) {
ESP_LOGV(TAG, "%s: Malformed packet of %zu bytes dropped", this->name_, packet.size());
this->note_received_(false);
return;
}
this->note_received_(true);
this->on_receive_from_interface_(PacketBuffer(this->rx_output_, length), meta_data);
}
} // namespace esphome::packet_interface
#endif
@@ -0,0 +1,64 @@
#pragma once
#include "esphome/core/defines.h"
#ifdef USE_PACKET_INTERFACE_LZSS
#include "esphome/components/lzss/lzss.h"
#include "packet_interface.h"
namespace esphome::packet_interface {
/**
* A compression layer: each packet is compressed on its own with LZSS, so a lost packet costs nothing more.
*
* Packets are short, so most of what can be saved comes from a preset dictionary: text that both ends hold, which a
* packet may copy from as if it came just before the packet. For JSON, a typical packet makes a good dictionary.
*
* A packet starts with a header byte: bit 7 is set when the rest is compressed and clear when it is sent as it is,
* because compressing did not make it smaller; bits 0-6 are a check of the dictionary, so a peer with another
* dictionary drops the packet rather than passing up garbage. The compressed data is in the format of lzss::Lzss.
*/
class LzssCompression : public PacketInterface {
public:
/// The bit flagging compressed data, and the dictionary check in the bits below it.
static constexpr uint8_t HEADER_COMPRESSED = 0x80;
static constexpr uint8_t HEADER_CHECK_MASK = 0x7F;
static constexpr size_t HEADER_SIZE = 1;
/// The largest packet the layer takes by default, over a layer below whose largest packet is \p lower_size.
static constexpr size_t packet_size(size_t lower_size) { return remaining_packet_size(lower_size, HEADER_SIZE); }
static constexpr size_t CHAIN_WORDS = lzss::Lzss::CHAIN_WORDS;
/// The packet to compress, the compressed packet, and an expanded packet.
static constexpr size_t buffer_size(size_t lower_size, size_t max_packet_size) {
return 2 * (max_packet_size != 0 ? max_packet_size : packet_size(lower_size)) + lower_size;
}
/**
* @param max_packet_size The largest packet before compression, or 0 for what the layer below takes less the
* header; a packet larger than that is refused when it does not compress enough
* @param dictionary The preset dictionary, in flash; may be null when \p dictionary_size is 0
* @param check The dictionary check sent in each header
* @param buffers buffer_size() bytes, and \p chains CHAIN_WORDS words; setup() fails if either is nullptr
*/
LzssCompression(PacketInterface *lower, size_t max_packet_size, const uint8_t *dictionary, size_t dictionary_size,
uint8_t check, uint8_t *buffers, uint16_t *chains);
void setup() override;
void dump_config() override;
bool send_to_interface(const PacketBuffer &data, const PacketMetaData &meta_data) override;
protected:
void receive_(const PacketBuffer &data, const PacketMetaData &meta_data);
bool send_(const PacketBuffer &data, const PacketMetaData &meta_data);
// First, so it fills the spare byte at the end of PacketInterface
const uint8_t check_;
PacketInterface *lower_;
const lzss::Lzss codec_;
uint8_t *tx_input_;
uint8_t *tx_output_{nullptr}; // set once setup() succeeds
uint8_t *rx_output_{nullptr};
uint16_t *chains_;
};
} // namespace esphome::packet_interface
#endif
@@ -22,6 +22,7 @@ enum Capability : uint8_t {
CAPABILITY_SESSION = 1 << 2,
CAPABILITY_ADDRESSING = 1 << 3,
CAPABILITY_FRAGMENTATION = 1 << 4,
CAPABILITY_COMPRESSION = 1 << 5,
};
/**
@@ -0,0 +1,70 @@
#include "radio_link.h"
#include <cinttypes>
#include "esphome/core/application.h"
#include "esphome/core/log.h"
namespace esphome::packet_interface {
ESPHOME_LOG_TAG(TAG, "packet_interface.radio");
bool RadioLinkBase::check_size_(size_t size) const {
if (size <= this->max_packet_size_)
return true;
ESP_LOGW(TAG, "Packet of %zu bytes is larger than %zu", size, this->max_packet_size_);
return false;
}
bool RadioLinkBase::may_send_(bool busy) {
if (busy)
this->enable_loop();
return this->listen_before_talk_.may_send(busy, this->current_time_ms(), App.get_loop_component_start_time());
}
bool RadioLinkBase::sent_(bool sent, bool busy) {
if (busy) {
uint32_t busy_ms = this->listen_before_talk_.busy_for(this->current_time_ms());
// The radio listens again, and a reception that starts now must be waited for afresh
this->listen_before_talk_.end_busy();
// The limit is longer than any packet takes, so the radio's busy indication is stuck or the channel is jammed
ESP_LOGW(TAG, "Radio busy for %" PRIu32 "ms, %s", busy_ms,
sent ? LOG_STR_LITERAL("sent anyway") : LOG_STR_LITERAL("tried to send anyway, which failed"));
}
if (sent)
this->listen_before_talk_.sent(this->current_time_ms(), App.get_loop_component_start_time());
return sent;
}
bool RadioLinkBase::skip_empty_() const {
ESP_LOGV(TAG, "Empty packet not sent");
return true;
}
void RadioLinkBase::radio_not_ready_(bool failed) {
if (!failed || this->failed_warned_)
return;
this->failed_warned_ = true;
ESP_LOGW(TAG, "%s: The radio failed to set up, so nothing can be sent", this->name_);
}
void RadioLinkBase::radio_free_() {
this->listen_before_talk_.end_busy();
this->disable_loop();
}
void RadioLinkBase::receive_(const std::vector<uint8_t> &packet, float rssi, float snr) {
// The radio takes packets up to its own limit, so a larger one is from a device configured differently
if (packet.size() > this->max_packet_size_) {
ESP_LOGV(TAG, "%s: Packet of %zu bytes is larger than %zu, dropped", this->name_, packet.size(),
this->max_packet_size_);
this->note_received_(false);
return;
}
this->note_received_(true);
this->listen_before_talk_.received();
PacketMetaData meta_data;
meta_data.rssi = rssi;
meta_data.snr = snr;
this->on_receive_from_interface_(PacketBuffer(packet.data(), packet.size()), meta_data);
}
} // namespace esphome::packet_interface
@@ -0,0 +1,101 @@
#pragma once
#include <vector>
#include "esphome/components/packet_interface/listen_before_talk.h"
#include "esphome/components/packet_interface/packet_interface.h"
#include "esphome/core/hal.h"
namespace esphome::packet_interface {
/// The parts of RadioLink that do not depend on the radio.
class RadioLinkBase : public PacketInterface {
public:
void set_max_busy(uint32_t max_busy_ms) { this->listen_before_talk_.set_max_busy(max_busy_ms); }
void set_turnaround(uint32_t turnaround_ms) { this->listen_before_talk_.set_turnaround(turnaround_ms); }
protected:
explicit RadioLinkBase(size_t max_packet_size) : PacketInterface(max_packet_size) {}
/// The time now, not the loop's start: earlier sends in the same loop pass may have waited seconds for the radio.
virtual uint32_t current_time_ms() const { return millis(); }
/// False if a packet of this size is too large.
bool check_size_(size_t size) const;
/// False if sending must wait, as the radio is busy or the peer may be about to reply; starts loop() to watch a
/// busy radio.
bool may_send_(bool busy);
/**
* Returns \p sent, after ending the busy period and warning if the packet was sent over a radio that seemed busy.
* Called only once the radio has the packet, as a log line can run an automation that sends again and overwrites
* the buffer it came from.
*/
bool sent_(bool sent, bool busy);
/// Returns true for an empty packet, which the radios cannot send, so there is nothing to retry.
bool skip_empty_() const;
/// Warns once when a send finds the radio failed; until its setup has run, sends are refused quietly.
void radio_not_ready_(bool failed);
/// Ends the busy period when loop() finds the radio free.
void radio_free_();
void receive_(const std::vector<uint8_t> &packet, float rssi, float snr);
// First, so it fills the spare byte at the end of PacketInterface
bool failed_warned_{false};
ListenBeforeTalk listen_before_talk_;
};
/**
* A packet interface link over a packet radio: each packet is one radio packet, with the RSSI and SNR of received
* packets in the metadata. Sending waits for the radio to finish transmitting. A radio cannot hear while it sends, so
* sending is refused while the radio is receiving a packet. A reliability layer sends the packet again shortly, and
* entity_transport after a delay; other callers drop it, logging at debug level at most. While a busy period lasts,
* loop() watches the radio and ends the period as soon as the radio is free, so a later reception starts a new one.
*
* Radio provides is_receiving(), register_listener(Listener *) and transmit_packet(const uint8_t *, size_t), which
* returns an Error whose value 0 means success. Listener declares on_packet(packet, rssi, snr). MaxPacketSize is the
* radio's limit.
*/
template<typename Radio, typename Listener, typename Error, size_t MaxPacketSize>
class RadioLink : public RadioLinkBase, public Listener {
public:
RadioLink(Radio *radio, size_t max_packet_size) : RadioLinkBase(max_packet_size), radio_(radio) {}
void setup() override {
this->radio_->register_listener(this);
this->disable_loop();
}
// Runs only during a busy period; a busy flag that never clears keeps it running. A radio that failed meanwhile
// is not read again, as reading it may wait on the radio every time
void loop() override {
if (!this->radio_->is_ready() || !this->radio_->is_receiving())
this->radio_free_();
}
bool send_to_interface(const PacketBuffer &data, const PacketMetaData &meta_data) override {
// The radio is set up after the layers above, which may send from their own setup
if (!this->radio_->is_ready()) {
this->radio_not_ready_(this->radio_->is_failed());
return false;
}
size_t size = data.size();
if (size == 0)
return this->skip_empty_();
bool busy = this->radio_->is_receiving();
if (!this->check_size_(size) || !this->may_send_(busy))
return false;
if (data.is_contiguous()) {
auto span = data.as_span();
return this->sent_(this->radio_->transmit_packet(span.data(), span.size()) == Error{}, busy);
}
uint8_t buf[MaxPacketSize];
data.copy_to(buf, size);
return this->sent_(this->radio_->transmit_packet(buf, size) == Error{}, busy);
}
void on_packet(const std::vector<uint8_t> &packet, float rssi, float snr) override {
this->receive_(packet, rssi, snr);
}
protected:
Radio *radio_;
};
} // namespace esphome::packet_interface
@@ -0,0 +1,311 @@
"""Shared code generation for the packet interface links over packet radios, such as the SX126x and SX127x."""
from collections.abc import Callable, Iterator
import logging
import math
import esphome.codegen as cg
from esphome.components.const import CONF_MAX_PACKET_SIZE
import esphome.config_validation as cv
from esphome.const import CONF_FRAGMENTATION, CONF_ID, CONF_TIMEOUT
from esphome.core import CORE
from esphome.cpp_generator import MockObjClass
import esphome.final_validate as fv
from esphome.types import ConfigType
from . import new_packet_interface, packet_interface_schema, reliability_layers
from .layers import (
ADDRESSING,
CONF_ADDRESSING,
CONF_PEERS,
CONF_RELIABILITY,
STACK_ORDER,
)
from .layers.basic_fragmentation import HEADER_SIZE as FRAGMENT_HEADER_SIZE
from .layers.hdlc_reliability import (
CONF_ACK_DELAY,
CONF_MAX_QUEUE_LENGTH,
DEFAULT_TIMEOUT,
)
_LOGGER = logging.getLogger(__name__)
# The largest packet a radio receives, from any device on the channel, given the radio's settings
ReceiveLimit = Callable[[ConfigType], int]
# The radios' payload length register is 8 bits
MAX_PACKET_SIZE = 255
# The smallest max_packet_size that packet_interface_schema() takes
MIN_PACKET_SIZE = 16
# Listen before talk holds a send back for at most the airtime of the largest packet, and never less than this
MIN_MAX_BUSY_MS = 2000
# Room for the preamble detection and the radio's own delays
MARGIN = 1.25
# The radio drivers stop waiting for a packet to be sent after this long
TRANSMIT_TIMEOUT_MS = 4000
# An acknowledgement, with room for the layers below the reliability layer, such as addressing and the rolling code
ACK_PACKET_SIZE = 32
# From the end of a packet to the start of the peer's reply: a loop pass to read the packet, one to answer it, and the
# radio's start-up
REPLY_START_MS = 50
# A LoRa packet's explicit header is in its first 8 symbols
LORA_HEADER_SYMBOLS = 8
def _lora_symbol_s(radio: ConfigType) -> float:
bandwidth_hz = (
float(str(radio["bandwidth"]).removesuffix("kHz").replace("_", ".")) * 1000
)
return (1 << radio["spreading_factor"]) / bandwidth_hz
def packet_airtime_ms(radio: ConfigType, size: int) -> float:
"""The time a radio configured as in radio takes to send a packet of size bytes.
LoRa follows the Semtech formula for an explicit header; the low data rate optimization is assumed when a symbol
takes more than 16 ms, as the drivers enable it. Other modulations count the preamble, sync word, length byte,
payload and CRC at the bitrate, treating the preamble size as bytes, which gives the longer time.
"""
if str(radio["modulation"]) == "LORA":
spreading_factor = radio["spreading_factor"]
coding_rate = int(str(radio["coding_rate"])[-1]) - 4
symbol_s = _lora_symbol_s(radio)
low_data_rate = 1 if symbol_s > 0.016 else 0
crc = 16 if radio.get("crc_enable", False) else 0
payload_symbols = 8 + max(
math.ceil(
(8 * size - 4 * spreading_factor + 28 + crc)
/ (4 * (spreading_factor - 2 * low_data_rate))
)
* (coding_rate + 4),
0,
)
return (radio["preamble_size"] + 4.25 + payload_symbols) * symbol_s * 1000
bytes_sent = (
radio["preamble_size"] + len(radio.get("sync_value", [])) + 1 + size + 2
)
return bytes_sent * 8 / radio["bitrate"] * 1000
def turnaround_ms(radio: ConfigType) -> int:
"""How long, after sending, to wait for the peer's reply to start and for the radio to receive its header, so
the peer's reply is not sent over.
"""
if str(radio["modulation"]) == "LORA":
symbols = radio["preamble_size"] + 4.25 + LORA_HEADER_SYMBOLS
header_ms = symbols * _lora_symbol_s(radio) * 1000
else:
header_bytes = radio["preamble_size"] + len(radio.get("sync_value", [])) + 1
header_ms = header_bytes * 8 / radio["bitrate"] * 1000
return math.ceil((header_ms + REPLY_START_MS) * MARGIN)
def max_busy_ms(radio: ConfigType, max_packet_size: int) -> int:
"""How long listen before talk may hold a send back, for packets of up to max_packet_size bytes."""
return max(
MIN_MAX_BUSY_MS, math.ceil(packet_airtime_ms(radio, max_packet_size) * MARGIN)
)
def _fits_transmit_time(radio: ConfigType, size: int) -> bool:
return packet_airtime_ms(radio, size) * MARGIN <= TRANSMIT_TIMEOUT_MS
def _largest_sendable(radio: ConfigType, limit: int) -> int | None:
"""The largest max_packet_size, up to limit, whose packets the radio sends within the drivers' wait."""
return next(
(
size
for size in range(limit, MIN_PACKET_SIZE - 1, -1)
if _fits_transmit_time(radio, size)
),
None,
)
def channel_packet_size(radio: ConfigType, receive_limit: int) -> int:
"""The largest packet any device on the channel can send: no more than the radio receives, and no more than a
device with these radio settings is allowed to send.
"""
return _largest_sendable(radio, receive_limit) or receive_limit
def reliability_timeout_ms(
radio: ConfigType, packet_size: int, ack_delay_ms: int
) -> int:
"""The shortest reliability timeout: before acknowledging, the peer may be sending, or receiving from another
device, a packet of packet_size bytes.
"""
airtime = packet_airtime_ms(radio, packet_size) + packet_airtime_ms(
radio, ACK_PACKET_SIZE
)
return math.ceil(airtime * MARGIN) + ack_delay_ms
def _check_transmit_time(config: ConfigType, radio: ConfigType) -> None:
"""The radio drivers give up on a packet that takes longer to send than they wait."""
size = config[CONF_MAX_PACKET_SIZE]
if _fits_transmit_time(radio, size):
return
largest = _largest_sendable(radio, size - 1)
advice = (
f"set '{CONF_MAX_PACKET_SIZE}' to {largest} or less"
if largest is not None
else "use faster radio settings"
)
raise cv.Invalid(
f"With these radio settings a packet of {size} bytes takes {packet_airtime_ms(radio, size):.0f} ms to "
f"send, longer than the radio waits for; {advice}",
path=[CONF_MAX_PACKET_SIZE],
)
def _check_reliability_timeouts(
config: ConfigType, radio: ConfigType, packet_size: int
) -> None:
"""A reliability timeout shorter than a packet and its acknowledgement take would send packets again too soon."""
for path, layer in reliability_layers(config):
if (timeout := layer.get(CONF_TIMEOUT)) is None:
continue
needed = reliability_timeout_ms(
radio, packet_size, layer[CONF_ACK_DELAY].total_milliseconds
)
if timeout.total_milliseconds < needed:
raise cv.Invalid(
f"With these radio settings a packet and its acknowledgement can take {needed} ms, so this must be "
f"at least {needed}ms; leave it out to use that",
path=[*path, CONF_TIMEOUT],
)
def _stacks(config: ConfigType) -> Iterator[tuple[ConfigType, int]]:
"""The link's stacks of layers, on the link or in each peer, each with the largest packet below it."""
size = config[CONF_MAX_PACKET_SIZE]
if (addressing := config.get(CONF_ADDRESSING)) is None:
yield config, size
return
size = ADDRESSING.get_type(addressing).packet_size(addressing, size)
yield from ((stack, size) for stack in addressing.get(CONF_PEERS, [config]))
def _radio_packets_per_send(stack: ConfigType, size: int) -> int:
"""How many radio packets one send through the stack can send one after another, each waited for in turn."""
if (reliability := stack.get(CONF_RELIABILITY)) is not None:
# It sends, and after a timeout sends again, every packet in its queue at once
return reliability[CONF_MAX_QUEUE_LENGTH]
if (fragmentation := stack.get(CONF_FRAGMENTATION)) is None:
return 1
for kind in STACK_ORDER:
if kind.key == CONF_FRAGMENTATION:
break
if (layer := stack.get(kind.key)) is not None:
size = kind.get_type(layer).packet_size(layer, size)
fragment = size - FRAGMENT_HEADER_SIZE
if fragment <= 0:
return 1
return math.ceil(fragmentation[CONF_MAX_PACKET_SIZE] / fragment)
def _warn_long_sends(config: ConfigType, radio: ConfigType) -> None:
"""The radio drivers wait for each packet to be sent, so a send of several packets holds up everything else."""
airtime = packet_airtime_ms(radio, config[CONF_MAX_PACKET_SIZE])
for stack, size in _stacks(config):
count = _radio_packets_per_send(stack, size)
if count > 1 and count * airtime > TRANSMIT_TIMEOUT_MS:
_LOGGER.warning(
"A send through '%s' can send %d radio packets in a row, holding up other components for about "
"%.1f s while the radio sends them; reduce '%s' or the reliability '%s', or use faster radio "
"settings",
stack[CONF_ID].id,
count,
count * airtime / 1000,
CONF_MAX_PACKET_SIZE,
CONF_MAX_QUEUE_LENGTH,
)
def radio_link_schema(
class_: MockObjClass, radio_id_key: str, radio_class: MockObjClass
) -> cv.Schema:
"""Schema for a radio link, referring to its radio by radio_id_key."""
return packet_interface_schema(
class_, MAX_PACKET_SIZE, MAX_PACKET_SIZE, chooses_reliability_timeout=True
).extend({cv.GenerateID(radio_id_key): cv.use_id(radio_class)})
def _two_way_layer(config: ConfigType) -> str | None:
"""The first layer on the link or in a peer that keeps state for one peer, so needs packets back from it."""
for stack in (config, *config.get(CONF_ADDRESSING, {}).get(CONF_PEERS, [])):
for kind in STACK_ORDER:
if (layer := stack.get(kind.key)) is not None and kind.get_type(
layer
).single_peer(layer):
return kind.key
return None
def takes_turns(config: ConfigType) -> bool:
"""Whether sends wait for the peer to reply: only a reliability layer's peer answers each packet at once."""
return next(reliability_layers(config), None) is not None
def radio_link_final_validate(
radio_id_key: str,
payload_length_key: str,
rx_start_key: str,
check: Callable[[ConfigType, ConfigType], None] | None = None,
receive_limit: ReceiveLimit = lambda radio: MAX_PACKET_SIZE,
) -> Callable[[ConfigType], ConfigType]:
"""Final validation for a radio link: packets vary in length, the radio listens after sending when a layer needs
replies, and check(link, radio) checks the rest.
"""
def validator(config: ConfigType) -> ConfigType:
radio = fv.get_declaring_config(config[radio_id_key])
if radio[payload_length_key] != 0:
raise cv.Invalid(
f"Packets vary in length, so the radio's '{payload_length_key}' must be 0",
path=[radio_id_key],
)
if not radio[rx_start_key] and (layer := _two_way_layer(config)) is not None:
raise cv.Invalid(
f"This '{layer}' needs packets from the peer, but the radio sleeps after sending unless "
f"'{rx_start_key}' is true",
path=[radio_id_key],
)
if check is not None:
check(config, radio)
_check_transmit_time(config, radio)
_check_reliability_timeouts(
config, radio, channel_packet_size(radio, receive_limit(radio))
)
_warn_long_sends(config, radio)
return config
return validator
async def new_radio_link(
config: ConfigType,
radio_id_key: str,
receive_limit: ReceiveLimit = lambda radio: MAX_PACKET_SIZE,
) -> None:
"""Create a radio link, with timings worked out from the radio's settings and the largest packet on the channel."""
radio_config = fv.get_declaring_config(config[radio_id_key], CORE.config)
packet_size = channel_packet_size(radio_config, receive_limit(radio_config))
# A reliability layer without a timeout gets one long enough for a packet and its acknowledgement
for _, layer in reliability_layers(config):
if CONF_TIMEOUT not in layer:
needed = reliability_timeout_ms(
radio_config, packet_size, layer[CONF_ACK_DELAY].total_milliseconds
)
layer[CONF_TIMEOUT] = cv.TimePeriodMilliseconds(
milliseconds=max(DEFAULT_TIMEOUT.total_milliseconds, needed)
)
radio = await cg.get_variable(config[radio_id_key])
var = await new_packet_interface(config, radio, config[CONF_MAX_PACKET_SIZE])
cg.add(var.set_max_busy(max_busy_ms(radio_config, packet_size)))
# Taking turns would hold up a run of one-way sends, and a reliability layer sends again what it refuses
if takes_turns(config):
cg.add(var.set_turnaround(turnaround_ms(radio_config)))
@@ -46,6 +46,8 @@ class XxteaEncryption : public PacketInterface {
void setup() override;
void dump_config() override;
bool send_to_interface(const PacketBuffer &data, const PacketMetaData &meta_data) override;
// One encrypted packet per packet, so a fragmentation layer above sees the link's room
size_t get_send_capacity() const override { return this->lower_->get_send_capacity(); }
void set_key(std::initializer_list<uint32_t> key);
+18 -29
View File
@@ -434,42 +434,31 @@ bool RTSPSession::queue_next_packet_() {
const size_t rtp_len = header_len - INTERLEAVED_HEADER_LEN + qtables_len + payload_len;
auto *buf = reinterpret_cast<uint8_t *>(this->send_buf_.data());
size_t pos = 0;
buf[pos++] = '$';
buf[pos++] = 0; // interleaved channel 0
buf[pos++] = static_cast<uint8_t>(rtp_len >> 8);
buf[pos++] = static_cast<uint8_t>(rtp_len);
uint8_t *p = buf;
*p++ = '$';
*p++ = 0; // interleaved channel 0
p = put_be16(p, rtp_len);
buf[pos++] = 0x80; // V=2, P=0, X=0, CC=0
buf[pos++] = static_cast<uint8_t>((last_fragment ? 0x80 : 0x00) | RTP_PAYLOAD_TYPE_JPEG);
buf[pos++] = static_cast<uint8_t>(this->sequence_number_ >> 8);
buf[pos++] = static_cast<uint8_t>(this->sequence_number_);
*p++ = 0x80; // V=2, P=0, X=0, CC=0
*p++ = static_cast<uint8_t>((last_fragment ? 0x80 : 0x00) | RTP_PAYLOAD_TYPE_JPEG);
p = put_be16(p, this->sequence_number_);
this->sequence_number_++;
buf[pos++] = static_cast<uint8_t>(this->rtp_timestamp_ >> 24);
buf[pos++] = static_cast<uint8_t>(this->rtp_timestamp_ >> 16);
buf[pos++] = static_cast<uint8_t>(this->rtp_timestamp_ >> 8);
buf[pos++] = static_cast<uint8_t>(this->rtp_timestamp_);
buf[pos++] = static_cast<uint8_t>(this->ssrc_ >> 24);
buf[pos++] = static_cast<uint8_t>(this->ssrc_ >> 16);
buf[pos++] = static_cast<uint8_t>(this->ssrc_ >> 8);
buf[pos++] = static_cast<uint8_t>(this->ssrc_);
p = put_be32(p, this->rtp_timestamp_);
p = put_be32(p, this->ssrc_);
// RFC 2435 main JPEG header
buf[pos++] = 0; // type-specific
buf[pos++] = static_cast<uint8_t>(this->frame_sent_ >> 16);
buf[pos++] = static_cast<uint8_t>(this->frame_sent_ >> 8);
buf[pos++] = static_cast<uint8_t>(this->frame_sent_);
buf[pos++] = this->jpeg_.type;
buf[pos++] = 255; // Q >= 128: the quantization tables follow in the first packet
buf[pos++] = static_cast<uint8_t>(this->jpeg_.width / 8);
buf[pos++] = static_cast<uint8_t>(this->jpeg_.height / 8);
*p++ = 0; // type-specific
p = put_be24(p, this->frame_sent_);
*p++ = this->jpeg_.type;
*p++ = 255; // Q >= 128: the quantization tables follow in the first packet
*p++ = static_cast<uint8_t>(this->jpeg_.width / 8);
*p++ = static_cast<uint8_t>(this->jpeg_.height / 8);
uint8_t count = 0;
if (first_fragment) {
buf[pos++] = 0; // MBZ
buf[pos++] = 0; // 8-bit precision
buf[pos++] = static_cast<uint8_t>(qtables_len >> 8);
buf[pos++] = static_cast<uint8_t>(qtables_len);
*p++ = 0; // MBZ
*p++ = 0; // 8-bit precision
put_be16(p, qtables_len);
this->iov_[0] = {buf, header_len};
this->iov_[1] = {const_cast<uint8_t *>(this->jpeg_.qtable0), QTABLE_LEN};
this->iov_[2] = {const_cast<uint8_t *>(this->jpeg_.qtable1), QTABLE_LEN};
@@ -145,11 +145,9 @@ void RuntimeImage::draw_pixel(int x, int y, const Color &color) {
this->map_chroma_key(mapped_color);
uint16_t rgb565 = display::ColorUtil::color_to_565(mapped_color);
if (this->big_endian_) {
this->buffer_[pos + 0] = static_cast<uint8_t>((rgb565 >> 8) & 0xFF);
this->buffer_[pos + 1] = static_cast<uint8_t>(rgb565 & 0xFF);
put_be16(this->buffer_ + pos, rgb565);
} else {
this->buffer_[pos + 0] = static_cast<uint8_t>(rgb565 & 0xFF);
this->buffer_[pos + 1] = static_cast<uint8_t>((rgb565 >> 8) & 0xFF);
put_le16(this->buffer_ + pos, rgb565);
}
if (this->transparency_ == image::TRANSPARENCY_ALPHA_CHANNEL) {
const size_t alpha_pos = pos / 2 + this->buffer_width_ * this->buffer_height_ * 2;
@@ -48,17 +48,16 @@ bool SensirionI2CDevice::write_command_(uint16_t command, CommandLen command_len
temp[raw_idx++] = command & 0xFF;
} else {
// command is 2 bytes
temp[raw_idx++] = command >> 8;
temp[raw_idx++] = command & 0xFF;
put_be16(temp, command);
raw_idx = 2;
}
// add parameters followed by crc
// skipped if len == 0
for (size_t i = 0; i < data_len; i++) {
temp[raw_idx++] = data[i] >> 8;
temp[raw_idx++] = data[i] & 0xFF;
put_be16(temp + raw_idx, data[i]);
// Use MSB first since Sensirion devices use CRC-8 with MSB first
uint8_t crc = crc8(&temp[raw_idx - 2], 2, 0xFF, CRC_POLYNOMIAL, true);
temp[raw_idx++] = crc;
temp[raw_idx + 2] = crc8(temp + raw_idx, 2, 0xFF, CRC_POLYNOMIAL, true);
raw_idx += 3;
}
this->last_error_ = this->write(temp, raw_idx);
return this->last_error_ == i2c::ERROR_OK;
@@ -611,7 +611,7 @@ stm32_unique_ptr stm32_init(uart::UARTDevice *stream, const uint8_t flags, const
ESP_LOGD(TAG, "Only %d bytes sent in the PID, unknown/unsupported device", returned);
return make_stm32_with_deletor(nullptr);
}
stm->pid = (buf[1] << 8) | buf[2];
stm->pid = encode_uint16(buf[1], buf[2]);
if (returned > 2) {
ESP_LOGD(TAG, "This bootloader returns %d extra bytes in PID:", returned);
for (auto i = 2; i <= returned; i++) {
@@ -952,7 +952,7 @@ stm32_err_t stm32_crc_memory(const stm32_unique_ptr &stm, const uint32_t address
if (buf[4] != xor_bytes(buf, 4))
return STM32_ERR_UNKNOWN;
*crc = (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
*crc = encode_uint32(buf[0], buf[1], buf[2], buf[3]);
}
return STM32_ERR_OK;
@@ -123,8 +123,7 @@ void HOT SSD1331::draw_absolute_pixel_internal(int x, int y, Color color) {
const uint32_t color565 = display::ColorUtil::color_to_565(color);
// where should the bits go in the big buffer array? math...
uint16_t pos = (x + y * this->get_width_internal()) * SSD1331_BYTESPERPIXEL;
this->buffer_[pos++] = (color565 >> 8) & 0xff;
this->buffer_[pos] = color565 & 0xff;
put_be16(this->buffer_ + pos, color565);
}
void SSD1331::fill(Color color) {
// If clipping is active, fall back to base implementation
@@ -155,8 +155,7 @@ void HOT SSD1351::draw_absolute_pixel_internal(int x, int y, Color color) {
const uint32_t color565 = display::ColorUtil::color_to_565(color);
// where should the bits go in the big buffer array? math...
uint16_t pos = (x + y * this->get_width_internal()) * SSD1351_BYTESPERPIXEL;
this->buffer_[pos++] = (color565 >> 8) & 0xff;
this->buffer_[pos] = color565 & 0xff;
put_be16(this->buffer_ + pos, color565);
}
void SSD1351::fill(Color color) {
// If clipping is active, fall back to base implementation
+4 -2
View File
@@ -48,7 +48,7 @@ CONF_WHITENING_ENABLE = "whitening_enable"
CONF_WHITENING_INITIAL = "whitening_initial"
sx126x_ns = cg.esphome_ns.namespace("sx126x")
SX126x = sx126x_ns.class_("SX126x", cg.Component, spi.SPIDevice)
SX126x = sx126x_ns.class_("SX126x", cg.Component)
SX126xListener = sx126x_ns.class_("SX126xListener")
SX126xBw = sx126x_ns.enum("SX126xBw")
SX126xPacketType = sx126x_ns.enum("SX126xPacketType")
@@ -217,7 +217,9 @@ CONFIG_SCHEMA = (
cv.Required(CONF_RF_SWITCH): cv.boolean,
cv.Optional(CONF_SHAPING, default="NONE"): cv.enum(SHAPING),
cv.Optional(CONF_SPREADING_FACTOR, default=7): cv.int_range(min=6, max=12),
cv.Optional(CONF_SYNC_VALUE, default=[]): cv.ensure_list(cv.hex_uint8_t),
cv.Optional(CONF_SYNC_VALUE, default=[]): cv.All(
cv.ensure_list(cv.hex_uint8_t), cv.Length(max=8)
),
cv.Optional(CONF_TCXO_VOLTAGE, default="NONE"): cv.enum(TCXO_VOLTAGE),
cv.Optional(CONF_TCXO_DELAY, default="5ms"): cv.All(
cv.positive_time_period_microseconds,
@@ -0,0 +1,49 @@
from esphome.components import packet_interface
from esphome.components.packet_interface.radio_link import (
new_radio_link,
radio_link_final_validate,
radio_link_schema,
)
import esphome.config_validation as cv
from esphome.types import ConfigType
from .. import (
CONF_MODULATION,
CONF_PAYLOAD_LENGTH,
CONF_RX_START,
CONF_SX126X_ID,
CONF_SYNC_VALUE,
SX126x,
SX126xListener,
sx126x_ns,
)
CODEOWNERS = ["@clydebarrow"]
DEPENDENCIES = ["sx126x"]
SX126xPacketInterface = sx126x_ns.class_(
"SX126xPacketInterface", packet_interface.PacketInterface, SX126xListener
)
CONFIG_SCHEMA = radio_link_schema(SX126xPacketInterface, CONF_SX126X_ID, SX126x)
def _check_fsk(config: ConfigType, radio: ConfigType) -> None:
"""Without LoRa, the radio can tell that a packet is arriving only from its sync word, which listen before talk
needs.
"""
if radio[CONF_MODULATION] != "LORA" and not radio[CONF_SYNC_VALUE]:
raise cv.Invalid(
f"Without LoRa modulation the radio needs a '{CONF_SYNC_VALUE}', so that the link can tell when a packet "
"is arriving and not send over it",
path=[CONF_SX126X_ID],
)
FINAL_VALIDATE_SCHEMA = radio_link_final_validate(
CONF_SX126X_ID, CONF_PAYLOAD_LENGTH, CONF_RX_START, _check_fsk
)
async def to_code(config: ConfigType) -> None:
await new_radio_link(config, CONF_SX126X_ID)
@@ -0,0 +1,10 @@
#pragma once
#include "esphome/components/packet_interface/radio_link.h"
#include "esphome/components/sx126x/sx126x.h"
namespace esphome::sx126x {
using SX126xPacketInterface = packet_interface::RadioLink<SX126x, SX126xListener, SX126xError, SX126X_MAX_PACKET_SIZE>;
} // namespace esphome::sx126x
+97
View File
@@ -0,0 +1,97 @@
#pragma once
#include "sx126x_reg.h"
#include <array>
#include <span>
#include <algorithm>
namespace esphome::sx126x {
enum SX126xBw : uint8_t {
// FSK
SX126X_BW_4800,
SX126X_BW_5800,
SX126X_BW_7300,
SX126X_BW_9700,
SX126X_BW_11700,
SX126X_BW_14600,
SX126X_BW_19500,
SX126X_BW_23400,
SX126X_BW_29300,
SX126X_BW_39000,
SX126X_BW_46900,
SX126X_BW_58600,
SX126X_BW_78200,
SX126X_BW_93800,
SX126X_BW_117300,
SX126X_BW_156200,
SX126X_BW_187200,
SX126X_BW_234300,
SX126X_BW_312000,
SX126X_BW_373600,
SX126X_BW_467000,
// LORA
SX126X_BW_7810,
SX126X_BW_10420,
SX126X_BW_15630,
SX126X_BW_20830,
SX126X_BW_31250,
SX126X_BW_41670,
SX126X_BW_62500,
SX126X_BW_125000,
SX126X_BW_250000,
SX126X_BW_500000,
};
// Requested settings are separate from the last successfully applied profile.
// Bounded sync storage makes profile snapshots allocation-free.
struct RadioProfile {
uint32_t bitrate{0};
uint32_t deviation{0};
uint32_t frequency{0};
uint32_t tcxo_delay{0};
uint16_t crc_polynomial{0};
uint16_t crc_initial{0};
uint16_t whitening_initial{0};
uint16_t preamble_detect{0};
uint16_t preamble_size{0};
SX126xBw bandwidth{SX126X_BW_125000};
uint8_t crc_size{0};
uint8_t tcxo_voltage{0};
uint8_t coding_rate{0};
uint8_t modulation{PACKET_TYPE_LORA};
uint8_t pa_ramp{0};
uint8_t shaping{0};
uint8_t spreading_factor{0};
int8_t pa_power{0};
uint8_t payload_length{0};
bool sx1261{false};
bool crc_enable{false};
bool crc_inverted{false};
bool whitening_enable{false};
bool rx_start{false};
bool rf_switch{false};
std::array<uint8_t, 8> sync_value{};
uint8_t sync_size{0};
bool sync_valid{true};
void set_sync_value(std::span<const uint8_t> bytes) {
this->sync_valid = bytes.size() <= this->sync_value.size();
if (!this->sync_valid) {
return;
}
std::copy(bytes.begin(), bytes.end(), this->sync_value.begin());
this->sync_size = bytes.size();
}
size_t max_packet_size() const { return this->payload_length > 0 ? this->payload_length : 255; }
};
// The parts of the last successfully applied profile that runtime operations read.
// SetPacketParams is encoded once; sends only change its payload length byte.
struct AppliedProfile {
uint32_t frequency{0};
std::array<uint8_t, 9> packet_params{};
uint8_t packet_params_size{0};
uint8_t payload_length{0};
uint8_t modulation{PACKET_TYPE_LORA};
bool rx_start{false};
size_t max_packet_size() const { return this->payload_length > 0 ? this->payload_length : 255; }
};
} // namespace esphome::sx126x
+169 -484
View File
@@ -2,534 +2,217 @@
#include "esphome/core/application.h"
#include "esphome/core/hal.h"
#include "esphome/core/log.h"
#include "esphome/core/progmem.h"
namespace esphome::sx126x {
ESPHOME_LOG_TAG(TAG, "sx126x");
static constexpr uint16_t RAMP[8] PROGMEM = {10, 20, 40, 80, 200, 800, 1700, 3400};
// Aligned 32 bit loads from flash are safe on ESP8266, so this table is read directly
static constexpr uint32_t BW_HZ[31] PROGMEM = {4800, 5800, 7300, 9700, 11700, 14600, 19500, 23400,
29300, 39000, 46900, 58600, 78200, 93800, 117300, 156200,
187200, 234300, 312000, 373600, 467000, 7810, 10420, 15630,
20830, 31250, 41670, 62500, 125000, 250000, 500000};
static constexpr uint8_t BW_LORA[10] PROGMEM = {LORA_BW_7810, LORA_BW_10420, LORA_BW_15630, LORA_BW_20830,
LORA_BW_31250, LORA_BW_41670, LORA_BW_62500, LORA_BW_125000,
LORA_BW_250000, LORA_BW_500000};
static constexpr uint8_t BW_FSK[21] PROGMEM = {
FSK_BW_4800, FSK_BW_5800, FSK_BW_7300, FSK_BW_9700, FSK_BW_11700, FSK_BW_14600, FSK_BW_19500,
FSK_BW_23400, FSK_BW_29300, FSK_BW_39000, FSK_BW_46900, FSK_BW_58600, FSK_BW_78200, FSK_BW_93800,
FSK_BW_117300, FSK_BW_156200, FSK_BW_187200, FSK_BW_234300, FSK_BW_312000, FSK_BW_373600, FSK_BW_467000};
static constexpr uint32_t RESET_DELAY_HIGH_US = 5000;
static constexpr uint32_t RESET_DELAY_LOW_US = 2000;
static constexpr uint32_t SWITCHING_DELAY_US = 1;
static constexpr uint32_t TRANSMIT_TIMEOUT_MS = 4000;
static constexpr uint32_t BUSY_TIMEOUT_MS = 20;
static constexpr uint32_t MAX_TRANSMIT_TIMEOUT_MS = 262143; // 24-bit SetTx timeout in 1/64 ms steps
static constexpr uint32_t RECONFIGURE_INTERVAL_ID = 0;
static constexpr uint32_t RECONFIGURE_INTERVAL_MS = 1000;
// OCP (Over Current Protection) values
static constexpr uint8_t OCP_80MA = 0x18; // 80 mA max current
static constexpr uint8_t OCP_140MA = 0x38; // 140 mA max current
// LoRa low data rate optimization threshold
static constexpr float LOW_DATA_RATE_OPTIMIZE_THRESHOLD = 16.38f; // 16.38 ms
uint8_t SX126x::read_fifo_(uint8_t offset, std::vector<uint8_t> &packet) {
this->enable();
this->wait_busy_();
this->transfer_byte(RADIO_READ_BUFFER);
this->transfer_byte(offset);
uint8_t status = this->transfer_byte(0x00);
for (uint8_t &byte : packet) {
byte = this->transfer_byte(0x00);
}
this->disable();
return status;
}
void SX126x::write_fifo_(uint8_t offset, const uint8_t *data, size_t len) {
this->enable();
this->wait_busy_();
this->transfer_byte(RADIO_WRITE_BUFFER);
this->transfer_byte(offset);
for (size_t i = 0; i < len; i++) {
this->transfer_byte(data[i]);
}
this->disable();
delayMicroseconds(SWITCHING_DELAY_US);
}
uint8_t SX126x::read_opcode_(uint8_t opcode, uint8_t *data, uint8_t size) {
this->enable();
this->wait_busy_();
this->transfer_byte(opcode);
uint8_t status = this->transfer_byte(0x00);
for (int32_t i = 0; i < size; i++) {
data[i] = this->transfer_byte(0x00);
}
this->disable();
return status;
}
void SX126x::write_opcode_(uint8_t opcode, uint8_t *data, uint8_t size) {
this->enable();
this->wait_busy_();
this->transfer_byte(opcode);
for (int32_t i = 0; i < size; i++) {
this->transfer_byte(data[i]);
}
this->disable();
delayMicroseconds(SWITCHING_DELAY_US);
}
void SX126x::read_register_(uint16_t reg, uint8_t *data, uint8_t size) {
this->enable();
this->wait_busy_();
this->write_byte(RADIO_READ_REGISTER);
this->write_byte((reg >> 8) & 0xFF);
this->write_byte((reg >> 0) & 0xFF);
this->write_byte(0x00);
for (int32_t i = 0; i < size; i++) {
data[i] = this->transfer_byte(0x00);
}
this->disable();
}
void SX126x::write_register_(uint16_t reg, uint8_t *data, uint8_t size) {
this->enable();
this->wait_busy_();
this->write_byte(RADIO_WRITE_REGISTER);
this->write_byte((reg >> 8) & 0xFF);
this->write_byte((reg >> 0) & 0xFF);
for (int32_t i = 0; i < size; i++) {
this->transfer_byte(data[i]);
}
this->disable();
delayMicroseconds(SWITCHING_DELAY_US);
}
void IRAM_ATTR SX126x::gpio_intr(SX126x *arg) { arg->enable_loop_soon_any_context(); }
// Indexed by SX126xError.
PROGMEM_STRING_TABLE(SX126xErrorStrings, "none", "timeout", "invalid payload", "radio not ready", "bus timeout",
"radio busy", "cancelled");
void SX126x::setup() {
// Sized once so later packet reads never reallocate; read_packet() sets the length.
this->packet_.resize(SX126X_MAX_PACKET_SIZE);
// setup pins
this->busy_pin_->setup();
this->rst_pin_->setup();
this->dio1_pin_->setup();
if (this->dio1_pin_->is_internal()) {
static_cast<InternalGPIOPin *>(this->dio1_pin_)
->attach_interrupt(&SX126x::gpio_intr, this, gpio::INTERRUPT_RISING_EDGE);
GPIOPin *dio1 = this->radio_.get_dio1_pin();
this->radio_.bus().get_busy_pin()->setup();
this->radio_.get_rst_pin()->setup();
dio1->setup();
if (dio1->is_internal()) {
static_cast<InternalGPIOPin *>(dio1)->attach_interrupt(&SX126x::gpio_intr, this, gpio::INTERRUPT_RISING_EDGE);
}
// start spi
this->spi_setup();
this->radio_.bus().setup();
// configure rf
this->configure();
// configure rf; a failure is reported through mark_failed() only, with its own reason
const RadioEffects effects = this->radio_.configure(this->requested_profile_, this->version_);
if (effects.warning != nullptr) {
this->mark_failed(effects.warning);
return;
}
this->apply_(effects);
}
void SX126x::apply_(const RadioEffects &effects) {
// User code may only run once the radio has committed. A rejection during another
// operation's command sequence carries no status or callbacks.
ESPHOME_DEBUG_ASSERT(!this->radio_.busy() || (!effects.report && effects.listener == nullptr && !effects.received));
if (effects.sleep_loop) {
this->disable_loop();
} else if (this->radio_.state() != RadioState::RADIO_STATE_NEEDS_CONFIGURATION) {
this->enable_loop();
}
this->watch_configuration_();
// The packet buffer is borrowed from the status report until listeners return;
// loop() will not refill it meanwhile.
if (effects.received) {
this->rx_dispatching_ = true;
}
if (effects.report) {
this->status_comm_result(effects.warning == nullptr, effects.warning);
}
if (effects.listener != nullptr) {
effects.listener->on_transmit_complete(effects.result);
}
if (effects.received) {
for (auto *listener : this->listeners_) {
listener->on_packet(this->packet_, effects.rssi, effects.snr);
}
this->packet_trigger_.trigger(this->packet_, effects.rssi, effects.snr);
this->rx_dispatching_ = false;
}
}
void SX126x::configure() {
uint8_t buf[8];
// toggle chip reset
this->rst_pin_->digital_write(true);
delayMicroseconds(RESET_DELAY_HIGH_US);
this->rst_pin_->digital_write(false);
delayMicroseconds(RESET_DELAY_LOW_US);
this->rst_pin_->digital_write(true);
delayMicroseconds(RESET_DELAY_HIGH_US);
// wakeup
this->read_opcode_(RADIO_GET_STATUS, nullptr, 0);
// config tcxo
if (this->tcxo_voltage_ != TCXO_CTRL_NONE) {
uint32_t delay = this->tcxo_delay_ >> 6;
buf[0] = this->tcxo_voltage_;
buf[1] = (delay >> 16) & 0xFF;
buf[2] = (delay >> 8) & 0xFF;
buf[3] = (delay >> 0) & 0xFF;
this->write_opcode_(RADIO_SET_TCXOMODE, buf, 4);
buf[0] = 0x7F;
this->write_opcode_(RADIO_CALIBRATE, buf, 1);
}
// clear errors
buf[0] = 0x00;
buf[1] = 0x00;
this->write_opcode_(RADIO_CLR_ERROR, buf, 2);
// rf switch
if (this->rf_switch_) {
buf[0] = 0x01;
this->write_opcode_(RADIO_SET_RFSWITCHMODE, buf, 1);
}
// check silicon version to make sure hw is ok
this->read_register_(REG_VERSION_STRING, (uint8_t *) this->version_, sizeof(this->version_));
this->version_[sizeof(this->version_) - 1] = '\0';
if (strncmp(this->version_, "SX126", 5) != 0 && strncmp(this->version_, "LLCC68", 6) != 0) {
this->mark_failed(LOG_STR("Unsupported chip version"));
// Before setup() the bus is not set up, and after a failed setup the radio stays unused
if (!this->is_ready()) {
return;
}
// setup packet type
buf[0] = this->modulation_;
this->write_opcode_(RADIO_SET_PACKETTYPE, buf, 1);
// calibrate image
this->run_image_cal();
// set frequency
uint64_t freq = ((uint64_t) this->frequency_ << 25) / XTAL_FREQ;
buf[0] = (uint8_t) ((freq >> 24) & 0xFF);
buf[1] = (uint8_t) ((freq >> 16) & 0xFF);
buf[2] = (uint8_t) ((freq >> 8) & 0xFF);
buf[3] = (uint8_t) (freq & 0xFF);
this->write_opcode_(RADIO_SET_RFFREQUENCY, buf, 4);
// configure pa
int8_t pa_power = this->pa_power_;
if (this->sx1261_) {
// the following values were taken from section 13.1.14.1 table 13-21
// in rev 2.1 of the datasheet
if (pa_power == 15) {
uint8_t cfg[4] = {0x06, 0x00, 0x01, 0x01};
this->write_opcode_(RADIO_SET_PACONFIG, cfg, 4);
} else {
uint8_t cfg[4] = {0x04, 0x00, 0x01, 0x01};
this->write_opcode_(RADIO_SET_PACONFIG, cfg, 4);
}
pa_power = std::max(pa_power, (int8_t) -3);
pa_power = std::min(pa_power, (int8_t) 14);
buf[0] = OCP_80MA;
this->write_register_(REG_OCP, buf, 1);
} else {
// the following values were taken from section 13.1.14.1 table 13-21
// in rev 2.1 of the datasheet
uint8_t cfg[4] = {0x04, 0x07, 0x00, 0x01};
this->write_opcode_(RADIO_SET_PACONFIG, cfg, 4);
pa_power = std::max(pa_power, (int8_t) -3);
pa_power = std::min(pa_power, (int8_t) 22);
buf[0] = OCP_140MA;
this->write_register_(REG_OCP, buf, 1);
if (!this->radio_.can_configure()) {
ESP_LOGW(TAG, "Radio operation in progress, configuration ignored");
return;
}
buf[0] = pa_power;
buf[1] = this->pa_ramp_;
this->write_opcode_(RADIO_SET_TXPARAMS, buf, 2);
this->cold_sleep_ = false;
this->apply_(this->radio_.configure(this->requested_profile_, this->version_));
}
// configure modem
if (this->modulation_ == PACKET_TYPE_LORA) {
// set modulation params
float duration = 1000.0f * (1UL << this->spreading_factor_) / BW_HZ[this->bandwidth_];
buf[0] = this->spreading_factor_;
buf[1] = progmem_read_byte(&BW_LORA[this->bandwidth_ - SX126X_BW_7810]);
buf[2] = this->coding_rate_;
buf[3] = (duration > LOW_DATA_RATE_OPTIMIZE_THRESHOLD) ? 0x01 : 0x00;
this->write_opcode_(RADIO_SET_MODULATIONPARAMS, buf, 4);
// set packet params and sync word
this->set_packet_params_(this->get_max_packet_size());
if (this->sync_value_.size() == 2) {
this->write_register_(REG_LORA_SYNCWORD, this->sync_value_.data(), this->sync_value_.size());
}
} else {
// set modulation params
uint32_t bitrate = ((uint64_t) XTAL_FREQ * 32) / this->bitrate_;
uint32_t fdev = ((uint64_t) this->deviation_ << 25) / XTAL_FREQ;
buf[0] = (bitrate >> 16) & 0xFF;
buf[1] = (bitrate >> 8) & 0xFF;
buf[2] = (bitrate >> 0) & 0xFF;
buf[3] = this->shaping_;
buf[4] = progmem_read_byte(&BW_FSK[this->bandwidth_ - SX126X_BW_4800]);
buf[5] = (fdev >> 16) & 0xFF;
buf[6] = (fdev >> 8) & 0xFF;
buf[7] = (fdev >> 0) & 0xFF;
this->write_opcode_(RADIO_SET_MODULATIONPARAMS, buf, 8);
// set crc params
if (this->crc_enable_) {
buf[0] = this->crc_initial_ >> 8;
buf[1] = this->crc_initial_ & 0xFF;
this->write_register_(REG_CRC_INITIAL, buf, 2);
buf[0] = this->crc_polynomial_ >> 8;
buf[1] = this->crc_polynomial_ & 0xFF;
this->write_register_(REG_CRC_POLYNOMIAL, buf, 2);
}
// set whitening params
if (this->whitening_enable_) {
// according to the datasheet, section 12 table 12-1 "The user should not
// change the value of the 7 MSB of this register"
this->read_register_(REG_WHITENING_INITIAL, buf, 1);
buf[0] = (buf[0] & 0xFE) | ((this->whitening_initial_ >> 8) & 0x01);
buf[1] = this->whitening_initial_ & 0xFF;
this->write_register_(REG_WHITENING_INITIAL, buf, 2);
}
// set packet params and sync word
this->set_packet_params_(this->get_max_packet_size());
if (!this->sync_value_.empty()) {
this->write_register_(REG_GFSK_SYNCWORD, this->sync_value_.data(), this->sync_value_.size());
}
// A failed command leaves the radio needing configuration, which nothing else would do, so a node
// that only uses YAML would stay deaf. Cold sleep is asked for, so it waits for a mode command.
void SX126x::watch_configuration_() {
const bool needed = this->radio_.state() == RadioState::RADIO_STATE_NEEDS_CONFIGURATION && !this->cold_sleep_;
if (needed == this->reconfigure_pending_) {
return;
}
// switch to rx or sleep
if (this->rx_start_) {
this->set_mode_rx();
this->reconfigure_pending_ = needed;
if (needed) {
this->set_interval(RECONFIGURE_INTERVAL_ID, RECONFIGURE_INTERVAL_MS, [this]() { this->configure(); });
} else {
this->set_mode_sleep();
this->cancel_interval(RECONFIGURE_INTERVAL_ID);
}
}
size_t SX126x::get_max_packet_size() {
if (this->payload_length_ > 0) {
return this->payload_length_;
void SX126x::set_mode_rx() { this->change_mode_(ModeCommand::MODE_COMMAND_RX); }
void SX126x::set_mode_tx() { this->change_mode_(ModeCommand::MODE_COMMAND_TX); }
void SX126x::set_mode_standby(SX126xStandbyMode mode) { this->change_mode_(ModeCommand::MODE_COMMAND_STANDBY, mode); }
void SX126x::set_mode_sleep(bool cold) {
this->change_mode_(cold ? ModeCommand::MODE_COMMAND_COLD_SLEEP : ModeCommand::MODE_COMMAND_SLEEP);
}
void SX126x::run_image_cal() { this->change_mode_(ModeCommand::MODE_COMMAND_IMAGE_CAL); }
void SX126x::change_mode_(ModeCommand command, uint8_t arg) {
const bool sleep = command == ModeCommand::MODE_COMMAND_SLEEP || command == ModeCommand::MODE_COMMAND_COLD_SLEEP;
if (this->cold_sleep_) {
if (sleep) {
return;
}
// Cold sleep lost the configuration, so waking needs it applied again first
this->configure();
}
return SX126X_MAX_PACKET_SIZE;
if (!this->radio_.can_change_mode()) {
ESP_LOGW(TAG, "Radio unavailable, mode change ignored");
return;
}
this->cold_sleep_ = command == ModeCommand::MODE_COMMAND_COLD_SLEEP;
this->apply_(this->radio_.change_mode(command, arg));
}
void SX126x::set_packet_params_(uint8_t payload_length) {
uint8_t buf[9];
if (this->modulation_ == PACKET_TYPE_LORA) {
buf[0] = (this->preamble_size_ >> 8) & 0xFF;
buf[1] = (this->preamble_size_ >> 0) & 0xFF;
buf[2] = (this->payload_length_ > 0) ? 0x01 : 0x00;
buf[3] = payload_length;
buf[4] = (this->crc_enable_) ? 0x01 : 0x00;
buf[5] = 0x00;
this->write_opcode_(RADIO_SET_PACKETPARAMS, buf, 6);
} else {
uint16_t preamble_size = this->preamble_size_ * 8;
buf[0] = (preamble_size >> 8) & 0xFF;
buf[1] = (preamble_size >> 0) & 0xFF;
buf[2] = (this->preamble_detect_ > 0) ? ((this->preamble_detect_ - 1) | 0x04) : 0x00;
buf[3] = this->sync_value_.size() * 8;
buf[4] = 0x00;
buf[5] = (this->payload_length_ > 0) ? 0x00 : 0x01;
buf[6] = payload_length;
if (this->crc_enable_) {
buf[7] = (this->crc_inverted_ ? 0x04 : 0x00) + (this->crc_size_ & 0x02);
} else {
buf[7] = 0x01;
}
buf[8] = (this->whitening_enable_) ? 0x01 : 0x00;
this->write_opcode_(RADIO_SET_PACKETPARAMS, buf, 9);
}
}
size_t SX126x::get_max_packet_size() { return this->radio_.max_packet_size(); }
SX126xError SX126x::transmit_packet(const uint8_t *data, size_t len) {
// Callers such as a template number's on_value can run before setup() or after a failed setup
if (!this->is_ready()) {
ESP_LOGW(TAG, "Radio not ready, packet dropped");
return SX126xError::SX126X_ERROR_NOT_READY;
}
if (this->payload_length_ > 0 && this->payload_length_ != len) {
ESP_LOGE(TAG, "Packet size does not match config");
return SX126xError::INVALID_PARAMS;
}
if (len == 0 || len > this->get_max_packet_size()) {
ESP_LOGE(TAG, "Packet size out of range");
return SX126xError::INVALID_PARAMS;
}
SX126xError ret = SX126xError::NONE;
this->set_mode_standby(STDBY_XOSC);
if (this->payload_length_ == 0) {
this->set_packet_params_(len);
}
this->write_fifo_(0x00, data, len);
this->set_mode_tx();
// wait until transmit completes, typically the delay will be less than 100 ms
uint32_t start = millis();
while (!this->dio1_pin_->digital_read()) {
App.feed_wdt();
if (millis() - start > TRANSMIT_TIMEOUT_MS) {
ESP_LOGE(TAG, "Transmit packet failure");
ret = SX126xError::TIMEOUT;
break;
SX126xError result = this->start_transmit_(nullptr, data, len, TRANSMIT_TIMEOUT_MS);
if (result == SX126xError::SX126X_ERROR_NONE) {
// Wait for this send's own completion. A send without a listener cannot be cancelled,
// and no user code runs between these polls, so the send cannot be replaced.
result = SX126xError::SX126X_ERROR_NOT_READY;
while (this->radio_.is_transmitting()) {
const RadioEffects effects = this->radio_.poll_transmit(millis());
if (effects.finished) {
result = effects.result;
this->apply_(effects);
break;
}
App.feed_wdt();
}
}
uint8_t buf[2];
buf[0] = 0xFF;
buf[1] = 0xFF;
this->write_opcode_(RADIO_CLR_IRQSTATUS, buf, 2);
if (this->payload_length_ == 0) {
this->set_packet_params_(this->get_max_packet_size());
if (result != SX126xError::SX126X_ERROR_NONE) {
ESP_LOGW(
TAG, "Packet send failed: %s",
LOG_STR_ARG(SX126xErrorStrings::get_log_str(static_cast<uint8_t>(result), SX126xErrorStrings::LAST_INDEX)));
}
if (this->rx_start_) {
this->set_mode_rx();
} else {
this->set_mode_sleep();
}
return ret;
return result;
}
void SX126x::call_listeners_(const std::vector<uint8_t> &packet, float rssi, float snr) {
for (auto &listener : this->listeners_) {
listener->on_packet(packet, rssi, snr);
SX126xError SX126x::start_transmit_async(SX126xTransmitListener *listener, const uint8_t *data, size_t len,
uint32_t timeout_ms) {
if (listener == nullptr || timeout_ms == 0 || timeout_ms > MAX_TRANSMIT_TIMEOUT_MS) {
return SX126xError::SX126X_ERROR_INVALID_PARAMS;
}
this->packet_trigger_.trigger(packet, rssi, snr);
return this->start_transmit_(listener, data, len, timeout_ms);
}
SX126xError SX126x::start_transmit_(SX126xTransmitListener *listener, const uint8_t *data, size_t len,
uint32_t timeout_ms) {
if (!this->is_ready()) {
return SX126xError::SX126X_ERROR_NOT_READY;
}
const RadioEffects effects = this->radio_.start_transmit(listener, data, len, timeout_ms);
this->apply_(effects);
return effects.result;
}
bool SX126x::cancel_transmit_async(SX126xTransmitListener *listener) {
const RadioEffects effects = this->radio_.cancel_transmit(listener);
if (!effects.finished) {
return false;
}
this->apply_(effects);
return true;
}
void SX126x::loop() {
if (this->dio1_pin_->is_internal()) {
this->disable_loop();
}
if (!this->dio1_pin_->digital_read()) {
if (this->rx_dispatching_ || this->is_failed()) {
return;
}
uint16_t status;
uint8_t buf[3];
uint8_t rssi;
int8_t snr;
this->read_opcode_(RADIO_GET_IRQSTATUS, buf, 2);
this->write_opcode_(RADIO_CLR_IRQSTATUS, buf, 2);
status = (buf[0] << 8) | buf[1];
if ((status & IRQ_RX_DONE) == IRQ_RX_DONE) {
if ((status & IRQ_CRC_ERROR) != IRQ_CRC_ERROR) {
this->read_opcode_(RADIO_GET_PACKETSTATUS, buf, 3);
if (this->modulation_ == PACKET_TYPE_LORA) {
rssi = buf[0];
snr = buf[1];
} else {
rssi = buf[2];
snr = 0;
}
this->read_opcode_(RADIO_GET_RXBUFFERSTATUS, buf, 2);
this->packet_.resize(buf[0]);
this->read_fifo_(buf[1], this->packet_);
this->call_listeners_(this->packet_, (float) rssi / -2.0f, (float) snr / 4.0f);
}
}
}
void SX126x::run_image_cal() {
// the following values were taken from section 9.2.1 table 9-2
// in rev 2.1 of the datasheet
uint8_t buf[2] = {0, 0};
if (this->frequency_ > 900000000) {
buf[0] = 0xE1;
buf[1] = 0xE9;
} else if (this->frequency_ > 850000000) {
buf[0] = 0xD7;
buf[1] = 0xDB;
} else if (this->frequency_ > 770000000) {
buf[0] = 0xC1;
buf[1] = 0xC5;
} else if (this->frequency_ > 460000000) {
buf[0] = 0x75;
buf[1] = 0x81;
} else if (this->frequency_ > 425000000) {
buf[0] = 0x6B;
buf[1] = 0x6F;
}
if (buf[0] > 0 && buf[1] > 0) {
this->write_opcode_(RADIO_CALIBRATEIMAGE, buf, 2);
}
}
void SX126x::set_mode_rx() {
uint8_t buf[8];
// configure irq params
uint16_t irq = IRQ_RX_DONE | IRQ_RX_TX_TIMEOUT | IRQ_CRC_ERROR;
buf[0] = (irq >> 8) & 0xFF;
buf[1] = (irq >> 0) & 0xFF;
buf[2] = (irq >> 8) & 0xFF;
buf[3] = (irq >> 0) & 0xFF;
buf[4] = (IRQ_RADIO_NONE >> 8) & 0xFF;
buf[5] = (IRQ_RADIO_NONE >> 0) & 0xFF;
buf[6] = (IRQ_RADIO_NONE >> 8) & 0xFF;
buf[7] = (IRQ_RADIO_NONE >> 0) & 0xFF;
this->write_opcode_(RADIO_SET_DIOIRQPARAMS, buf, 8);
// set timeout to 0
buf[0] = 0x00;
this->write_opcode_(RADIO_SET_LORASYMBTIMEOUT, buf, 1);
// switch to continuous mode rx
buf[0] = 0xFF;
buf[1] = 0xFF;
buf[2] = 0xFF;
this->write_opcode_(RADIO_SET_RX, buf, 3);
}
void SX126x::set_mode_tx() {
uint8_t buf[8];
// configure irq params
uint16_t irq = IRQ_TX_DONE | IRQ_RX_TX_TIMEOUT;
buf[0] = (irq >> 8) & 0xFF;
buf[1] = (irq >> 0) & 0xFF;
buf[2] = (irq >> 8) & 0xFF;
buf[3] = (irq >> 0) & 0xFF;
buf[4] = (IRQ_RADIO_NONE >> 8) & 0xFF;
buf[5] = (IRQ_RADIO_NONE >> 0) & 0xFF;
buf[6] = (IRQ_RADIO_NONE >> 8) & 0xFF;
buf[7] = (IRQ_RADIO_NONE >> 0) & 0xFF;
this->write_opcode_(RADIO_SET_DIOIRQPARAMS, buf, 8);
// switch to single mode tx
buf[0] = 0x00;
buf[1] = 0x00;
buf[2] = 0x00;
this->write_opcode_(RADIO_SET_TX, buf, 3);
}
void SX126x::set_mode_sleep(bool cold) {
// 0x04 = warm start (config retained), 0x00 = cold start (config lost, lowest power)
uint8_t buf[1];
buf[0] = cold ? 0x00 : 0x04;
this->write_opcode_(RADIO_SET_SLEEP, buf, 1);
}
void SX126x::set_mode_standby(SX126xStandbyMode mode) {
uint8_t buf[1];
buf[0] = mode;
this->write_opcode_(RADIO_SET_STANDBY, buf, 1);
}
void SX126x::wait_busy_() {
// wait if the device is busy, the maximum delay is only be a few ms
// with most commands taking only a few us
uint32_t start = millis();
while (this->busy_pin_->digital_read()) {
if (millis() - start > BUSY_TIMEOUT_MS) {
this->mark_failed(LOG_STR("Wait busy timeout"));
break;
}
}
this->apply_(this->radio_.poll(App.get_loop_component_start_time(), this->packet_));
}
void SX126x::dump_config() {
ESP_LOGCONFIG(TAG, "SX126x:");
LOG_PIN(" CS Pin: ", this->cs_);
LOG_PIN(" BUSY Pin: ", this->busy_pin_);
LOG_PIN(" RST Pin: ", this->rst_pin_);
LOG_PIN(" DIO1 Pin: ", this->dio1_pin_);
ESP_LOGCONFIG(TAG, "SX126x:\n Ready for operation: %s",
YESNO(!this->is_failed() && this->radio_.state() == RadioState::RADIO_STATE_IDLE));
LOG_PIN(" CS Pin: ", this->radio_.bus().get_cs_pin());
LOG_PIN(" BUSY Pin: ", this->radio_.bus().get_busy_pin());
LOG_PIN(" RST Pin: ", this->radio_.get_rst_pin());
LOG_PIN(" DIO1 Pin: ", this->radio_.get_dio1_pin());
ESP_LOGCONFIG(TAG,
" HW Version: %15s\n"
" Requested configuration:\n"
" Frequency: %" PRIu32 " Hz\n"
" Bandwidth: %" PRIu32 " Hz\n"
" PA Power: %" PRId8 " dBm\n"
" PA Ramp: %" PRIu16 " us\n"
" Payload Length: %" PRIu32 "\n"
" Payload Length: %" PRIu8 "\n"
" CRC Enable: %s\n"
" Rx Start: %s",
this->version_, this->frequency_, BW_HZ[this->bandwidth_], this->pa_power_,
progmem_read_uint16(&RAMP[this->pa_ramp_]), this->payload_length_, TRUEFALSE(this->crc_enable_),
TRUEFALSE(this->rx_start_));
if (this->modulation_ == PACKET_TYPE_GFSK) {
this->version_, this->requested_profile_.frequency,
SX126xCommands::bandwidth_hz(this->requested_profile_.bandwidth), this->requested_profile_.pa_power,
SX126xCommands::ramp_us(this->requested_profile_.pa_ramp), this->requested_profile_.payload_length,
TRUEFALSE(this->requested_profile_.crc_enable), TRUEFALSE(this->requested_profile_.rx_start));
if (this->requested_profile_.modulation == PACKET_TYPE_GFSK) {
const char *shaping = "NONE";
if (this->shaping_ == GAUSSIAN_BT_0_3) {
if (this->requested_profile_.shaping == GAUSSIAN_BT_0_3) {
shaping = "GAUSSIAN_BT_0_3";
} else if (this->shaping_ == GAUSSIAN_BT_0_5) {
} else if (this->requested_profile_.shaping == GAUSSIAN_BT_0_5) {
shaping = "GAUSSIAN_BT_0_5";
} else if (this->shaping_ == GAUSSIAN_BT_0_7) {
} else if (this->requested_profile_.shaping == GAUSSIAN_BT_0_7) {
shaping = "GAUSSIAN_BT_0_7";
} else if (this->shaping_ == GAUSSIAN_BT_1_0) {
} else if (this->requested_profile_.shaping == GAUSSIAN_BT_1_0) {
shaping = "GAUSSIAN_BT_1_0";
}
ESP_LOGCONFIG(TAG,
@@ -539,14 +222,15 @@ void SX126x::dump_config() {
" Preamble Size: %" PRIu16 "\n"
" Preamble Detect: %" PRIu16 "\n"
" Bitrate: %" PRIu32 "b/s",
this->deviation_, shaping, this->preamble_size_, this->preamble_detect_, this->bitrate_);
} else if (this->modulation_ == PACKET_TYPE_LORA) {
this->requested_profile_.deviation, shaping, this->requested_profile_.preamble_size,
this->requested_profile_.preamble_detect, this->requested_profile_.bitrate);
} else if (this->requested_profile_.modulation == PACKET_TYPE_LORA) {
const char *cr = "4/8";
if (this->coding_rate_ == LORA_CR_4_5) {
if (this->requested_profile_.coding_rate == LORA_CR_4_5) {
cr = "4/5";
} else if (this->coding_rate_ == LORA_CR_4_6) {
} else if (this->requested_profile_.coding_rate == LORA_CR_4_6) {
cr = "4/6";
} else if (this->coding_rate_ == LORA_CR_4_7) {
} else if (this->requested_profile_.coding_rate == LORA_CR_4_7) {
cr = "4/7";
}
ESP_LOGCONFIG(TAG,
@@ -554,16 +238,17 @@ void SX126x::dump_config() {
" Spreading Factor: %" PRIu8 "\n"
" Coding Rate: %s\n"
" Preamble Size: %" PRIu16,
this->spreading_factor_, cr, this->preamble_size_);
this->requested_profile_.spreading_factor, cr, this->requested_profile_.preamble_size);
}
if (!this->sync_value_.empty()) {
if (this->requested_profile_.sync_size != 0) {
char hex_buf[17]; // 8 bytes max = 16 hex chars + null
ESP_LOGCONFIG(TAG, " Sync Value: 0x%s",
format_hex_to(hex_buf, this->sync_value_.data(), this->sync_value_.size()));
ESP_LOGCONFIG(
TAG, " Sync Value: 0x%s",
format_hex_to(hex_buf, this->requested_profile_.sync_value.data(), this->requested_profile_.sync_size));
}
ESP_LOGCONFIG(TAG, " Whitening Enable: %s", TRUEFALSE(this->whitening_enable_));
if (this->whitening_enable_) {
ESP_LOGCONFIG(TAG, " Whitening Initial: 0x%03x", this->whitening_initial_);
ESP_LOGCONFIG(TAG, " Whitening Enable: %s", TRUEFALSE(this->requested_profile_.whitening_enable));
if (this->requested_profile_.whitening_enable) {
ESP_LOGCONFIG(TAG, " Whitening Initial: 0x%03x", this->requested_profile_.whitening_initial);
}
}
+82 -114
View File
@@ -1,157 +1,125 @@
#pragma once
#include "sx126x_radio.h"
#include "esphome/components/spi/spi.h"
#include "esphome/core/automation.h"
#include "esphome/core/component.h"
#include "esphome/core/hal.h"
#include "sx126x_reg.h"
#include <utility>
#include <vector>
namespace esphome::sx126x {
static constexpr size_t SX126X_MAX_PACKET_SIZE = 255;
enum SX126xBw : uint8_t {
// FSK
SX126X_BW_4800,
SX126X_BW_5800,
SX126X_BW_7300,
SX126X_BW_9700,
SX126X_BW_11700,
SX126X_BW_14600,
SX126X_BW_19500,
SX126X_BW_23400,
SX126X_BW_29300,
SX126X_BW_39000,
SX126X_BW_46900,
SX126X_BW_58600,
SX126X_BW_78200,
SX126X_BW_93800,
SX126X_BW_117300,
SX126X_BW_156200,
SX126X_BW_187200,
SX126X_BW_234300,
SX126X_BW_312000,
SX126X_BW_373600,
SX126X_BW_467000,
// LORA
SX126X_BW_7810,
SX126X_BW_10420,
SX126X_BW_15630,
SX126X_BW_20830,
SX126X_BW_31250,
SX126X_BW_41670,
SX126X_BW_62500,
SX126X_BW_125000,
SX126X_BW_250000,
SX126X_BW_500000,
};
enum class SX126xError { NONE = 0, TIMEOUT, INVALID_PARAMS, SX126X_ERROR_NOT_READY };
class SX126xListener {
public:
// Called from loop(). The packet is borrowed until this returns; copy what you keep.
// Listeners may send, change mode or configure. A send returns BUSY if another packet
// is already waiting, which is then delivered by the next loop().
virtual void on_packet(const std::vector<uint8_t> &packet, float rssi, float snr) = 0;
};
class SX126x final : public Component,
public spi::SPIDevice<spi::BIT_ORDER_MSB_FIRST, spi::CLOCK_POLARITY_LOW, spi::CLOCK_PHASE_LEADING,
spi::DATA_RATE_8MHZ> {
class SX126x final : public Component {
public:
void set_spi_parent(spi::SPIComponent *parent) { this->radio_.bus().set_spi_parent(parent); }
void set_cs_pin(GPIOPin *pin) { this->radio_.bus().set_cs_pin(pin); }
void set_data_rate(uint32_t rate) { this->radio_.bus().set_data_rate(rate); }
void set_mode(spi::SPIMode mode) { this->radio_.bus().set_mode(mode); }
void set_bit_order(spi::SPIBitOrder order) { this->radio_.bus().set_bit_order(order); }
void set_release_device(bool release) { this->radio_.bus().set_release_device(release); }
void set_write_only(bool write_only) { this->radio_.bus().set_write_only(write_only); }
#ifdef USE_SPI_PSRAM_DMA
void set_psram_dma(bool enable) { this->radio_.bus().set_psram_dma(enable); }
#endif
// Releases the SPI bus, as SPIDevice::spi_teardown() did before SX126x stopped being one
void spi_teardown() { this->radio_.bus().teardown(); }
size_t get_max_packet_size();
float get_setup_priority() const override { return setup_priority::PROCESSOR; }
void setup() override;
void loop() override;
void dump_config() override;
void set_bandwidth(SX126xBw bandwidth) { this->bandwidth_ = bandwidth; }
void set_bitrate(uint32_t bitrate) { this->bitrate_ = bitrate; }
void set_busy_pin(GPIOPin *busy_pin) { this->busy_pin_ = busy_pin; }
void set_coding_rate(uint8_t coding_rate) { this->coding_rate_ = coding_rate; }
void set_crc_enable(bool crc_enable) { this->crc_enable_ = crc_enable; }
void set_crc_inverted(bool crc_inverted) { this->crc_inverted_ = crc_inverted; }
void set_crc_size(uint8_t crc_size) { this->crc_size_ = crc_size; }
void set_crc_polynomial(uint16_t crc_polynomial) { this->crc_polynomial_ = crc_polynomial; }
void set_crc_initial(uint16_t crc_initial) { this->crc_initial_ = crc_initial; }
void set_whitening_enable(bool whitening_enable) { this->whitening_enable_ = whitening_enable; }
void set_whitening_initial(uint16_t whitening_initial) { this->whitening_initial_ = whitening_initial; }
void set_deviation(uint32_t deviation) { this->deviation_ = deviation; }
void set_dio1_pin(GPIOPin *dio1_pin) { this->dio1_pin_ = dio1_pin; }
void set_frequency(uint32_t frequency) { this->frequency_ = frequency; }
void set_sx1261(bool sx1261) { this->sx1261_ = sx1261; }
void set_bandwidth(SX126xBw bandwidth) { this->requested_profile_.bandwidth = bandwidth; }
void set_bitrate(uint32_t bitrate) { this->requested_profile_.bitrate = bitrate; }
void set_busy_pin(GPIOPin *busy_pin) { this->radio_.bus().set_busy_pin(busy_pin); }
void set_coding_rate(uint8_t coding_rate) { this->requested_profile_.coding_rate = coding_rate; }
void set_crc_enable(bool crc_enable) { this->requested_profile_.crc_enable = crc_enable; }
void set_crc_inverted(bool crc_inverted) { this->requested_profile_.crc_inverted = crc_inverted; }
void set_crc_size(uint8_t crc_size) { this->requested_profile_.crc_size = crc_size; }
void set_crc_polynomial(uint16_t crc_polynomial) { this->requested_profile_.crc_polynomial = crc_polynomial; }
void set_crc_initial(uint16_t crc_initial) { this->requested_profile_.crc_initial = crc_initial; }
void set_whitening_enable(bool whitening_enable) { this->requested_profile_.whitening_enable = whitening_enable; }
void set_whitening_initial(uint16_t whitening_initial) {
this->requested_profile_.whitening_initial = whitening_initial;
}
void set_deviation(uint32_t deviation) { this->requested_profile_.deviation = deviation; }
void set_dio1_pin(GPIOPin *dio1_pin) { this->radio_.set_dio1_pin(dio1_pin); }
void set_frequency(uint32_t frequency) { this->requested_profile_.frequency = frequency; }
void set_sx1261(bool sx1261) { this->requested_profile_.sx1261 = sx1261; }
// Mode changes are ignored with a warning unless the radio is idle and configured.
void set_mode_rx();
void set_mode_tx();
void set_mode_standby(SX126xStandbyMode mode);
void set_mode_sleep(bool cold = false);
void set_modulation(uint8_t modulation) { this->modulation_ = modulation; }
void set_pa_power(int8_t power) { this->pa_power_ = power; }
void set_pa_ramp(uint8_t ramp) { this->pa_ramp_ = ramp; }
void set_payload_length(uint8_t payload_length) { this->payload_length_ = payload_length; }
void set_preamble_detect(uint16_t preamble_detect) { this->preamble_detect_ = preamble_detect; }
void set_preamble_size(uint16_t preamble_size) { this->preamble_size_ = preamble_size; }
void set_rst_pin(GPIOPin *rst_pin) { this->rst_pin_ = rst_pin; }
void set_rx_start(bool rx_start) { this->rx_start_ = rx_start; }
void set_rf_switch(bool rf_switch) { this->rf_switch_ = rf_switch; }
void set_shaping(uint8_t shaping) { this->shaping_ = shaping; }
void set_spreading_factor(uint8_t spreading_factor) { this->spreading_factor_ = spreading_factor; }
void set_sync_value(const std::vector<uint8_t> &sync_value) { this->sync_value_ = sync_value; }
void set_tcxo_voltage(uint8_t tcxo_voltage) { this->tcxo_voltage_ = tcxo_voltage; }
void set_tcxo_delay(uint32_t tcxo_delay) { this->tcxo_delay_ = tcxo_delay; }
void set_modulation(uint8_t modulation) { this->requested_profile_.modulation = modulation; }
void set_pa_power(int8_t power) { this->requested_profile_.pa_power = power; }
void set_pa_ramp(uint8_t ramp) { this->requested_profile_.pa_ramp = ramp; }
void set_payload_length(uint8_t payload_length) { this->requested_profile_.payload_length = payload_length; }
void set_preamble_detect(uint16_t preamble_detect) { this->requested_profile_.preamble_detect = preamble_detect; }
void set_preamble_size(uint16_t preamble_size) { this->requested_profile_.preamble_size = preamble_size; }
void set_rst_pin(GPIOPin *rst_pin) { this->radio_.set_rst_pin(rst_pin); }
void set_rx_start(bool rx_start) { this->requested_profile_.rx_start = rx_start; }
void set_rf_switch(bool rf_switch) { this->requested_profile_.rf_switch = rf_switch; }
void set_shaping(uint8_t shaping) { this->requested_profile_.shaping = shaping; }
void set_spreading_factor(uint8_t spreading_factor) { this->requested_profile_.spreading_factor = spreading_factor; }
void set_sync_value(const std::vector<uint8_t> &sync_value) { this->requested_profile_.set_sync_value(sync_value); }
void set_tcxo_voltage(uint8_t tcxo_voltage) { this->requested_profile_.tcxo_voltage = tcxo_voltage; }
void set_tcxo_delay(uint32_t tcxo_delay) { this->requested_profile_.tcxo_delay = tcxo_delay; }
void run_image_cal();
// Mode changes and configuration are allowed during RX callbacks when the radio
// is available; they never modify the borrowed packet buffer.
void configure();
SX126xError transmit_packet(const uint8_t *data, size_t len);
SX126xError transmit_packet(const std::vector<uint8_t> &packet) {
return this->transmit_packet(packet.data(), packet.size());
}
// Main-loop context only. SX126X_ERROR_NONE accepts one operation and promises one completion.
// Data is copied into the chip FIFO before return; listener must outlive completion.
// Pending RX rejects admission with BUSY and is delivered by a later loop().
// Timeout: 1..262143 ms. SPI/BUSY waits are synchronous; airtime is asynchronous.
[[nodiscard]] SX126xError start_transmit_async(SX126xTransmitListener *listener, const uint8_t *data, size_t len,
uint32_t timeout_ms = 4000);
[[nodiscard]] SX126xError start_transmit_async(SX126xTransmitListener *listener, const std::vector<uint8_t> &packet,
uint32_t timeout_ms = 4000) {
return this->start_transmit_async(listener, packet.data(), packet.size(), timeout_ms);
}
// Normal completion runs in loop(); cancellation completes synchronously in its caller.
// The radio is released before callbacks, which may start another operation if recovery
// succeeded. True accepts cancellation; the completion result reports cleanup failure.
bool cancel_transmit_async(SX126xTransmitListener *listener);
bool is_transmitting() const { return this->radio_.is_transmitting(); }
void register_listener(SX126xListener *listener) { this->listeners_.push_back(listener); }
// True while a packet is being received, or has been received and not yet read; sending would lose it.
bool is_receiving() { return this->radio_.is_receiving(); }
Trigger<std::vector<uint8_t>, float, float> *get_packet_trigger() { return &this->packet_trigger_; }
protected:
static void gpio_intr(SX126x *arg);
void configure_fsk_ook_();
void configure_lora_();
void set_packet_params_(uint8_t payload_length);
uint8_t read_fifo_(uint8_t offset, std::vector<uint8_t> &packet);
void write_fifo_(uint8_t offset, const uint8_t *data, size_t len);
void write_opcode_(uint8_t opcode, uint8_t *data, uint8_t size);
uint8_t read_opcode_(uint8_t opcode, uint8_t *data, uint8_t size);
void write_register_(uint16_t reg, uint8_t *data, uint8_t size);
void read_register_(uint16_t reg, uint8_t *data, uint8_t size);
void call_listeners_(const std::vector<uint8_t> &packet, float rssi, float snr);
void wait_busy_();
private:
static void IRAM_ATTR gpio_intr(SX126x *arg) { arg->enable_loop_soon_any_context(); }
void change_mode_(ModeCommand command, uint8_t arg = 0);
// The only place that runs user code for a radio operation: loop scheduling, then status,
// then the completion or packet listeners. SX126xRadio has already committed its state.
void apply_(const RadioEffects &effects);
void watch_configuration_();
SX126xError start_transmit_(SX126xTransmitListener *listener, const uint8_t *data, size_t len, uint32_t timeout_ms);
SX126xRadio radio_;
RadioProfile requested_profile_;
char version_[16]{};
Trigger<std::vector<uint8_t>, float, float> packet_trigger_;
std::vector<SX126xListener *> listeners_;
std::vector<uint8_t> packet_;
std::vector<uint8_t> sync_value_;
GPIOPin *busy_pin_{nullptr};
GPIOPin *dio1_pin_{nullptr};
GPIOPin *rst_pin_{nullptr};
uint32_t bitrate_{0};
uint32_t deviation_{0};
uint32_t frequency_{0};
uint32_t payload_length_{0};
uint32_t tcxo_delay_{0};
uint16_t crc_polynomial_{0};
uint16_t crc_initial_{0};
uint16_t whitening_initial_{0};
uint16_t preamble_detect_{0};
uint16_t preamble_size_{0};
char version_[16];
SX126xBw bandwidth_{SX126X_BW_125000};
uint8_t crc_size_{0};
uint8_t tcxo_voltage_{0};
uint8_t coding_rate_{0};
uint8_t modulation_{PACKET_TYPE_LORA};
uint8_t pa_ramp_{0};
uint8_t shaping_{0};
uint8_t spreading_factor_{0};
int8_t pa_power_{0};
bool sx1261_{false};
bool crc_enable_{false};
bool crc_inverted_{false};
bool whitening_enable_{false};
bool rx_start_{false};
bool rf_switch_{false};
bool rx_dispatching_{false};
bool cold_sleep_{false};
bool reconfigure_pending_{false};
};
} // namespace esphome::sx126x
@@ -0,0 +1,332 @@
#include "sx126x_commands.h"
#include "esphome/core/hal.h"
#include "esphome/core/helpers.h"
#include <cmath>
#include <cstring>
namespace esphome::sx126x {
static constexpr uint16_t RAMP[8] PROGMEM = {10, 20, 40, 80, 200, 800, 1700, 3400};
// Aligned 32 bit loads from flash are safe on ESP8266, so this table is read directly
static constexpr uint32_t BW_HZ[31] PROGMEM = {4800, 5800, 7300, 9700, 11700, 14600, 19500, 23400,
29300, 39000, 46900, 58600, 78200, 93800, 117300, 156200,
187200, 234300, 312000, 373600, 467000, 7810, 10420, 15630,
20830, 31250, 41670, 62500, 125000, 250000, 500000};
static constexpr uint8_t BW_LORA[10] PROGMEM = {LORA_BW_7810, LORA_BW_10420, LORA_BW_15630, LORA_BW_20830,
LORA_BW_31250, LORA_BW_41670, LORA_BW_62500, LORA_BW_125000,
LORA_BW_250000, LORA_BW_500000};
static constexpr uint8_t BW_FSK[21] PROGMEM = {
FSK_BW_4800, FSK_BW_5800, FSK_BW_7300, FSK_BW_9700, FSK_BW_11700, FSK_BW_14600, FSK_BW_19500,
FSK_BW_23400, FSK_BW_29300, FSK_BW_39000, FSK_BW_46900, FSK_BW_58600, FSK_BW_78200, FSK_BW_93800,
FSK_BW_117300, FSK_BW_156200, FSK_BW_187200, FSK_BW_234300, FSK_BW_312000, FSK_BW_373600, FSK_BW_467000};
// OCP (Over Current Protection) values
static constexpr uint8_t OCP_80MA = 0x18; // 80 mA max current
static constexpr uint8_t OCP_140MA = 0x38; // 140 mA max current
// LoRa low data rate optimization threshold
static constexpr float LOW_DATA_RATE_OPTIMIZE_THRESHOLD = 16.38f; // 16.38 ms
void SX126xCommands::read_opcode_(uint8_t opcode, uint8_t *data, uint8_t size) {
const uint8_t header[] = {opcode, 0};
this->spi_device_.read(header, {data, size});
}
void SX126xCommands::write_opcode_(uint8_t opcode, const uint8_t *data, uint8_t size) {
this->spi_device_.write({&opcode, 1}, {data, size});
}
void SX126xCommands::read_register_(uint16_t reg, uint8_t *data, uint8_t size) {
const uint8_t header[] = {RADIO_READ_REGISTER, static_cast<uint8_t>(reg >> 8), static_cast<uint8_t>(reg), 0};
this->spi_device_.read(header, {data, size});
}
void SX126xCommands::write_register_(uint16_t reg, const uint8_t *data, uint8_t size) {
const uint8_t header[] = {RADIO_WRITE_REGISTER, static_cast<uint8_t>(reg >> 8), static_cast<uint8_t>(reg)};
this->spi_device_.write(header, {data, size});
}
ConfigurationResult SX126xCommands::configure(const RadioProfile &profile, std::span<char, 16> version,
AppliedProfile &applied) {
applied.frequency = profile.frequency;
applied.payload_length = profile.payload_length;
applied.modulation = profile.modulation;
applied.rx_start = profile.rx_start;
encode_packet_params(profile, applied);
uint8_t buf[8];
// wakeup
this->read_opcode_(RADIO_GET_STATUS, nullptr, 0);
// config tcxo
if (profile.tcxo_voltage != TCXO_CTRL_NONE) {
uint32_t delay = profile.tcxo_delay >> 6;
buf[0] = profile.tcxo_voltage;
put_be24(buf + 1, delay);
this->write_opcode_(RADIO_SET_TCXOMODE, buf, 4);
buf[0] = 0x7F;
this->write_opcode_(RADIO_CALIBRATE, buf, 1);
}
// clear errors
buf[0] = 0x00;
buf[1] = 0x00;
this->write_opcode_(RADIO_CLR_ERROR, buf, 2);
// rf switch
if (profile.rf_switch) {
buf[0] = 0x01;
this->write_opcode_(RADIO_SET_RFSWITCHMODE, buf, 1);
}
// check silicon version to make sure hw is ok
this->read_register_(REG_VERSION_STRING, reinterpret_cast<uint8_t *>(version.data()), version.size());
if (!this->spi_device_.ok()) {
return ConfigurationResult::CONFIGURATION_RESULT_BUSY_TIMEOUT;
}
version[version.size() - 1] = '\0';
if (strncmp(version.data(), "SX126", 5) != 0 && strncmp(version.data(), "LLCC68", 6) != 0) {
return ConfigurationResult::CONFIGURATION_RESULT_UNSUPPORTED;
}
// setup packet type
buf[0] = profile.modulation;
this->write_opcode_(RADIO_SET_PACKETTYPE, buf, 1);
// calibrate image
this->calibrate_image(profile.frequency);
// set frequency
uint64_t freq = ((uint64_t) profile.frequency << 25) / XTAL_FREQ;
put_be32(buf, static_cast<uint32_t>(freq));
this->write_opcode_(RADIO_SET_RFFREQUENCY, buf, 4);
// configure pa
int8_t pa_power = profile.pa_power;
if (profile.sx1261) {
// the following values were taken from section 13.1.14.1 table 13-21
// in rev 2.1 of the datasheet
if (pa_power == 15) {
uint8_t cfg[4] = {0x06, 0x00, 0x01, 0x01};
this->write_opcode_(RADIO_SET_PACONFIG, cfg, 4);
} else {
uint8_t cfg[4] = {0x04, 0x00, 0x01, 0x01};
this->write_opcode_(RADIO_SET_PACONFIG, cfg, 4);
}
pa_power = clamp(pa_power, (int8_t) -3, (int8_t) 14);
buf[0] = OCP_80MA;
this->write_register_(REG_OCP, buf, 1);
} else {
// the following values were taken from section 13.1.14.1 table 13-21
// in rev 2.1 of the datasheet
uint8_t cfg[4] = {0x04, 0x07, 0x00, 0x01};
this->write_opcode_(RADIO_SET_PACONFIG, cfg, 4);
pa_power = clamp(pa_power, (int8_t) -3, (int8_t) 22);
buf[0] = OCP_140MA;
this->write_register_(REG_OCP, buf, 1);
}
buf[0] = pa_power;
buf[1] = profile.pa_ramp;
this->write_opcode_(RADIO_SET_TXPARAMS, buf, 2);
// configure modem
if (profile.modulation == PACKET_TYPE_LORA) {
// set modulation params
float duration = 1000.0f * (1UL << profile.spreading_factor) / BW_HZ[profile.bandwidth];
buf[0] = profile.spreading_factor;
buf[1] = progmem_read_byte(&BW_LORA[profile.bandwidth - SX126X_BW_7810]);
buf[2] = profile.coding_rate;
buf[3] = (duration > LOW_DATA_RATE_OPTIMIZE_THRESHOLD) ? 0x01 : 0x00;
this->write_opcode_(RADIO_SET_MODULATIONPARAMS, buf, 4);
// set packet params and sync word
this->write_opcode_(RADIO_SET_PACKETPARAMS, applied.packet_params.data(), applied.packet_params_size);
if (profile.sync_size == 2) {
this->write_register_(REG_LORA_SYNCWORD, profile.sync_value.data(), profile.sync_size);
}
} else {
// set modulation params
uint32_t bitrate = ((uint64_t) XTAL_FREQ * 32) / profile.bitrate;
uint32_t fdev = ((uint64_t) profile.deviation << 25) / XTAL_FREQ;
put_be24(buf, bitrate);
buf[3] = profile.shaping;
buf[4] = progmem_read_byte(&BW_FSK[profile.bandwidth - SX126X_BW_4800]);
put_be24(buf + 5, fdev);
this->write_opcode_(RADIO_SET_MODULATIONPARAMS, buf, 8);
// set crc params
if (profile.crc_enable) {
put_be16(buf, profile.crc_initial);
this->write_register_(REG_CRC_INITIAL, buf, 2);
put_be16(buf, profile.crc_polynomial);
this->write_register_(REG_CRC_POLYNOMIAL, buf, 2);
}
// set whitening params
if (profile.whitening_enable) {
// according to the datasheet, section 12 table 12-1 "The user should not
// change the value of the 7 MSB of this register"
this->read_register_(REG_WHITENING_INITIAL, buf, 1);
buf[0] = (buf[0] & 0xFE) | ((profile.whitening_initial >> 8) & 0x01);
buf[1] = profile.whitening_initial & 0xFF;
this->write_register_(REG_WHITENING_INITIAL, buf, 2);
}
// set packet params and sync word
this->write_opcode_(RADIO_SET_PACKETPARAMS, applied.packet_params.data(), applied.packet_params_size);
if (profile.sync_size != 0) {
this->write_register_(REG_GFSK_SYNCWORD, profile.sync_value.data(), profile.sync_size);
}
}
// switch to rx or sleep
if (profile.rx_start) {
this->receive();
} else {
this->sleep();
}
return this->spi_device_.ok() ? ConfigurationResult::CONFIGURATION_RESULT_OK
: ConfigurationResult::CONFIGURATION_RESULT_BUSY_TIMEOUT;
}
void SX126xCommands::encode_packet_params(const RadioProfile &profile, AppliedProfile &applied) {
auto &buf = applied.packet_params;
const uint8_t payload_length = profile.max_packet_size();
if (profile.modulation == PACKET_TYPE_LORA) {
put_be16(buf.data(), profile.preamble_size);
buf[2] = (profile.payload_length > 0) ? 0x01 : 0x00;
buf[3] = payload_length;
buf[4] = (profile.crc_enable) ? 0x01 : 0x00;
buf[5] = 0x00;
applied.packet_params_size = 6;
} else {
uint16_t preamble_size = profile.preamble_size * 8;
put_be16(buf.data(), preamble_size);
buf[2] = (profile.preamble_detect > 0) ? ((profile.preamble_detect - 1) | 0x04) : 0x00;
buf[3] = profile.sync_size * 8;
buf[4] = 0x00;
buf[5] = (profile.payload_length > 0) ? 0x00 : 0x01;
buf[6] = payload_length;
if (profile.crc_enable) {
buf[7] = (profile.crc_inverted ? 0x04 : 0x00) + (profile.crc_size & 0x02);
} else {
buf[7] = 0x01;
}
buf[8] = (profile.whitening_enable) ? 0x01 : 0x00;
applied.packet_params_size = 9;
}
}
void SX126xCommands::set_packet_length(AppliedProfile &applied, uint8_t length) {
applied.packet_params[applied.modulation == PACKET_TYPE_LORA ? 3 : 6] = length;
this->write_opcode_(RADIO_SET_PACKETPARAMS, applied.packet_params.data(), applied.packet_params_size);
}
void SX126xCommands::calibrate_image(uint32_t frequency) {
// the following values were taken from section 9.2.1 table 9-2
// in rev 2.1 of the datasheet
uint8_t buf[2] = {0, 0};
if (frequency > 900000000) {
buf[0] = 0xE1;
buf[1] = 0xE9;
} else if (frequency > 850000000) {
buf[0] = 0xD7;
buf[1] = 0xDB;
} else if (frequency > 770000000) {
buf[0] = 0xC1;
buf[1] = 0xC5;
} else if (frequency > 460000000) {
buf[0] = 0x75;
buf[1] = 0x81;
} else if (frequency > 425000000) {
buf[0] = 0x6B;
buf[1] = 0x6F;
}
if (buf[0] > 0 && buf[1] > 0) {
this->write_opcode_(RADIO_CALIBRATEIMAGE, buf, 2);
}
}
// Only the dio1 interrupts are routed to DIO1; DIO2 and DIO3 stay unused.
void SX126xCommands::set_dio_irq_params_(uint16_t flags, uint16_t dio1) {
uint8_t buf[8];
put_be16(buf, flags);
put_be16(buf + 2, dio1);
put_be16(buf + 4, IRQ_RADIO_NONE);
put_be16(buf + 6, IRQ_RADIO_NONE);
this->write_opcode_(RADIO_SET_DIOIRQPARAMS, buf, 8);
}
void SX126xCommands::receive() {
// A valid header or sync word is flagged for SX126xRadio::is_receiving(), but not signalled on DIO1
const uint16_t irq = IRQ_RX_DONE | IRQ_RX_TX_TIMEOUT | IRQ_CRC_ERROR;
this->set_dio_irq_params_(irq | IRQ_HEADER_VALID | IRQ_SYNCWORD_VALID, irq);
uint8_t buf[3];
// set timeout to 0
buf[0] = 0x00;
this->write_opcode_(RADIO_SET_LORASYMBTIMEOUT, buf, 1);
// switch to continuous mode rx
buf[0] = 0xFF;
buf[1] = 0xFF;
buf[2] = 0xFF;
this->write_opcode_(RADIO_SET_RX, buf, 3);
}
void SX126xCommands::transmit(uint32_t timeout_ms) {
this->set_dio_irq_params_(IRQ_TX_DONE | IRQ_RX_TX_TIMEOUT, IRQ_TX_DONE | IRQ_RX_TX_TIMEOUT);
uint8_t buf[3];
const uint32_t ticks = timeout_ms * 64;
put_be24(buf, ticks);
this->write_opcode_(RADIO_SET_TX, buf, 3);
}
void SX126xCommands::sleep(bool cold) {
// 0x04 = warm start (config retained), 0x00 = cold start (config lost, lowest power)
const uint8_t mode = cold ? 0x00 : 0x04;
this->write_opcode_(RADIO_SET_SLEEP, &mode, 1);
}
void SX126xCommands::standby(SX126xStandbyMode mode) {
const uint8_t value = mode;
this->write_opcode_(RADIO_SET_STANDBY, &value, 1);
}
uint32_t SX126xCommands::bandwidth_hz(SX126xBw bw) { return BW_HZ[bw]; }
uint16_t SX126xCommands::ramp_us(uint8_t ramp) { return progmem_read_uint16(&RAMP[ramp]); }
void SX126xCommands::clear_irqs(uint16_t mask) {
const uint8_t data[] = {static_cast<uint8_t>(mask >> 8), static_cast<uint8_t>(mask)};
this->write_opcode_(RADIO_CLR_IRQSTATUS, data, 2);
}
uint16_t SX126xCommands::read_irq() {
uint8_t data[2]{};
this->read_opcode_(RADIO_GET_IRQSTATUS, data, 2);
return (uint16_t(data[0]) << 8) | data[1];
}
void SX126xCommands::write_fifo(const uint8_t *data, size_t size) {
const uint8_t header[] = {RADIO_WRITE_BUFFER, 0};
this->spi_device_.write(header, {data, size});
}
void SX126xCommands::read_packet(uint8_t modulation, std::vector<uint8_t> &packet, float &rssi, float &snr) {
uint8_t data[3]{};
this->read_opcode_(RADIO_GET_PACKETSTATUS, data, 3);
rssi = (modulation == PACKET_TYPE_LORA ? data[0] : data[2]) / -2.0f;
// FSK packets report no SNR
snr = modulation == PACKET_TYPE_LORA ? static_cast<int8_t>(data[1]) / 4.0f : NAN;
this->read_opcode_(RADIO_GET_RXBUFFERSTATUS, data, 2);
if (!this->spi_device_.ok()) {
return; // The length and offset were not read.
}
packet.resize(data[0]);
const uint8_t header[] = {RADIO_READ_BUFFER, data[1], 0};
this->spi_device_.read(header, packet);
}
} // namespace esphome::sx126x
@@ -0,0 +1,50 @@
#pragma once
#include "radio_profile.h"
#include "sx126x_spi_device.h"
#include <vector>
namespace esphome::sx126x {
enum class ConfigurationResult {
CONFIGURATION_RESULT_OK,
CONFIGURATION_RESULT_BUSY_TIMEOUT,
CONFIGURATION_RESULT_UNSUPPORTED
};
// Encodes chip commands. No ESPHome lifecycle, callbacks, or raw SPI access.
// Commands record failure in the SPI device: callers start a sequence with begin()
// and check ok() at its end, or before acting on a value that was read.
class SX126xCommands {
public:
SX126xCommands() = default;
SX126xCommands(const SX126xCommands &) = delete;
SX126xCommands &operator=(const SX126xCommands &) = delete;
SX126xSpiDevice &bus() { return this->spi_device_; }
// Fills applied as it goes; only use it if the result is OK.
[[nodiscard]] ConfigurationResult configure(const RadioProfile &profile, std::span<char, 16> version,
AppliedProfile &applied);
// Sets the payload length in the applied packet parameters and writes them.
void set_packet_length(AppliedProfile &applied, uint8_t length);
void calibrate_image(uint32_t frequency);
void standby(SX126xStandbyMode mode);
void receive();
void transmit(uint32_t timeout_ms = 0);
void sleep(bool cold = false);
void clear_irqs(uint16_t mask = 0xFFFF);
// Returns 0 if the read was skipped or failed.
uint16_t read_irq();
void write_fifo(const uint8_t *data, size_t size);
// Leaves the packet unchanged if a read fails.
void read_packet(uint8_t modulation, std::vector<uint8_t> &packet, float &rssi, float &snr);
static uint32_t bandwidth_hz(SX126xBw bw);
static uint16_t ramp_us(uint8_t ramp);
private:
void read_opcode_(uint8_t opcode, uint8_t *data, uint8_t size);
void write_opcode_(uint8_t opcode, const uint8_t *data, uint8_t size);
void set_dio_irq_params_(uint16_t flags, uint16_t dio1);
void read_register_(uint16_t reg, uint8_t *data, uint8_t size);
void write_register_(uint16_t reg, const uint8_t *data, uint8_t size);
static void encode_packet_params(const RadioProfile &profile, AppliedProfile &applied);
SX126xSpiDevice spi_device_;
};
} // namespace esphome::sx126x
+273
View File
@@ -0,0 +1,273 @@
#include "sx126x_radio.h"
#include "esphome/core/log.h"
#include <utility>
namespace esphome::sx126x {
// No ESP_LOG calls in this file: log listeners are user code, see sx126x_radio.h.
static constexpr uint32_t RESET_DELAY_HIGH_US = 5000;
static constexpr uint32_t RESET_DELAY_LOW_US = 2000;
static constexpr uint32_t RECEIVE_RETRY_INTERVAL_MS = 200;
RadioEffects SX126xRadio::comm_report(bool ok) {
RadioEffects effects;
effects.report = true;
effects.warning = ok ? nullptr : LOG_STR("Wait busy timeout");
return effects;
}
RadioEffects SX126xRadio::configure(const RadioProfile &requested, std::span<char, 16> version) {
ESPHOME_DEBUG_ASSERT(this->can_configure());
this->busy_ = true;
this->rx_retry_pending_ = false;
this->pending_irq_ = 0;
RadioEffects effects;
effects.report = true;
effects.warning = this->apply_configuration_(requested, version);
this->commit_(effects.warning == nullptr ? RadioState::RADIO_STATE_IDLE
: RadioState::RADIO_STATE_NEEDS_CONFIGURATION);
return effects;
}
const LogString *SX126xRadio::apply_configuration_(const RadioProfile &requested, std::span<char, 16> version) {
if (!requested.sync_valid) {
return LOG_STR("Invalid sync value");
}
this->rst_pin_->digital_write(true);
delayMicroseconds(RESET_DELAY_HIGH_US);
this->rst_pin_->digital_write(false);
delayMicroseconds(RESET_DELAY_LOW_US);
this->rst_pin_->digital_write(true);
delayMicroseconds(RESET_DELAY_HIGH_US);
this->bus().begin();
AppliedProfile applied;
switch (this->commands_.configure(requested, version, applied)) {
case ConfigurationResult::CONFIGURATION_RESULT_OK:
this->applied_ = applied;
return nullptr;
case ConfigurationResult::CONFIGURATION_RESULT_UNSUPPORTED:
return LOG_STR("Unsupported chip version");
default:
return LOG_STR("Wait busy timeout");
}
}
RadioEffects SX126xRadio::change_mode(ModeCommand command, uint8_t arg) {
ESPHOME_DEBUG_ASSERT(this->can_change_mode());
this->busy_ = true;
this->bus().begin();
switch (command) {
case ModeCommand::MODE_COMMAND_RX:
this->commands_.receive();
break;
case ModeCommand::MODE_COMMAND_TX:
this->commands_.transmit();
break;
case ModeCommand::MODE_COMMAND_STANDBY:
this->commands_.standby(static_cast<SX126xStandbyMode>(arg));
break;
case ModeCommand::MODE_COMMAND_SLEEP:
case ModeCommand::MODE_COMMAND_COLD_SLEEP:
this->commands_.sleep(command == ModeCommand::MODE_COMMAND_COLD_SLEEP);
break;
case ModeCommand::MODE_COMMAND_IMAGE_CAL:
this->commands_.calibrate_image(this->applied_.frequency);
break;
}
const bool ok = this->bus().ok();
// Cold sleep loses the configuration, and a failed command leaves the chip state unknown.
this->commit_(ok && command != ModeCommand::MODE_COMMAND_COLD_SLEEP ? RadioState::RADIO_STATE_IDLE
: RadioState::RADIO_STATE_NEEDS_CONFIGURATION);
return comm_report(ok);
}
RadioEffects SX126xRadio::start_transmit(SX126xTransmitListener *listener, const uint8_t *data, size_t len,
uint32_t timeout_ms) {
RadioEffects effects;
if (this->state_ == RadioState::RADIO_STATE_NEEDS_CONFIGURATION) {
effects.result = SX126xError::SX126X_ERROR_NOT_READY;
return effects;
}
if (this->busy_ || this->state_ != RadioState::RADIO_STATE_IDLE) {
effects.result = SX126xError::SX126X_ERROR_BUSY;
return effects;
}
const uint8_t fixed_length = this->applied_.payload_length;
if (data == nullptr || len == 0 || len > this->max_packet_size() || (fixed_length != 0 && len != fixed_length)) {
effects.result = SX126xError::SX126X_ERROR_INVALID_PARAMS;
return effects;
}
this->busy_ = true;
this->bus().begin();
this->commands_.standby(STDBY_XOSC);
// RX cannot advance in standby. Keep a packet that completed before standby intact for
// poll(), before clearing IRQs or overwriting the shared FIFO. A failed read returns 0.
// A packet that failed its CRC is not delivered, so it does not hold up the send.
const uint16_t irq = this->commands_.read_irq() | this->pending_irq_;
if ((irq & IRQ_RX_DONE) && !(irq & IRQ_CRC_ERROR)) {
this->commit_(RadioState::RADIO_STATE_HOLDING_RX);
effects.result = SX126xError::SX126X_ERROR_BUSY;
return effects;
}
this->commands_.clear_irqs();
this->pending_irq_ = 0;
if (fixed_length == 0) {
this->commands_.set_packet_length(this->applied_, len);
}
this->commands_.write_fifo(data, len);
this->commands_.transmit(timeout_ms);
if (!this->bus().ok()) {
const bool restored = this->restore_();
this->commit_(restored ? RadioState::RADIO_STATE_IDLE : RadioState::RADIO_STATE_NEEDS_CONFIGURATION);
effects = comm_report(restored);
effects.result = SX126xError::SX126X_ERROR_BUSY_TIMEOUT;
return effects;
}
this->tx_ = {listener, millis(), timeout_ms};
this->commit_(RadioState::RADIO_STATE_TRANSMITTING);
// No status report on success, so no user code runs before the caller has the result.
// The completion reports status instead.
return effects;
}
RadioEffects SX126xRadio::poll_transmit(uint32_t now) {
if (this->busy_ || !this->is_transmitting()) {
return {};
}
bool done = false;
SX126xError outcome = SX126xError::SX126X_ERROR_NONE;
if (this->dio1_pin_->digital_read()) {
this->busy_ = true;
this->bus().begin();
const uint16_t status = this->commands_.read_irq();
this->commands_.clear_irqs(status);
this->busy_ = false;
if (!this->bus().ok()) {
outcome = SX126xError::SX126X_ERROR_BUSY_TIMEOUT;
done = true;
} else if (status & IRQ_RX_TX_TIMEOUT) {
outcome = SX126xError::SX126X_ERROR_TIMEOUT;
done = true;
} else if (status & IRQ_TX_DONE) {
done = true;
}
}
// A cached loop tick can precede admission; signed subtraction also handles wraparound.
if (!done && static_cast<int32_t>(now - this->tx_.started_ms) >= static_cast<int32_t>(this->tx_.timeout_ms)) {
outcome = SX126xError::SX126X_ERROR_TIMEOUT;
done = true;
}
return done ? this->finish_transmit_(outcome) : RadioEffects{};
}
RadioEffects SX126xRadio::cancel_transmit(SX126xTransmitListener *listener) {
if (this->busy_ || !this->is_transmitting() || listener == nullptr || listener != this->tx_.listener) {
return {};
}
return this->finish_transmit_(SX126xError::SX126X_ERROR_CANCELLED);
}
// The only place a send ends.
RadioEffects SX126xRadio::finish_transmit_(SX126xError result) {
this->busy_ = true;
const bool restored = this->restore_();
this->commit_(restored ? RadioState::RADIO_STATE_IDLE : RadioState::RADIO_STATE_NEEDS_CONFIGURATION);
RadioEffects effects = comm_report(restored);
effects.result = restored ? result : SX126xError::SX126X_ERROR_BUSY_TIMEOUT;
effects.listener = std::exchange(this->tx_.listener, nullptr);
effects.finished = true;
return effects;
}
bool SX126xRadio::restore_() {
this->bus().begin();
this->commands_.standby(STDBY_XOSC);
this->commands_.clear_irqs();
if (this->applied_.payload_length == 0) {
this->commands_.set_packet_length(this->applied_, this->max_packet_size());
}
if (this->applied_.rx_start) {
this->commands_.receive();
} else {
this->commands_.sleep();
}
return this->bus().ok();
}
bool SX126xRadio::is_receiving() {
if (this->state_ == RadioState::RADIO_STATE_HOLDING_RX) {
return true;
}
// A radio that sleeps after sending is not listening, and reading it would wake it
if (this->busy_ || this->state_ != RadioState::RADIO_STATE_IDLE || !this->applied_.rx_start) {
return false;
}
// DIO1 signals a received packet that loop() has not read yet
if (this->pending_irq_ != 0 || this->dio1_pin_->digital_read()) {
return true;
}
this->busy_ = true;
this->bus().begin();
const uint16_t status = this->commands_.read_irq();
this->busy_ = false;
// A failed read counts as receiving, so the link holds the send and warns if the radio stays unreadable
return !this->bus().ok() || (status & (IRQ_HEADER_VALID | IRQ_SYNCWORD_VALID)) != 0;
}
RadioEffects SX126xRadio::poll(uint32_t now, std::vector<uint8_t> &packet) {
if (this->busy_) {
return {};
}
if (this->is_transmitting()) {
return this->poll_transmit(now);
}
RadioEffects effects;
if (this->state_ == RadioState::RADIO_STATE_NEEDS_CONFIGURATION) {
effects.sleep_loop = true; // Polling cannot recover the radio; configure() can.
return effects;
}
if (this->rx_retry_pending_ && now - this->rx_retry_started_ms_ < RECEIVE_RETRY_INTERVAL_MS) {
return effects;
}
const bool holding = this->state_ == RadioState::RADIO_STATE_HOLDING_RX;
if (!holding && this->pending_irq_ == 0 && !this->dio1_pin_->digital_read()) {
effects.sleep_loop = this->dio1_pin_->is_internal(); // Its interrupt wakes the loop.
return effects;
}
return this->receive_(holding, now, packet);
}
RadioEffects SX126xRadio::receive_(bool holding, uint32_t now, std::vector<uint8_t> &packet) {
this->busy_ = true;
this->bus().begin();
// A packet whose read failed has had its flags cleared, so they are kept until it is read.
const uint16_t status = this->commands_.read_irq() | this->pending_irq_;
const bool received = (status & IRQ_RX_DONE) && !(status & IRQ_CRC_ERROR);
if (!holding) {
// Cleared before the read, so a packet that completes during the read raises DIO1 again.
// A held packet keeps its IRQ until restoration.
this->commands_.clear_irqs(status);
}
float rssi = 0, snr = 0;
if (received) {
this->commands_.read_packet(this->applied_.modulation, packet, rssi, snr);
}
const bool read = this->bus().ok();
this->pending_irq_ = read ? 0 : status;
// Do not spend a BUSY timeout on every loop while a read keeps failing.
this->rx_retry_pending_ = !read;
this->rx_retry_started_ms_ = now;
RadioState next = this->state_;
if (read && holding) {
next = this->restore_() ? RadioState::RADIO_STATE_IDLE : RadioState::RADIO_STATE_NEEDS_CONFIGURATION;
}
this->commit_(next);
RadioEffects effects = comm_report(read && next != RadioState::RADIO_STATE_NEEDS_CONFIGURATION);
effects.received = read && received;
effects.rssi = rssi;
effects.snr = snr;
return effects;
}
} // namespace esphome::sx126x
+152
View File
@@ -0,0 +1,152 @@
#pragma once
#include "radio_profile.h"
#include "sx126x_commands.h"
#include "esphome/core/hal.h"
#include "esphome/core/log.h"
#include <span>
#include <vector>
namespace esphome::sx126x {
enum class SX126xError {
SX126X_ERROR_NONE = 0,
SX126X_ERROR_TIMEOUT,
SX126X_ERROR_INVALID_PARAMS,
SX126X_ERROR_NOT_READY,
SX126X_ERROR_BUSY_TIMEOUT,
SX126X_ERROR_BUSY,
SX126X_ERROR_CANCELLED
};
class SX126xTransmitListener {
public:
virtual void on_transmit_complete(SX126xError result) = 0;
};
// Who may use the radio between operations. This is driver state, not the chip's mode.
enum class RadioState : uint8_t {
// Startup, cold sleep, or a failed configuration, mode command or restoration. Only
// configure() is accepted; sends return NOT_READY and the loop sleeps. SX126x configures
// again every second after a failure, and on the next mode command after cold sleep.
RADIO_STATE_NEEDS_CONFIGURATION,
// Available. The chip is receiving or sleeping, as configured, or after the TX mode command
// sending whatever the FIFO holds. That send is not tracked: a send or mode command may cut
// it short, and poll() clears its TX_DONE as a flag without a packet.
RADIO_STATE_IDLE,
// A send is on air. SPI is free between polls; only polling and cancellation are accepted.
RADIO_STATE_TRANSMITTING,
// Standby with a received packet left in the FIFO, found when a send entered standby.
// The send was rejected with BUSY; the next poll() delivers the packet and restores the
// radio. configure() may discard it to recover from repeated read failures.
RADIO_STATE_HOLDING_RX,
};
enum class ModeCommand : uint8_t {
MODE_COMMAND_RX,
MODE_COMMAND_TX,
MODE_COMMAND_STANDBY,
MODE_COMMAND_SLEEP,
MODE_COMMAND_COLD_SLEEP,
MODE_COMMAND_IMAGE_CAL,
};
// What a radio operation leaves for its caller to do. The radio has already committed its
// state; the caller reports status first, then calls the listener or delivers the packet.
struct RadioEffects {
SX126xError result{SX126xError::SX126X_ERROR_NONE};
// The completion to notify when finished is set; null for a blocking send.
SX126xTransmitListener *listener{nullptr};
// With report set: the warning to set, or null to clear it.
const LogString *warning{nullptr};
float rssi{0};
float snr{0};
bool report{false};
// A send ended, and result is its outcome.
bool finished{false};
// The packet buffer holds a packet to deliver.
bool received{false};
// Nothing to poll until the next DIO1 edge or configuration.
bool sleep_loop{false};
};
// Owns the radio state and every SPI command sequence.
//
// Status reports, completions and packet listeners can run user code, which may call back
// into the driver. Every operation therefore does its SPI work with busy() set, commits the
// next state, and returns RadioEffects; SX126x::apply_() then reports status and calls the
// listeners. This class has no access to component status or listeners, so callbacks only
// ever see a committed state. Do not log here either: log listeners are user code. busy()
// covers re-entry during a sequence, for example from a GPIO pin that logs.
//
// Each sequence starts with bus().begin(); after a BUSY timeout the rest is skipped and
// bus().ok() is false. A failed send preparation restores the radio in a new sequence. A
// failed restoration needs configuration, and its result overrides the send result. A
// successful send start reports nothing, so no user code runs before the caller has the
// result. Every send ends in finish_transmit_(), exactly once.
//
// A failed receive read keeps the packet and retries after RECEIVE_RETRY_INTERVAL_MS, so a
// stuck BUSY line does not cost a 20 ms wait on every loop.
class SX126xRadio {
public:
SX126xRadio() = default;
SX126xRadio(const SX126xRadio &) = delete;
SX126xRadio &operator=(const SX126xRadio &) = delete;
SX126xSpiDevice &bus() { return this->commands_.bus(); }
void set_dio1_pin(GPIOPin *pin) { this->dio1_pin_ = pin; }
void set_rst_pin(GPIOPin *pin) { this->rst_pin_ = pin; }
GPIOPin *get_dio1_pin() const { return this->dio1_pin_; }
GPIOPin *get_rst_pin() const { return this->rst_pin_; }
RadioState state() const { return this->state_; }
bool busy() const { return this->busy_; }
bool is_transmitting() const { return this->state_ == RadioState::RADIO_STATE_TRANSMITTING; }
// A held packet may be discarded: explicit reconfiguration is the recovery path.
bool can_configure() const { return !this->busy_ && !this->is_transmitting(); }
bool can_change_mode() const { return !this->busy_ && this->state_ == RadioState::RADIO_STATE_IDLE; }
size_t max_packet_size() const { return this->applied_.max_packet_size(); }
// True while a packet is being received, or has been received and not yet read, so a send would lose it.
// Reads the chip only when the radio is idle and listening; any other state reports false, a failed read true.
bool is_receiving();
// Requires can_configure(). Resets the chip and applies the requested profile.
RadioEffects configure(const RadioProfile &requested, std::span<char, 16> version);
// Requires can_change_mode(). Cold sleep and failed commands need configuration afterwards.
RadioEffects change_mode(ModeCommand command, uint8_t arg);
// Result SX126X_ERROR_NONE starts a send that finishes exactly once, through poll_transmit() or
// cancel_transmit(). Any other result owes no completion.
RadioEffects start_transmit(SX126xTransmitListener *listener, const uint8_t *data, size_t len, uint32_t timeout_ms);
// Sets finished only when it ended the current send.
RadioEffects poll_transmit(uint32_t now);
// Sets finished only if listener owns the current send.
RadioEffects cancel_transmit(SX126xTransmitListener *listener);
// One loop step: polls a send, or reads a received packet into packet.
RadioEffects poll(uint32_t now, std::vector<uint8_t> &packet);
private:
struct TxOperation {
SX126xTransmitListener *listener{nullptr};
uint32_t started_ms{0};
uint32_t timeout_ms{0};
};
void commit_(RadioState state) {
this->state_ = state;
this->busy_ = false;
}
static RadioEffects comm_report(bool ok);
const LogString *apply_configuration_(const RadioProfile &requested, std::span<char, 16> version);
bool restore_();
RadioEffects finish_transmit_(SX126xError result);
RadioEffects receive_(bool holding, uint32_t now, std::vector<uint8_t> &packet);
SX126xCommands commands_;
AppliedProfile applied_;
TxOperation tx_;
uint32_t rx_retry_started_ms_{0};
uint16_t pending_irq_{0}; // flags of a received packet whose read failed after they were cleared
GPIOPin *dio1_pin_{nullptr};
GPIOPin *rst_pin_{nullptr};
RadioState state_{RadioState::RADIO_STATE_NEEDS_CONFIGURATION};
bool busy_{false};
bool rx_retry_pending_{false};
};
} // namespace esphome::sx126x
@@ -0,0 +1,45 @@
#include "sx126x_spi_device.h"
#include "esphome/core/hal.h"
namespace esphome::sx126x {
static constexpr uint32_t BUSY_TIMEOUT_MS = 20;
static constexpr uint32_t SWITCHING_DELAY_US = 1;
void SX126xSpiDevice::exchange_(std::span<const uint8_t> header, std::span<const uint8_t> tx, std::span<uint8_t> rx) {
if (!this->ok_) {
return;
}
// Selecting first wakes a sleeping radio. The guard releases CS even on timeout.
Selection selected(this->device_);
const uint32_t start = millis();
while (this->busy_pin_->digital_read()) {
if (millis() - start > BUSY_TIMEOUT_MS) {
this->ok_ = false;
return;
}
}
for (auto byte : header) {
this->device_.transfer_byte(byte);
}
for (auto byte : tx) {
this->device_.transfer_byte(byte);
}
for (auto &byte : rx) {
byte = this->device_.transfer_byte(0);
}
}
void SX126xSpiDevice::write(std::span<const uint8_t> header, std::span<const uint8_t> data) {
this->exchange_(header, data, {});
if (this->ok_) {
// This delay belongs after CS is released, not in the selected interval.
delayMicroseconds(SWITCHING_DELAY_US);
}
}
void SX126xSpiDevice::read(std::span<const uint8_t> header, std::span<uint8_t> data) {
this->exchange_(header, {}, data);
}
} // namespace esphome::sx126x
@@ -0,0 +1,63 @@
#pragma once
#include "esphome/components/spi/spi.h"
#include <span>
namespace esphome::sx126x {
// Persistent radio device. read()/write() use exchange_() for one complete selected interval.
// No raw SPI access escapes. Call only from the main loop; spans are borrowed until return.
// Failures stick: after a BUSY timeout every exchange is skipped until the next begin(),
// so a command sequence checks ok() once instead of after every command.
class SX126xSpiDevice {
public:
SX126xSpiDevice() = default;
SX126xSpiDevice(const SX126xSpiDevice &) = delete;
SX126xSpiDevice &operator=(const SX126xSpiDevice &) = delete;
void set_spi_parent(spi::SPIComponent *parent) { this->device_.set_spi_parent(parent); }
void set_cs_pin(GPIOPin *pin) { this->device_.set_cs_pin(pin); }
void set_data_rate(uint32_t rate) { this->device_.set_data_rate(rate); }
void set_mode(spi::SPIMode mode) { this->device_.set_mode(mode); }
void set_bit_order(spi::SPIBitOrder order) { this->device_.set_bit_order(order); }
void set_release_device(bool release) { this->device_.set_release_device(release); }
void set_write_only(bool write_only) { this->device_.set_write_only(write_only); }
#ifdef USE_SPI_PSRAM_DMA
void set_psram_dma(bool enable) { this->device_.set_psram_dma(enable); }
#endif
void set_busy_pin(GPIOPin *pin) { this->busy_pin_ = pin; }
GPIOPin *get_busy_pin() const { return this->busy_pin_; }
GPIOPin *get_cs_pin() const { return this->device_.get_cs_pin(); }
void setup() { this->device_.spi_setup(); }
void teardown() { this->device_.spi_teardown(); }
// Starts a command sequence with no recorded failure.
void begin() { this->ok_ = true; }
// False once any exchange since begin() timed out waiting for BUSY.
bool ok() const { return this->ok_; }
void write(std::span<const uint8_t> header, std::span<const uint8_t> data);
// Leaves data unchanged when the exchange is skipped or times out.
void read(std::span<const uint8_t> header, std::span<uint8_t> data);
private:
class Device final : public spi::SPIDevice<spi::BIT_ORDER_MSB_FIRST, spi::CLOCK_POLARITY_LOW,
spi::CLOCK_PHASE_LEADING, spi::DATA_RATE_8MHZ> {
public:
GPIOPin *get_cs_pin() const { return this->cs_; }
};
class Selection {
public:
explicit Selection(Device &device) : device_(device) { this->device_.enable(); }
~Selection() { this->device_.disable(); }
Selection(const Selection &) = delete;
Selection &operator=(const Selection &) = delete;
private:
Device &device_;
};
void exchange_(std::span<const uint8_t> header, std::span<const uint8_t> tx, std::span<uint8_t> rx);
Device device_;
GPIOPin *busy_pin_{nullptr};
bool ok_{true};
};
} // namespace esphome::sx126x
@@ -0,0 +1,72 @@
from esphome.components import packet_interface
from esphome.components.packet_interface import CONF_MAX_PACKET_SIZE
from esphome.components.packet_interface.radio_link import (
MAX_PACKET_SIZE,
new_radio_link,
radio_link_final_validate,
radio_link_schema,
)
import esphome.config_validation as cv
from esphome.types import ConfigType
from .. import (
CONF_MODULATION,
CONF_PACKET_MODE,
CONF_PAYLOAD_LENGTH,
CONF_RX_START,
CONF_SX127X_ID,
CONF_SYNC_VALUE,
SX127x,
SX127xListener,
sx127x_ns,
)
CODEOWNERS = ["@clydebarrow"]
DEPENDENCIES = ["sx127x"]
# Outside LoRa mode the 64 byte FIFO also holds the length byte
FSK_MAX_PACKET_SIZE = 63
SX127xPacketInterface = sx127x_ns.class_(
"SX127xPacketInterface", packet_interface.PacketInterface, SX127xListener
)
CONFIG_SCHEMA = radio_link_schema(SX127xPacketInterface, CONF_SX127X_ID, SX127x)
def _check_fsk(config: ConfigType, radio: ConfigType) -> None:
"""Without LoRa, the radio must send packets, not a continuous bit stream, and holds fewer bytes.
It can tell that a packet is arriving only from its sync word, which listen before talk needs.
"""
if radio[CONF_MODULATION] == "LORA":
return
if not radio.get(CONF_PACKET_MODE, False):
raise cv.Invalid(
f"Without LoRa modulation the radio's '{CONF_PACKET_MODE}' must be true, as a link sends packets",
path=[CONF_SX127X_ID],
)
if not radio.get(CONF_SYNC_VALUE):
raise cv.Invalid(
f"Without LoRa modulation the radio needs a '{CONF_SYNC_VALUE}', so that the link can tell when a "
"packet is arriving and not send over it",
path=[CONF_SX127X_ID],
)
if config[CONF_MAX_PACKET_SIZE] > FSK_MAX_PACKET_SIZE:
raise cv.Invalid(
f"Without LoRa modulation the radio sends at most {FSK_MAX_PACKET_SIZE} bytes",
path=[CONF_MAX_PACKET_SIZE],
)
def _receive_limit(radio: ConfigType) -> int:
return MAX_PACKET_SIZE if radio[CONF_MODULATION] == "LORA" else FSK_MAX_PACKET_SIZE
FINAL_VALIDATE_SCHEMA = radio_link_final_validate(
CONF_SX127X_ID, CONF_PAYLOAD_LENGTH, CONF_RX_START, _check_fsk, _receive_limit
)
async def to_code(config: ConfigType) -> None:
await new_radio_link(config, CONF_SX127X_ID, _receive_limit)
@@ -0,0 +1,10 @@
#pragma once
#include "esphome/components/packet_interface/radio_link.h"
#include "esphome/components/sx127x/sx127x.h"
namespace esphome::sx127x {
using SX127xPacketInterface = packet_interface::RadioLink<SX127x, SX127xListener, SX127xError, SX127X_MAX_PACKET_SIZE>;
} // namespace esphome::sx127x
+356 -113
View File
@@ -1,12 +1,27 @@
#include "sx127x.h"
#include "esphome/core/application.h"
#include "esphome/core/hal.h"
#include "esphome/core/helpers.h"
#include "esphome/core/log.h"
#include "esphome/core/progmem.h"
#include <cmath>
#include <utility>
namespace esphome::sx127x {
ESPHOME_LOG_TAG(TAG, "sx127x");
static const uint32_t FXOSC = 32000000u;
static constexpr uint32_t TRANSMIT_TIMEOUT_MS = 4000;
static constexpr uint32_t MAX_TRANSMIT_TIMEOUT_MS = 262143; // the same range as SX126x
static constexpr uint32_t MODE_TIMEOUT_MS = 20;
static constexpr uint32_t RECONFIGURE_INTERVAL_ID = 0;
static constexpr uint32_t RECONFIGURE_INTERVAL_MS = 1000;
// Indexed by SX127xError
PROGMEM_STRING_TABLE(SX127xErrorStrings, "none", "timeout", "invalid parameters", "radio not ready", "radio busy",
"cancelled");
static const LogString *set_mode_failure() { return LOG_STR("Set mode failure"); }
static constexpr uint16_t RAMP[16] PROGMEM = {3400, 2000, 1000, 500, 250, 125, 100, 62, 50, 40, 31, 25, 20, 15, 12, 10};
// Aligned 32 bit loads from flash are safe on ESP8266, so this table is read directly
static constexpr uint32_t BW_HZ[22] PROGMEM = {2604, 3125, 3906, 5208, 6250, 7812, 10416, 12500,
@@ -47,35 +62,86 @@ void SX127x::read_fifo_(std::vector<uint8_t> &packet) {
this->disable();
}
void SX127x::write_fifo_(const uint8_t *data, size_t len) {
// Burst write: the radio moves to the next register after each byte, except for REG_FIFO
void SX127x::write_registers_(uint8_t reg, const uint8_t *data, size_t len) {
this->enable();
this->write_byte(REG_FIFO | 0x80);
for (size_t i = 0; i < len; i++) {
this->transfer_byte(data[i]);
}
this->write_byte(reg | 0x80);
this->write_array(data, len);
this->disable();
}
void IRAM_ATTR SX127x::gpio_intr(SX127x *arg) { arg->enable_loop_soon_any_context(); }
void SX127x::write_register16_(uint8_t msb_reg, uint16_t value) {
uint8_t bytes[2];
put_be16(bytes, value);
this->write_registers_(msb_reg, bytes, sizeof(bytes));
}
void SX127x::setup() {
// setup reset
this->rst_pin_->setup();
// setup dio0
if (this->dio0_pin_) {
if (this->dio0_pin_ != nullptr) {
this->dio0_pin_->setup();
this->dio0_pin_->attach_interrupt(&SX127x::gpio_intr, this, gpio::INTERRUPT_RISING_EDGE);
if (this->dio0_pin_->is_internal()) {
static_cast<InternalGPIOPin *>(this->dio0_pin_)
->attach_interrupt(&SX127x::gpio_intr, this, gpio::INTERRUPT_RISING_EDGE);
}
}
// start spi
this->spi_setup();
// configure rf
this->configure();
const LogString *reason = this->configure_radio_();
if (reason != nullptr) {
this->mark_failed(reason);
return;
}
this->state_ = RadioState::RADIO_STATE_IDLE;
// Sized once so later packet reads do not reallocate
this->packet_.reserve(this->get_max_packet_size());
}
void SX127x::configure() {
// Nothing to configure before setup() or after a failed setup
if (!this->is_ready()) {
return;
}
if (this->is_transmitting()) {
ESP_LOGW(TAG, "Radio operation in progress, configuration ignored");
return;
}
const LogString *reason = this->configure_radio_();
if (reason != nullptr) {
this->fail_(reason);
return;
}
this->state_ = RadioState::RADIO_STATE_IDLE;
if (this->reconfigure_pending_) {
this->reconfigure_pending_ = false;
this->cancel_interval(RECONFIGURE_INTERVAL_ID);
}
this->status_clear_warning();
this->enable_loop();
}
void SX127x::fail_(const LogString *reason) {
this->state_ = RadioState::RADIO_STATE_NEEDS_CONFIGURATION;
// Nothing else configures the radio again
if (!this->reconfigure_pending_) {
this->reconfigure_pending_ = true;
this->set_interval(RECONFIGURE_INTERVAL_ID, RECONFIGURE_INTERVAL_MS, [this]() { this->configure(); });
}
// Last: a log listener may call configure(), which cancels the retry
this->status_set_warning(reason);
}
const LogString *SX127x::configure_radio_() {
// Until this succeeds; a held packet is discarded
this->state_ = RadioState::RADIO_STATE_NEEDS_CONFIGURATION;
this->applied_ = {this->frequency_, this->payload_length_, this->modulation_, this->packet_mode_, this->rx_start_};
// toggle chip reset
this->rst_pin_->digital_write(false);
delayMicroseconds(1000);
@@ -84,35 +150,42 @@ void SX127x::configure() {
// check silicon version to make sure hw is ok
if (this->read_register_(REG_VERSION) != 0x12) {
this->mark_failed(LOG_STR("Unsupported chip version"));
return;
return LOG_STR("Unsupported chip version");
}
// enter sleep mode
this->set_mode_(MOD_FSK, MODE_SLEEP);
if (!this->set_mode_(MOD_FSK, MODE_SLEEP)) {
return set_mode_failure();
}
// set freq
uint64_t frf = ((uint64_t) this->frequency_ << 19) / FXOSC;
this->write_register_(REG_FRF_MSB, (uint8_t) ((frf >> 16) & 0xFF));
this->write_register_(REG_FRF_MID, (uint8_t) ((frf >> 8) & 0xFF));
this->write_register_(REG_FRF_LSB, (uint8_t) ((frf >> 0) & 0xFF));
uint8_t frf_bytes[3];
put_be24(frf_bytes, static_cast<uint32_t>(frf));
this->write_registers_(REG_FRF_MSB, frf_bytes, sizeof(frf_bytes));
// enter standby mode
this->set_mode_(MOD_FSK, MODE_STDBY);
if (!this->set_mode_(MOD_FSK, MODE_STDBY)) {
return set_mode_failure();
}
// run image cal
this->run_image_cal();
const LogString *reason = this->image_cal_();
if (reason != nullptr) {
return reason;
}
// go back to sleep
this->set_mode_sleep();
if (!this->set_mode_(this->modulation_, MODE_SLEEP)) {
return set_mode_failure();
}
// config pa
if (this->pa_pin_ == PA_PIN_BOOST) {
this->pa_power_ = std::max(this->pa_power_, (uint8_t) 2);
this->pa_power_ = std::min(this->pa_power_, (uint8_t) 17);
this->pa_power_ = clamp(this->pa_power_, (uint8_t) 2, (uint8_t) 17);
this->write_register_(REG_PA_CONFIG, (this->pa_power_ - 2) | this->pa_pin_ | PA_MAX_POWER);
} else {
this->pa_power_ = std::min(this->pa_power_, (uint8_t) 14);
this->pa_power_ = clamp_at_most(this->pa_power_, (uint8_t) 14);
this->write_register_(REG_PA_CONFIG, (this->pa_power_ - 0) | this->pa_pin_ | PA_MAX_POWER);
}
if (this->modulation_ != MOD_LORA) {
@@ -129,11 +202,10 @@ void SX127x::configure() {
}
// switch to rx or sleep
if (this->rx_start_) {
this->set_mode_rx();
} else {
this->set_mode_sleep();
if (!this->restore_()) {
return set_mode_failure();
}
return nullptr;
}
void SX127x::configure_fsk_ook_() {
@@ -141,14 +213,12 @@ void SX127x::configure_fsk_ook_() {
this->write_register_(REG_RX_BW, progmem_read_byte(&BW_FSK_OOK[this->bandwidth_]));
// set fdev
uint32_t fdev = std::min((this->deviation_ * 4096) / 250000, (uint32_t) 0x3FFF);
this->write_register_(REG_FDEV_MSB, (uint8_t) ((fdev >> 8) & 0xFF));
this->write_register_(REG_FDEV_LSB, (uint8_t) ((fdev >> 0) & 0xFF));
uint16_t fdev = clamp_at_most((this->deviation_ * 4096) / 250000, uint32_t{0x3FFF});
this->write_register16_(REG_FDEV_MSB, fdev);
// set bitrate
uint64_t bitrate = (FXOSC + this->bitrate_ / 2) / this->bitrate_; // round up
this->write_register_(REG_BITRATE_MSB, (uint8_t) ((bitrate >> 8) & 0xFF));
this->write_register_(REG_BITRATE_LSB, (uint8_t) ((bitrate >> 0) & 0xFF));
uint16_t bitrate = (FXOSC + this->bitrate_ / 2) / this->bitrate_; // round up
this->write_register16_(REG_BITRATE_MSB, bitrate);
// configure rx and afc
this->write_register_(REG_AFC_BW, progmem_read_byte(&BW_FSK_OOK[this->afc_bandwidth_]));
@@ -168,7 +238,7 @@ void SX127x::configure_fsk_ook_() {
this->write_register_(REG_PAYLOAD_LENGTH_LSB, this->payload_length_);
this->write_register_(REG_PACKET_CONFIG_1, crc_mode | FIXED_LENGTH);
} else {
this->write_register_(REG_PAYLOAD_LENGTH_LSB, this->get_max_packet_size() - 1);
this->write_register_(REG_PAYLOAD_LENGTH_LSB, this->get_max_packet_size());
this->write_register_(REG_PACKET_CONFIG_1, crc_mode | VARIABLE_LENGTH);
}
this->write_register_(REG_PACKET_CONFIG_2, PACKET_MODE);
@@ -197,8 +267,7 @@ void SX127x::configure_fsk_ook_() {
} else {
this->write_register_(REG_PREAMBLE_DETECT, PREAMBLE_DETECTOR_OFF);
}
this->write_register_(REG_PREAMBLE_SIZE_MSB, this->preamble_size_ >> 8);
this->write_register_(REG_PREAMBLE_SIZE_LSB, this->preamble_size_ & 0xFF);
this->write_register16_(REG_PREAMBLE_SIZE_MSB, this->preamble_size_);
// config sync generation and setup ook threshold
uint8_t bitsync = this->bitsync_ ? BIT_SYNC_ON : BIT_SYNC_OFF;
@@ -226,8 +295,7 @@ void SX127x::configure_lora_() {
// config preamble
if (this->preamble_size_ >= 6) {
this->write_register_(REG_PREAMBLE_LEN_MSB, this->preamble_size_ >> 8);
this->write_register_(REG_PREAMBLE_LEN_LSB, this->preamble_size_ & 0xFF);
this->write_register16_(REG_PREAMBLE_LEN_MSB, this->preamble_size_);
}
// optimize detection
@@ -252,70 +320,167 @@ void SX127x::configure_lora_() {
}
size_t SX127x::get_max_packet_size() {
if (this->payload_length_ > 0) {
return this->payload_length_;
if (this->applied_.payload_length > 0) {
return this->applied_.payload_length;
}
if (this->modulation_ == MOD_LORA) {
if (this->applied_.modulation == MOD_LORA) {
return SX127X_MAX_PACKET_SIZE;
}
return 64;
// The 64 byte FIFO also holds the length byte
return 63;
}
SX127xError SX127x::transmit_packet(const uint8_t *data, size_t len) {
SX127xError result = this->start_transmit_(nullptr, data, len, TRANSMIT_TIMEOUT_MS);
if (result == SX127xError::SX127X_ERROR_NONE) {
// Without a listener this send cannot be cancelled or replaced
result = SX127xError::SX127X_ERROR_NOT_READY;
while (this->is_transmitting() && !this->poll_transmit_(millis(), result)) {
App.feed_wdt();
}
}
if (result != SX127xError::SX127X_ERROR_NONE) {
ESP_LOGW(
TAG, "Packet send failed: %s",
LOG_STR_ARG(SX127xErrorStrings::get_log_str(static_cast<uint8_t>(result), SX127xErrorStrings::LAST_INDEX)));
}
return result;
}
SX127xError SX127x::start_transmit_async(SX127xTransmitListener *listener, const uint8_t *data, size_t len,
uint32_t timeout_ms) {
if (listener == nullptr || timeout_ms == 0 || timeout_ms > MAX_TRANSMIT_TIMEOUT_MS) {
return SX127xError::SX127X_ERROR_INVALID_PARAMS;
}
return this->start_transmit_(listener, data, len, timeout_ms);
}
SX127xError SX127x::start_transmit_(SX127xTransmitListener *listener, const uint8_t *data, size_t len,
uint32_t timeout_ms) {
// Callers such as a template number's on_value can run before setup() or after a failed setup
if (!this->is_ready()) {
ESP_LOGW(TAG, "Radio not ready, packet dropped");
if (!this->is_ready() || this->state_ == RadioState::RADIO_STATE_NEEDS_CONFIGURATION) {
return SX127xError::SX127X_ERROR_NOT_READY;
}
if (this->payload_length_ > 0 && this->payload_length_ != len) {
ESP_LOGE(TAG, "Packet size does not match config");
return SX127xError::INVALID_PARAMS;
if (this->state_ != RadioState::RADIO_STATE_IDLE) {
return SX127xError::SX127X_ERROR_BUSY;
}
if (len == 0 || len > this->get_max_packet_size()) {
ESP_LOGE(TAG, "Packet size out of range");
return SX127xError::INVALID_PARAMS;
if (data == nullptr || len == 0 || len > this->get_max_packet_size() ||
(this->applied_.payload_length > 0 && this->applied_.payload_length != len)) {
return SX127xError::SX127X_ERROR_INVALID_PARAMS;
}
if (this->dio0_pin_ == nullptr) {
ESP_LOGE(TAG, "DIO0 pin not configured, cannot wait for transmit completion");
return SX127xError::INVALID_PARAMS;
return SX127xError::SX127X_ERROR_INVALID_PARAMS;
}
SX127xError ret = SX127xError::NONE;
if (this->modulation_ == MOD_LORA) {
this->set_mode_standby();
if (this->payload_length_ == 0) {
if (!this->set_mode_(this->applied_.modulation, MODE_STDBY)) {
this->fail_(set_mode_failure());
return SX127xError::SX127X_ERROR_NOT_READY;
}
// A packet received before standby stays in the FIFO for loop()
if (this->packet_waiting_()) {
this->state_ = RadioState::RADIO_STATE_HOLDING_RX;
this->enable_loop();
return SX127xError::SX127X_ERROR_BUSY;
}
if (this->applied_.modulation == MOD_LORA) {
if (this->applied_.payload_length == 0) {
this->write_register_(REG_PAYLOAD_LENGTH, len);
}
this->write_register_(REG_IRQ_FLAGS, 0xFF);
this->write_register_(REG_FIFO_ADDR_PTR, 0);
this->write_fifo_(data, len);
this->set_mode_tx();
} else {
this->set_mode_standby();
if (this->payload_length_ == 0) {
this->write_register_(REG_FIFO, len);
}
this->write_fifo_(data, len);
this->set_mode_tx();
} else if (this->applied_.payload_length == 0) {
this->write_register_(REG_FIFO, len);
}
this->write_registers_(REG_FIFO, data, len);
if (!this->enter_tx_()) {
this->fail_(set_mode_failure());
return SX127xError::SX127X_ERROR_NOT_READY;
}
this->tx_ = {listener, millis(), timeout_ms};
this->state_ = RadioState::RADIO_STATE_TRANSMITTING;
this->enable_loop();
return SX127xError::SX127X_ERROR_NONE;
}
// wait until transmit completes, typically the delay will be less than 100 ms
uint32_t start = millis();
while (!this->dio0_pin_->digital_read()) {
App.feed_wdt();
if (millis() - start > 4000) {
ESP_LOGE(TAG, "Transmit packet failure");
ret = SX127xError::TIMEOUT;
break;
}
bool SX127x::poll_transmit_(uint32_t now, SX127xError &result) {
if (!this->is_transmitting()) {
return false;
}
if (this->rx_start_) {
this->set_mode_rx();
// DIO0 is TX_DONE in LoRa, and PacketSent in FSK and OOK while transmitting
if (this->dio0_pin_->digital_read()) {
result = SX127xError::SX127X_ERROR_NONE;
} else if (static_cast<int32_t>(now - this->tx_.started_ms) >= static_cast<int32_t>(this->tx_.timeout_ms)) {
// Signed, as the cached loop time can precede the start
result = SX127xError::SX127X_ERROR_TIMEOUT;
} else {
this->set_mode_sleep();
return false;
}
return ret;
result = this->finish_transmit_(result);
return true;
}
bool SX127x::cancel_transmit_async(SX127xTransmitListener *listener) {
if (!this->is_transmitting() || listener == nullptr || listener != this->tx_.listener) {
return false;
}
this->finish_transmit_(SX127xError::SX127X_ERROR_CANCELLED);
return true;
}
// The only place a send ends; state is committed before the listener runs
SX127xError SX127x::finish_transmit_(SX127xError result) {
SX127xTransmitListener *listener = std::exchange(this->tx_.listener, nullptr);
if (this->restore_()) {
this->state_ = RadioState::RADIO_STATE_IDLE;
} else {
this->fail_(set_mode_failure());
}
if (listener != nullptr) {
listener->on_transmit_complete(result);
}
return result;
}
bool SX127x::restore_() {
// Via standby: the chip ignores RX while a packet is still going out
if (!this->set_mode_(this->applied_.modulation, MODE_STDBY)) {
return false;
}
if (this->applied_.modulation == MOD_LORA) {
this->write_register_(REG_IRQ_FLAGS, 0xFF);
}
return this->applied_.rx_start ? this->enter_rx_() : this->set_mode_(this->applied_.modulation, MODE_SLEEP);
}
bool SX127x::is_receiving() {
if (this->state_ == RadioState::RADIO_STATE_HOLDING_RX) {
return true;
}
// A radio that sleeps after sending is not listening
if (this->state_ != RadioState::RADIO_STATE_IDLE || !this->applied_.rx_start || this->dio0_pin_ == nullptr) {
return false;
}
const bool lora = this->applied_.modulation == MOD_LORA;
// In receive mode DIO0 signals a received packet that loop() has not read yet. In LoRa it also signals TX_DONE
// after the TX mode action.
if (this->dio0_pin_->digital_read() && (!lora || (this->read_register_(REG_IRQ_FLAGS) & RX_DONE) != 0)) {
return true;
}
if (!lora) {
// Set from the sync word until the packet has been read; the preamble flag stays set when no sync word follows
return (this->read_register_(REG_IRQ_FLAGS_1) & IRQ_FLAGS_1_SYNC_ADDRESS_MATCH) != 0;
}
return (this->read_register_(REG_MODEM_STAT) &
(MODEM_STAT_SIGNAL_DETECTED | MODEM_STAT_SIGNAL_SYNCHRONIZED | MODEM_STAT_HEADER_VALID)) != 0;
}
bool SX127x::packet_waiting_() {
if (this->applied_.modulation == MOD_LORA) {
const uint8_t flags = this->read_register_(REG_IRQ_FLAGS);
return (flags & RX_DONE) != 0 && (flags & PAYLOAD_CRC_ERROR) == 0;
}
return this->applied_.packet_mode && (this->read_register_(REG_IRQ_FLAGS2) & PAYLOAD_READY) != 0;
}
void SX127x::call_listeners_(const std::vector<uint8_t> &packet, float rssi, float snr) {
@@ -326,43 +491,81 @@ void SX127x::call_listeners_(const std::vector<uint8_t> &packet, float rssi, flo
}
void SX127x::loop() {
this->disable_loop();
if (this->dio0_pin_ == nullptr || !this->dio0_pin_->digital_read()) {
return;
switch (this->state_) {
case RadioState::RADIO_STATE_TRANSMITTING: {
SX127xError result;
this->poll_transmit_(App.get_loop_component_start_time(), result);
return;
}
case RadioState::RADIO_STATE_HOLDING_RX:
this->receive_();
return;
case RadioState::RADIO_STATE_IDLE:
if (this->dio0_pin_ == nullptr) {
this->disable_loop();
return;
}
// DIO0's interrupt wakes the loop
if (this->dio0_pin_->is_internal()) {
this->disable_loop();
}
if (this->dio0_pin_->digital_read()) {
this->receive_();
}
return;
default:
// configure() wakes the loop
this->disable_loop();
return;
}
}
if (this->modulation_ == MOD_LORA) {
void SX127x::receive_() {
const bool holding = this->state_ == RadioState::RADIO_STATE_HOLDING_RX;
bool received = false;
float rssi = 0.0f;
float snr = NAN; // FSK and OOK have no SNR
if (this->applied_.modulation == MOD_LORA) {
uint8_t status = this->read_register_(REG_IRQ_FLAGS);
this->write_register_(REG_IRQ_FLAGS, 0xFF);
if ((status & PAYLOAD_CRC_ERROR) == 0) {
if ((status & RX_DONE) != 0 && (status & PAYLOAD_CRC_ERROR) == 0) {
uint8_t bytes = this->read_register_(REG_NB_RX_BYTES);
uint8_t addr = this->read_register_(REG_FIFO_RX_CURR_ADDR);
uint8_t rssi = this->read_register_(REG_PKT_RSSI_VALUE);
int8_t snr = (int8_t) this->read_register_(REG_PKT_SNR_VALUE);
uint8_t raw_rssi = this->read_register_(REG_PKT_RSSI_VALUE);
int8_t raw_snr = (int8_t) this->read_register_(REG_PKT_SNR_VALUE);
this->packet_.resize(bytes);
this->write_register_(REG_FIFO_ADDR_PTR, addr);
this->read_fifo_(this->packet_);
if (this->frequency_ > 700000000) {
this->call_listeners_(this->packet_, (float) rssi - RSSI_OFFSET_HF, (float) snr / 4);
} else {
this->call_listeners_(this->packet_, (float) rssi - RSSI_OFFSET_LF, (float) snr / 4);
}
rssi = (float) raw_rssi - (this->applied_.frequency > 700000000 ? RSSI_OFFSET_HF : RSSI_OFFSET_LF);
snr = (float) raw_snr / 4;
received = true;
}
} else if (this->packet_mode_) {
uint8_t payload_length = this->payload_length_;
} else if (this->applied_.packet_mode && (this->read_register_(REG_IRQ_FLAGS2) & PAYLOAD_READY) != 0) {
uint8_t payload_length = this->applied_.payload_length;
if (payload_length == 0) {
payload_length = this->read_register_(REG_FIFO);
}
this->packet_.resize(payload_length);
this->read_fifo_(this->packet_);
this->call_listeners_(this->packet_, 0.0f, 0.0f);
received = true;
}
if (holding) {
if (this->restore_()) {
this->state_ = RadioState::RADIO_STATE_IDLE;
} else {
this->fail_(set_mode_failure());
}
}
if (received) {
this->call_listeners_(this->packet_, rssi, snr);
}
}
void SX127x::run_image_cal() {
if (this->modulation_ == MOD_LORA) {
this->set_mode_(MOD_FSK, MODE_SLEEP);
this->set_mode_(MOD_FSK, MODE_STDBY);
const LogString *SX127x::image_cal_() {
if (this->applied_.modulation == MOD_LORA) {
if (!this->set_mode_(MOD_FSK, MODE_SLEEP) || !this->set_mode_(MOD_FSK, MODE_STDBY)) {
return set_mode_failure();
}
}
if (this->auto_cal_) {
this->write_register_(REG_IMAGE_CAL, IMAGE_CAL_START | AUTO_IMAGE_CAL_ON | TEMP_THRESHOLD_10C);
@@ -372,17 +575,29 @@ void SX127x::run_image_cal() {
uint32_t start = millis();
while (this->read_register_(REG_IMAGE_CAL) & IMAGE_CAL_RUNNING) {
if (millis() - start > 20) {
this->mark_failed(LOG_STR("Image cal failure"));
break;
return LOG_STR("Image cal failure");
}
}
if (this->modulation_ == MOD_LORA) {
this->set_mode_(this->modulation_, MODE_SLEEP);
this->set_mode_(this->modulation_, MODE_STDBY);
if (this->applied_.modulation == MOD_LORA) {
if (!this->set_mode_(this->applied_.modulation, MODE_SLEEP) ||
!this->set_mode_(this->applied_.modulation, MODE_STDBY)) {
return set_mode_failure();
}
}
return nullptr;
}
void SX127x::run_image_cal() {
if (!this->can_change_mode_()) {
return;
}
const LogString *reason = this->image_cal_();
if (reason != nullptr) {
this->fail_(reason);
}
}
void SX127x::set_mode_(uint8_t modulation, uint8_t mode) {
bool SX127x::set_mode_(uint8_t modulation, uint8_t mode) {
uint32_t start = millis();
this->write_register_(REG_OP_MODE, modulation | mode);
while (true) {
@@ -391,34 +606,62 @@ void SX127x::set_mode_(uint8_t modulation, uint8_t mode) {
if (mode == MODE_SLEEP) {
this->write_register_(REG_OP_MODE, modulation | mode);
}
break;
return true;
}
if (millis() - start > 20) {
this->mark_failed(LOG_STR("Set mode failure"));
return;
if (millis() - start > MODE_TIMEOUT_MS) {
return false;
}
}
}
void SX127x::set_mode_rx() {
this->set_mode_(this->modulation_, MODE_RX);
if (this->modulation_ == MOD_LORA) {
bool SX127x::enter_rx_() {
if (this->applied_.modulation == MOD_LORA) {
this->write_register_(REG_IRQ_FLAGS_MASK, 0x00);
this->write_register_(REG_DIO_MAPPING1, DIO0_MAPPING_00);
}
return this->set_mode_(this->applied_.modulation, MODE_RX);
}
void SX127x::set_mode_tx() {
this->set_mode_(this->modulation_, MODE_TX);
if (this->modulation_ == MOD_LORA) {
bool SX127x::enter_tx_() {
if (this->applied_.modulation == MOD_LORA) {
this->write_register_(REG_IRQ_FLAGS_MASK, 0x00);
this->write_register_(REG_DIO_MAPPING1, DIO0_MAPPING_01);
}
return this->set_mode_(this->applied_.modulation, MODE_TX);
}
void SX127x::set_mode_standby() { this->set_mode_(this->modulation_, MODE_STDBY); }
bool SX127x::can_change_mode_() {
if (this->state_ == RadioState::RADIO_STATE_IDLE) {
return true;
}
ESP_LOGW(TAG, "Radio unavailable, mode change ignored");
return false;
}
void SX127x::set_mode_sleep() { this->set_mode_(this->modulation_, MODE_SLEEP); }
void SX127x::change_mode_(uint8_t mode) {
if (!this->can_change_mode_()) {
return;
}
bool ok;
if (mode == MODE_RX) {
ok = this->enter_rx_();
} else if (mode == MODE_TX) {
ok = this->enter_tx_();
} else {
ok = this->set_mode_(this->applied_.modulation, mode);
}
if (!ok) {
this->fail_(set_mode_failure());
}
}
void SX127x::set_mode_rx() { this->change_mode_(MODE_RX); }
void SX127x::set_mode_tx() { this->change_mode_(MODE_TX); }
void SX127x::set_mode_standby() { this->change_mode_(MODE_STDBY); }
void SX127x::set_mode_sleep() { this->change_mode_(MODE_SLEEP); }
void SX127x::dump_config() {
ESP_LOGCONFIG(TAG, "SX127x:");
+83 -8
View File
@@ -36,10 +36,35 @@ enum SX127xBw : uint8_t {
SX127X_BW_500_0,
};
enum class SX127xError { NONE = 0, TIMEOUT, INVALID_PARAMS, SX127X_ERROR_NOT_READY };
enum class SX127xError {
SX127X_ERROR_NONE = 0,
SX127X_ERROR_TIMEOUT,
SX127X_ERROR_INVALID_PARAMS,
SX127X_ERROR_NOT_READY,
SX127X_ERROR_BUSY,
SX127X_ERROR_CANCELLED,
};
class SX127xTransmitListener {
public:
virtual void on_transmit_complete(SX127xError result) = 0;
};
// Driver state, not the chip's mode
enum class RadioState : uint8_t {
// Before setup or after a failed mode change; configure() is retried every second
RADIO_STATE_NEEDS_CONFIGURATION,
// Receiving or sleeping as configured, or sending after the TX mode action (untracked)
RADIO_STATE_IDLE,
// A send is on air
RADIO_STATE_TRANSMITTING,
// A send found a received packet waiting; loop() delivers it
RADIO_STATE_HOLDING_RX,
};
class SX127xListener {
public:
// Called from loop(); the packet is only valid until this returns
virtual void on_packet(const std::vector<uint8_t> &packet, float rssi, float snr) = 0;
};
@@ -60,8 +85,9 @@ class SX127x final : public Component,
void set_coding_rate(uint8_t coding_rate) { this->coding_rate_ = coding_rate; }
void set_crc_enable(bool crc_enable) { this->crc_enable_ = crc_enable; }
void set_deviation(uint32_t deviation) { this->deviation_ = deviation; }
void set_dio0_pin(InternalGPIOPin *dio0_pin) { this->dio0_pin_ = dio0_pin; }
void set_dio0_pin(GPIOPin *dio0_pin) { this->dio0_pin_ = dio0_pin; }
void set_frequency(uint32_t frequency) { this->frequency_ = frequency; }
// Ignored unless the radio is idle
void set_mode_rx();
void set_mode_tx();
void set_mode_standby();
@@ -76,27 +102,72 @@ class SX127x final : public Component,
void set_preamble_polarity(uint8_t preamble_polarity) { this->preamble_polarity_ = preamble_polarity; }
void set_preamble_size(uint16_t preamble_size) { this->preamble_size_ = preamble_size; }
void set_preamble_detect(uint8_t preamble_detect) { this->preamble_detect_ = preamble_detect; }
void set_rst_pin(InternalGPIOPin *rst_pin) { this->rst_pin_ = rst_pin; }
void set_rst_pin(GPIOPin *rst_pin) { this->rst_pin_ = rst_pin; }
void set_rx_floor(float floor) { this->rx_floor_ = floor; }
void set_rx_start(bool start) { this->rx_start_ = start; }
void set_shaping(uint8_t shaping) { this->shaping_ = shaping; }
void set_spreading_factor(uint8_t spreading_factor) { this->spreading_factor_ = spreading_factor; }
void set_sync_value(const std::vector<uint8_t> &sync_value) { this->sync_value_ = sync_value; }
void run_image_cal();
// Ignored while a send is on air; discards a held packet
void configure();
SX127xError transmit_packet(const uint8_t *data, size_t len);
SX127xError transmit_packet(const std::vector<uint8_t> &packet) {
return this->transmit_packet(packet.data(), packet.size());
}
// On SX127X_ERROR_NONE, the listener is called once from loop()
[[nodiscard]] SX127xError start_transmit_async(SX127xTransmitListener *listener, const uint8_t *data, size_t len,
uint32_t timeout_ms = 4000);
[[nodiscard]] SX127xError start_transmit_async(SX127xTransmitListener *listener, const std::vector<uint8_t> &packet,
uint32_t timeout_ms = 4000) {
return this->start_transmit_async(listener, packet.data(), packet.size(), timeout_ms);
}
// Completes the send with SX127X_ERROR_CANCELLED; false if the listener has none
bool cancel_transmit_async(SX127xTransmitListener *listener);
bool is_transmitting() const { return this->state_ == RadioState::RADIO_STATE_TRANSMITTING; }
void register_listener(SX127xListener *listener) { this->listeners_.push_back(listener); }
// True while a packet is being received, or has been received and not yet read; sending would lose it.
bool is_receiving();
Trigger<std::vector<uint8_t>, float, float> *get_packet_trigger() { return &this->packet_trigger_; }
protected:
static void gpio_intr(SX127x *arg);
// Settings as last applied by configure(), used by sends and reception
struct AppliedSettings {
uint32_t frequency{0};
uint32_t payload_length{0};
uint8_t modulation{0};
bool packet_mode{false};
bool rx_start{false};
};
struct TxOperation {
SX127xTransmitListener *listener{nullptr};
uint32_t started_ms{0};
uint32_t timeout_ms{0};
};
static void IRAM_ATTR gpio_intr(SX127x *arg) { arg->enable_loop_soon_any_context(); }
// Each returns the failure reason, or nullptr
const LogString *configure_radio_();
const LogString *image_cal_();
void configure_fsk_ook_();
void configure_lora_();
void set_mode_(uint8_t modulation, uint8_t mode);
void write_fifo_(const uint8_t *data, size_t len);
// False if the chip did not enter the mode
bool set_mode_(uint8_t modulation, uint8_t mode);
bool enter_rx_();
bool enter_tx_();
bool can_change_mode_();
void change_mode_(uint8_t mode);
// Puts the radio back in RX or sleep after a send or a held packet
bool restore_();
// Retries configure() every second
void fail_(const LogString *reason);
bool packet_waiting_();
void receive_();
SX127xError start_transmit_(SX127xTransmitListener *listener, const uint8_t *data, size_t len, uint32_t timeout_ms);
// True once the send has ended, with its outcome in result
bool poll_transmit_(uint32_t now, SX127xError &result);
SX127xError finish_transmit_(SX127xError result);
void write_registers_(uint8_t reg, const uint8_t *data, size_t len);
void write_register16_(uint8_t msb_reg, uint16_t value);
void read_fifo_(std::vector<uint8_t> &packet);
void write_register_(uint8_t reg, uint8_t value);
void call_listeners_(const std::vector<uint8_t> &packet, float rssi, float snr);
@@ -105,8 +176,10 @@ class SX127x final : public Component,
std::vector<SX127xListener *> listeners_;
std::vector<uint8_t> packet_;
std::vector<uint8_t> sync_value_;
InternalGPIOPin *dio0_pin_{nullptr};
InternalGPIOPin *rst_pin_{nullptr};
AppliedSettings applied_;
TxOperation tx_;
GPIOPin *dio0_pin_{nullptr};
GPIOPin *rst_pin_{nullptr};
SX127xBw afc_bandwidth_{SX127X_BW_50_0};
SX127xBw bandwidth_;
uint32_t bitrate_;
@@ -130,6 +203,8 @@ class SX127x final : public Component,
bool crc_enable_{false};
bool packet_mode_{false};
bool rx_start_{false};
bool reconfigure_pending_{false};
RadioState state_{RadioState::RADIO_STATE_NEEDS_CONFIGURATION};
};
} // namespace esphome::sx127x
+18
View File
@@ -46,6 +46,8 @@ enum SX127xReg : uint8_t {
REG_PAYLOAD_LENGTH_LSB = 0x32,
REG_FIFO_THRESH = 0x35,
REG_IMAGE_CAL = 0x3B,
REG_IRQ_FLAGS_1 = 0x3E,
REG_IRQ_FLAGS2 = 0x3F,
// LoRa registers
REG_FIFO_ADDR_PTR = 0x0D,
REG_FIFO_TX_BASE_ADDR = 0x0E,
@@ -260,6 +262,22 @@ enum SX127xIrqFlags : uint8_t {
CAD_DETECTED = 0x01,
};
enum SX127xIrqFlags1 : uint8_t {
IRQ_FLAGS_1_PREAMBLE_DETECT = 0x02,
IRQ_FLAGS_1_SYNC_ADDRESS_MATCH = 0x01,
};
enum SX127xModemStat : uint8_t {
MODEM_STAT_SIGNAL_DETECTED = 0x01,
MODEM_STAT_SIGNAL_SYNCHRONIZED = 0x02,
MODEM_STAT_HEADER_VALID = 0x08,
};
enum SX127xIrqFlags2 : uint8_t {
PACKET_SENT = 0x08,
PAYLOAD_READY = 0x04,
};
enum SX127xModemCfg1 : uint8_t {
BW_7_8 = 0x00,
BW_10_4 = 0x10,
+4
View File
@@ -0,0 +1,4 @@
"""TCP links. The packet_interface platform carries packets over a TCP connection."""
CODEOWNERS = ["@clydebarrow"]
DOMAIN = "tcp"
@@ -0,0 +1,132 @@
import esphome.codegen as cg
from esphome.components import binary_sensor, packet_interface, socket
from esphome.components.const import (
CONF_ALLOWED_IPS,
CONF_CONNECTED,
CONF_HOST,
CONF_RECONNECT_INTERVAL,
CONF_ROLE,
)
from esphome.components.packet_interface import (
CONF_MAX_PACKET_SIZE,
new_packet_interface,
packet_interface_schema,
)
from esphome.components.packet_interface.layers import (
CONF_ADDRESSING,
CONF_RELIABILITY,
CONF_SESSION,
)
from esphome.components.packet_interface.layers.basic_session import CONF_KEEP_ALIVE
import esphome.config_validation as cv
from esphome.const import (
CONF_ID,
CONF_PORT,
CONF_TIMEOUT,
DEVICE_CLASS_CONNECTIVITY,
ENTITY_CATEGORY_DIAGNOSTIC,
)
from esphome.types import ConfigType
CODEOWNERS = ["@clydebarrow"]
DEPENDENCIES = ["network"]
def AUTO_LOAD(config: ConfigType | None = None) -> list[str]:
"""The binary_sensor component only for the connected sensor; without a config, as tooling calls it, both."""
if not config or CONF_CONNECTED in config:
return ["socket", "binary_sensor"]
return ["socket"]
# Each packet and its 2 byte length must fit the socket link's 1024 byte send buffer
MAX_PACKET_SIZE = 1022
tcp_ns = cg.esphome_ns.namespace("tcp")
TcpPacketInterface = tcp_ns.class_(
"TcpPacketInterface", packet_interface.PacketInterface
)
def _timeout(config: ConfigType) -> ConfigType:
"""Default the timeout to three keep-alive intervals, and require it to be longer than one."""
keep_alive = config[CONF_KEEP_ALIVE].total_milliseconds
if (timeout := config.get(CONF_TIMEOUT)) is None:
config[CONF_TIMEOUT] = cv.positive_time_period_milliseconds(
f"{keep_alive * 3}ms"
)
elif timeout.total_milliseconds <= keep_alive:
raise cv.Invalid("Must be longer than keep_alive", path=[CONF_TIMEOUT])
return config
BASE_SCHEMA = packet_interface_schema(
TcpPacketInterface,
MAX_PACKET_SIZE,
MAX_PACKET_SIZE,
# TCP resends what is lost, joins exactly two devices, and its connection state is the session
provides=(CONF_ADDRESSING, CONF_RELIABILITY, CONF_SESSION),
).extend(
{
cv.Required(CONF_PORT): cv.port,
cv.Optional(
CONF_RECONNECT_INTERVAL, default="5s"
): cv.positive_time_period_milliseconds,
cv.Optional(CONF_KEEP_ALIVE, default="10s"): cv.All(
cv.positive_time_period_milliseconds,
cv.Range(min=cv.TimePeriod(seconds=1), max=cv.TimePeriod(hours=1)),
),
# Nothing received for this long closes the connection; it must be longer than the peer's keep_alive
cv.Optional(CONF_TIMEOUT): cv.All(
cv.positive_time_period_milliseconds,
cv.Range(max=cv.TimePeriod(hours=3)),
),
cv.Optional(CONF_CONNECTED): binary_sensor.binary_sensor_schema(
device_class=DEVICE_CLASS_CONNECTIVITY,
entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
),
}
)
CONFIG_SCHEMA = cv.All(
cv.typed_schema(
{
"client": cv.All(
BASE_SCHEMA.extend({cv.Required(CONF_HOST): socket.ipv4_host}),
_timeout,
),
"server": cv.All(
BASE_SCHEMA.extend(
{cv.Optional(CONF_ALLOWED_IPS): socket.IPV4_ALLOW_SCHEMA}
),
_timeout,
),
},
key=CONF_ROLE,
default_type="client",
),
# A client uses one socket; a server one listener and one accepted socket
socket.consume_role_sockets("tcp.packet_interface"),
)
async def to_code(config: ConfigType) -> None:
rx_buffer = cg.static_buffer(
config[CONF_ID], cg.uint8, config[CONF_MAX_PACKET_SIZE]
)
var = await new_packet_interface(config, rx_buffer)
if config[CONF_ROLE] == "server":
socket.require_tcp_listener()
cg.add(var.set_server(True))
socket.add_ipv4_allow(
var.set_allow, config.get(CONF_ALLOWED_IPS), config[CONF_ID]
)
else:
socket.require_tcp_client_link()
cg.add(var.set_host(config[CONF_HOST]))
cg.add(var.set_port(config[CONF_PORT]))
cg.add(var.set_reconnect_interval(config[CONF_RECONNECT_INTERVAL]))
cg.add(var.set_keep_alive(config[CONF_KEEP_ALIVE]))
cg.add(var.set_receive_timeout(config[CONF_TIMEOUT]))
binary_sensors = binary_sensor.sub_binary_sensors(config)
await binary_sensors(CONF_CONNECTED, var.set_connected_binary_sensor)
@@ -0,0 +1,182 @@
#include "tcp_packet_interface.h"
#include "esphome/core/application.h"
#include "esphome/core/helpers.h"
#include "esphome/core/log.h"
namespace esphome::tcp {
using packet_interface::PacketBuffer;
using packet_interface::PacketMetaData;
ESPHOME_LOG_TAG(TAG, "tcp.packet_interface");
// The packet length before each packet
static constexpr size_t LENGTH_SIZE = 2;
// A peer that sends without a pause must not hold the main loop here; a frame being read carries over to the next pass
static constexpr uint8_t MAX_FRAMES_PER_LOOP = 8;
TcpPacketInterface::TcpPacketInterface(std::span<uint8_t> rx_buffer)
: packet_interface::PacketInterface(rx_buffer.size()), rx_buffer_(rx_buffer) {
this->capabilities_ = packet_interface::CAPABILITY_RELIABILITY | packet_interface::CAPABILITY_SESSION |
packet_interface::CAPABILITY_ADDRESSING;
}
void TcpPacketInterface::setup() {
this->link_.begin(TAG);
#ifdef USE_SOCKET_TCP_LISTENER
this->listener_.begin(TAG);
#endif
#ifdef USE_BINARY_SENSOR
if (this->connected_binary_sensor_ != nullptr)
this->connected_binary_sensor_->publish_initial_state(false);
#endif
}
void TcpPacketInterface::dump_config() {
bool server = false;
#ifdef USE_SOCKET_TCP_LISTENER
server = this->server_;
#endif
ESP_LOGCONFIG(TAG,
"TCP Packet Interface '%s':\n"
" Role: %s\n"
" Address: %s:%u\n"
" Reconnect Interval: %" PRIu32 "ms\n"
" Keep Alive: %" PRIu32 "ms\n"
" Timeout: %" PRIu32 "ms\n"
" Max Packet Size: %zu",
this->name_, server ? LOG_STR_LITERAL("server") : LOG_STR_LITERAL("client"),
server ? LOG_STR_LITERAL("*") : this->link_.host(), this->link_.port(),
this->link_.reconnect_interval(), this->keep_alive_ms_, this->timeout_ms_, this->max_packet_size_);
#ifdef USE_SOCKET_TCP_LISTENER
this->listener_.dump_config();
#endif
#ifdef USE_BINARY_SENSOR
LOG_BINARY_SENSOR(" ", "Connected", this->connected_binary_sensor_);
#endif
}
void TcpPacketInterface::on_shutdown() {
this->link_.close();
#ifdef USE_SOCKET_TCP_LISTENER
this->listener_.close();
#endif
}
void TcpPacketInterface::loop() {
#ifdef USE_SOCKET_TCP_LISTENER
if (this->server_) {
// A new client is accepted only once the drop of the last has been reported
this->listener_.poll(this->link_, !this->connected_);
} else {
this->link_.poll();
}
#else
this->link_.poll();
#endif
if (this->link_.connected() != this->connected_)
this->on_connection_(this->link_.connected());
if (!this->connected_)
return;
this->read_();
if (!this->connected_)
return;
uint32_t now = App.get_loop_component_start_time();
if (now - this->last_rx_ms_ > this->timeout_ms_) {
ESP_LOGW(TAG, "%s: Nothing received for %" PRIu32 "ms, closing the connection", this->name_, this->timeout_ms_);
this->link_.close();
this->link_.note_attempt();
this->on_connection_(false);
return;
}
if (now - this->last_tx_ms_ >= this->keep_alive_ms_)
this->queue_frame_(nullptr, 0);
this->flush_();
}
void TcpPacketInterface::flush_() { this->tx_waiting_ = !this->link_.flush_tx(); }
size_t TcpPacketInterface::get_send_capacity() const {
if (!this->tx_waiting_)
return SIZE_MAX;
return this->link_.tx_free() / (this->max_packet_size_ + LENGTH_SIZE);
}
void TcpPacketInterface::on_connection_(bool connected) {
ESP_LOGD(TAG, "%s: Connection %s", this->name_, connected ? LOG_STR_LITERAL("up") : LOG_STR_LITERAL("down"));
this->connected_ = connected;
this->tx_waiting_ = false;
this->rx_have_ = 0;
this->last_rx_ms_ = this->last_tx_ms_ = App.get_loop_component_start_time();
#ifdef USE_BINARY_SENSOR
if (this->connected_binary_sensor_ != nullptr)
this->connected_binary_sensor_->publish_state(connected);
#endif
this->session_callback_.call(connected);
}
void TcpPacketInterface::read_() {
for (uint8_t frames = 0; frames != MAX_FRAMES_PER_LOOP;) {
ssize_t count;
if (this->rx_have_ < LENGTH_SIZE) {
count = this->link_.read(this->rx_header_ + this->rx_have_, LENGTH_SIZE - this->rx_have_);
} else {
count = this->link_.read(this->rx_buffer_.data() + this->rx_have_ - LENGTH_SIZE,
this->rx_length_ + LENGTH_SIZE - this->rx_have_);
}
// Nothing more for now; a dropped link is seen on the next loop
if (count <= 0)
return;
this->last_rx_ms_ = App.get_loop_component_start_time();
this->rx_have_ += count;
if (this->rx_have_ < LENGTH_SIZE)
continue;
if (this->rx_have_ == LENGTH_SIZE) {
this->rx_length_ = encode_uint16(this->rx_header_[1], this->rx_header_[0]);
if (this->rx_length_ > this->max_packet_size_) {
// The stream cannot be resynchronised, so start a new connection
ESP_LOGW(TAG, "%s: Packet of %u bytes is larger than %zu, closing the connection", this->name_,
this->rx_length_, this->max_packet_size_);
this->link_.close();
this->link_.note_attempt();
this->on_connection_(false);
return;
}
}
if (this->rx_have_ == this->rx_length_ + LENGTH_SIZE) {
this->rx_have_ = 0;
frames++;
// A zero length packet is a keep-alive
if (this->rx_length_ != 0)
this->on_receive_from_interface_(PacketBuffer(this->rx_buffer_.data(), this->rx_length_), {});
}
}
}
bool TcpPacketInterface::queue_frame_(const PacketBuffer *data, size_t size) {
if (this->link_.tx_free() < size + LENGTH_SIZE)
return false;
uint8_t *tail = this->link_.tx_tail();
tail[0] = static_cast<uint8_t>(size);
tail[1] = static_cast<uint8_t>(size >> 8);
if (data != nullptr)
data->copy_to(tail + LENGTH_SIZE, size);
this->link_.tx_commit(size + LENGTH_SIZE);
this->last_tx_ms_ = App.get_loop_component_start_time();
return true;
}
bool TcpPacketInterface::send_to_interface(const PacketBuffer &data, const PacketMetaData &meta_data) {
size_t size = data.size();
if (size > this->max_packet_size_) {
ESP_LOGW(TAG, "%s: Packet of %zu bytes is larger than %zu", this->name_, size, this->max_packet_size_);
return false;
}
if (!this->connected_ || !this->queue_frame_(&data, size))
return false;
// A write that fails closes the link and discards what was queued, this packet included
this->flush_();
return this->link_.connected();
}
} // namespace esphome::tcp
@@ -0,0 +1,93 @@
#pragma once
#include <cstdint>
#include <span>
#include "esphome/components/packet_interface/packet_interface.h"
#include "esphome/components/socket/tcp_client_link.h"
#ifdef USE_SOCKET_TCP_LISTENER
#include "esphome/components/socket/tcp_listener.h"
#endif
#ifdef USE_BINARY_SENSOR
#include "esphome/components/binary_sensor/binary_sensor.h"
#endif
namespace esphome::tcp {
/**
* A packet interface link over one TCP connection, as a client that connects to a host, or a server that accepts
* one client at a time.
*
* Each packet is sent as a 2 byte length, little endian, then the packet. TCP delivers the stream in order and
* resends what is lost, and the connection joins exactly two devices, so the link provides the reliability,
* addressing and session capabilities itself. Its connection state is the session state.
*
* Each packet is written to the socket as it is sent, so the link takes packets as fast as the socket does and keeps
* the default, unlimited, send capacity; a packet is refused only while the connection is down or the socket is full.
*
* A zero length packet is a keep-alive, sent when nothing else has been sent for keep_alive. TCP can take minutes to
* notice a peer that has gone without closing the connection, so the link closes it, and reconnects or accepts again,
* when nothing has been received for the timeout, which must be longer than the peer's keep-alive interval.
*/
class TcpPacketInterface : public packet_interface::PacketInterface {
public:
/// @param rx_buffer Holds the packet being received; its size is the largest packet, and it must outlive the link
explicit TcpPacketInterface(std::span<uint8_t> rx_buffer);
void setup() override;
void loop() override;
void dump_config() override;
void on_shutdown() override;
bool send_to_interface(const packet_interface::PacketBuffer &data,
const packet_interface::PacketMetaData &meta_data) override;
/**
* Unlimited while the socket takes what is sent. Once frames wait for it, how many more full frames fit. A socket
* that stalls part way through a fragmented packet still cuts it short.
*/
size_t get_send_capacity() const override;
void set_host(const char *host) { this->link_.set_host(host); }
void set_port(uint16_t port) { this->link_.set_port(port); }
void set_reconnect_interval(uint32_t interval_ms) { this->link_.set_reconnect_interval(interval_ms); }
void set_keep_alive(uint32_t keep_alive_ms) { this->keep_alive_ms_ = keep_alive_ms; }
/// The connection is closed when nothing has been received for this long; the peer's keep_alive sets the pace.
void set_receive_timeout(uint32_t timeout_ms) { this->timeout_ms_ = timeout_ms; }
#ifdef USE_SOCKET_TCP_LISTENER
void set_server(bool server) { this->server_ = server; }
#ifdef USE_SOCKET_IPV4_ALLOW
void set_allow(const socket::Ipv4AllowEntry *entries, size_t count) { this->listener_.set_allow(entries, count); }
#endif
#endif
#ifdef USE_BINARY_SENSOR
SUB_BINARY_SENSOR(connected)
#endif
bool is_connected() const { return this->connected_; }
protected:
void on_connection_(bool connected);
void read_();
bool queue_frame_(const packet_interface::PacketBuffer *data, size_t size);
void flush_();
socket::TcpClientLink link_;
#ifdef USE_SOCKET_TCP_LISTENER
socket::TcpListener listener_;
#endif
const std::span<uint8_t> rx_buffer_;
uint32_t keep_alive_ms_{10000};
uint32_t timeout_ms_{30000};
uint32_t last_rx_ms_{0};
uint32_t last_tx_ms_{0};
uint16_t rx_length_{0};
// Bytes of the current frame received so far, counting the 2 byte length
uint16_t rx_have_{0};
uint8_t rx_header_[2]{};
bool connected_ : 1 {false};
bool tx_waiting_ : 1 {false}; // frames are queued that the socket has not taken yet
#ifdef USE_SOCKET_TCP_LISTENER
bool server_ : 1 {false};
#endif
};
} // namespace esphome::tcp
@@ -1,6 +1,7 @@
#include "esphome/core/log.h"
#include "esphome/core/application.h"
#include "uart_transport.h"
#include "esphome/core/helpers.h"
namespace esphome::uart {
@@ -23,7 +24,7 @@ void UARTTransport::loop() {
if (this->rx_started_ && this->receive_buffer_.size() > 6) {
auto len = this->receive_buffer_.size();
auto crc = crc16(this->receive_buffer_.data(), len - 2);
if (crc != (this->receive_buffer_[len - 2] | (this->receive_buffer_[len - 1] << 8))) {
if (crc != encode_value_le<uint16_t>(this->receive_buffer_.data() + len - 2)) {
ESP_LOGD(TAG, "CRC mismatch, discarding packet");
this->rx_started_ = false;
this->receive_buffer_.clear();
@@ -1,3 +1,5 @@
from ipaddress import IPv4Address
import esphome.codegen as cg
from esphome.components import packet_interface
from esphome.components.packet_interface import (
@@ -5,15 +7,24 @@ from esphome.components.packet_interface import (
new_packet_interface,
packet_interface_schema,
)
from esphome.components.packet_interface.layers import (
CONF_ADDRESSING,
check_broadcast_link,
)
import esphome.config_validation as cv
from esphome.const import CONF_ID
from esphome.core import CORE, HexInt
import esphome.final_validate as fv
from esphome.types import ConfigType
from .. import CONF_UDP_ID, UDP_SCHEMA, udp_ns
from .. import CONF_ADDRESSES, CONF_UDP_ID, DOMAIN as UDP_DOMAIN, UDP_SCHEMA, udp_ns
CODEOWNERS = ["@clydebarrow"]
DEPENDENCIES = ["udp"]
CONF_POINT_TO_POINT = "point_to_point"
# Size of the receive buffer of the udp component
MAX_PACKET_SIZE = 508
@@ -22,9 +33,62 @@ UdpPacketInterface = udp_ns.class_(
packet_interface.PacketInterface,
)
CONFIG_SCHEMA = packet_interface_schema(
UdpPacketInterface, MAX_PACKET_SIZE, MAX_PACKET_SIZE
).extend(UDP_SCHEMA)
CONFIG_SCHEMA = (
packet_interface_schema(UdpPacketInterface, MAX_PACKET_SIZE, MAX_PACKET_SIZE)
.extend(UDP_SCHEMA)
.extend(
{
# Overrides the guess from the udp component's addresses, which cannot see the subnet
cv.Optional(CONF_POINT_TO_POINT): cv.boolean,
}
)
)
def _peer(udp_config: ConfigType, config: ConfigType) -> IPv4Address | None:
"""The one peer, when the UDP component sends to a single unicast IPv4 address.
Unless point_to_point says otherwise, an address ending in .255 is taken as a subnet broadcast, as the subnet is
not known here.
"""
point_to_point = config.get(CONF_POINT_TO_POINT)
match udp_config[CONF_ADDRESSES]:
# Neither all zeros nor all ones is one device's address
case [IPv4Address() as address] if not (
address.is_multicast
or address.is_unspecified
or address == IPv4Address("255.255.255.255")
):
if point_to_point is None:
point_to_point = address.packed[3] != 255
return address if point_to_point else None
if point_to_point:
raise cv.Invalid(
f"'{CONF_POINT_TO_POINT}' needs the UDP component to send to one unicast IPv4 address",
path=[CONF_POINT_TO_POINT],
)
return None
def _udp_config(full_config: ConfigType, config: ConfigType) -> ConfigType:
return next(
udp for udp in full_config[UDP_DOMAIN] if udp[CONF_ID] == config[CONF_UDP_ID]
)
def _final_validate(config: ConfigType) -> ConfigType:
if (peer := _peer(_udp_config(fv.full_config.get(), config), config)) is None:
check_broadcast_link(config)
elif CONF_ADDRESSING in config:
raise cv.Invalid(
f"The UDP component sends only to {peer}, so packets are already addressed; "
f"'{CONF_ADDRESSING}' is only for broadcast or multicast",
path=[CONF_ADDRESSING],
)
return config
FINAL_VALIDATE_SCHEMA = _final_validate
async def to_code(config: ConfigType) -> None:
@@ -32,7 +96,11 @@ async def to_code(config: ConfigType) -> None:
cg.add(udp_var.set_should_listen())
# The udp component sends to its addresses through its broadcast socket
cg.add(udp_var.set_should_broadcast())
peer = _peer(_udp_config(CORE.config, config), config)
peer_bytes = peer.packed if peer is not None else bytes(4)
tx_buffer = cg.static_buffer(
config[CONF_ID], cg.uint8, config[CONF_MAX_PACKET_SIZE]
)
await new_packet_interface(config, udp_var, tx_buffer)
await new_packet_interface(
config, udp_var, tx_buffer, [HexInt(x) for x in peer_bytes]
)
@@ -1,6 +1,8 @@
#include "udp_packet_interface.h"
#ifdef USE_NETWORK
#include <cstring>
#include "esphome/components/network/util.h"
#include "esphome/core/application.h"
#include "esphome/core/log.h"
namespace esphome::udp {
@@ -10,11 +12,23 @@ using packet_interface::PacketMetaData;
ESPHOME_LOG_TAG(TAG, "udp.packet_interface");
void UdpPacketInterface::setup() {
this->parent_->add_listener([this](std::span<const uint8_t> data) { this->receive_(data); });
UdpPacketInterface::UdpPacketInterface(UDPComponent *udp_component, std::span<uint8_t> tx_buffer,
std::array<uint8_t, 4> peer)
: packet_interface::PacketInterface(tx_buffer.size()), parent_(udp_component), tx_buffer_(tx_buffer), peer_(peer) {
if (this->peer_ != std::array<uint8_t, 4>{})
this->capabilities_ = packet_interface::CAPABILITY_ADDRESSING;
}
void UdpPacketInterface::receive_(std::span<const uint8_t> data) {
void UdpPacketInterface::setup() {
this->parent_->add_listener(
[this](std::span<const uint8_t> data) { this->receive_(data, this->parent_->get_rx_source()); });
}
void UdpPacketInterface::receive_(std::span<const uint8_t> data, const sockaddr *source) {
if (!this->accepts_from_(source)) {
this->warn_dropped_(source);
return;
}
if (data.size() > this->max_packet_size_) {
ESP_LOGV(TAG, "%s: Packet of %zu bytes is larger than %zu, dropped", this->name_, data.size(),
this->max_packet_size_);
@@ -23,6 +37,28 @@ void UdpPacketInterface::receive_(std::span<const uint8_t> data) {
this->on_receive_from_interface_(PacketBuffer(data.data(), data.size()), {});
}
bool UdpPacketInterface::accepts_from_(const sockaddr *source) const {
if (!this->has_capability(packet_interface::CAPABILITY_ADDRESSING))
return true;
uint32_t address;
return socket::sockaddr_to_ipv4(source, &address) && memcmp(&address, this->peer_.data(), sizeof(address)) == 0;
}
void UdpPacketInterface::warn_dropped_(const sockaddr *source) {
static constexpr uint32_t WARNING_INTERVAL_MS = 60000;
uint32_t now = App.get_loop_component_start_time();
if (this->drop_warned_ && now - this->last_drop_warning_ms_ < WARNING_INTERVAL_MS)
return;
this->drop_warned_ = true;
this->last_drop_warning_ms_ = now;
char from[socket::SOCKADDR_STR_LEN];
socket::format_sockaddr_to(source, sizeof(sockaddr_storage), from);
ESP_LOGW(TAG,
"%s: Packet from %s dropped, as only %u.%u.%u.%u is accepted; set point_to_point: false if that is a "
"broadcast address",
this->name_, from, this->peer_[0], this->peer_[1], this->peer_[2], this->peer_[3]);
}
bool UdpPacketInterface::send_to_interface(const PacketBuffer &data, const PacketMetaData &meta_data) {
size_t size = data.size();
if (size > this->max_packet_size_) {
@@ -4,9 +4,11 @@
// udp_component.h declares nothing without USE_NETWORK
#ifdef USE_NETWORK
#include <array>
#include <span>
#include "esphome/components/packet_interface/packet_interface.h"
#include "esphome/components/socket/socket.h"
#include "../udp_component.h"
namespace esphome::udp {
@@ -14,24 +16,33 @@ namespace esphome::udp {
/**
* A packet interface link over UDP: each packet is one datagram, sent to every address of the UDP component.
*
* Every datagram received on the listen port is passed up, from any sender, so on a shared network an addressing
* or encryption layer is needed to tell the peer's packets from others.
* When the UDP component sends to one unicast IPv4 address, the link joins exactly two devices: it accepts packets
* only from that address, and provides the addressing capability itself. Otherwise every packet is accepted, and an
* addressing layer can tell the devices apart. Packets from other senders are dropped with a warning at most once a
* minute, as they suggest that the address is a broadcast address the link took for a device.
*/
class UdpPacketInterface : public packet_interface::PacketInterface {
public:
/// @param tx_buffer Joins packets split across buffers; its size is the largest packet, and it must outlive the link
UdpPacketInterface(UDPComponent *udp_component, std::span<uint8_t> tx_buffer)
: packet_interface::PacketInterface(tx_buffer.size()), parent_(udp_component), tx_buffer_(tx_buffer) {}
/// @param peer The IPv4 address of the one peer, in network byte order; all zeros if packets are broadcast
UdpPacketInterface(UDPComponent *udp_component, std::span<uint8_t> tx_buffer, std::array<uint8_t, 4> peer);
void setup() override;
bool send_to_interface(const packet_interface::PacketBuffer &data,
const packet_interface::PacketMetaData &meta_data) override;
protected:
void receive_(std::span<const uint8_t> data);
void receive_(std::span<const uint8_t> data, const sockaddr *source);
/// True if packets from \p source are accepted: from anywhere, or with a peer, only from the peer.
bool accepts_from_(const sockaddr *source) const;
void warn_dropped_(const sockaddr *source);
// First, so it fills the spare byte at the end of PacketInterface
bool drop_warned_{false};
UDPComponent *parent_;
const std::span<uint8_t> tx_buffer_;
std::array<uint8_t, 4> peer_;
uint32_t last_drop_warning_ms_{0};
};
} // namespace esphome::udp
#endif
+11 -1
View File
@@ -242,10 +242,18 @@ void UDPComponent::loop() {
}
// One byte more than the largest packet, as a read cuts a longer datagram to fit and so cannot report it
std::array<uint8_t, MAX_PACKET_SIZE + 1> buf;
struct sockaddr_storage source;
for (;;) {
if (!this->listen_socket_->ready())
break;
auto len = this->listen_socket_->read(buf.data(), buf.size());
socklen_t source_len = sizeof(source);
auto len =
this->listen_socket_->recvfrom(buf.data(), buf.size(), reinterpret_cast<sockaddr *>(&source), &source_len);
if (len < 0 && errno != EWOULDBLOCK && errno != EAGAIN) {
// The raw lwIP socket consumes a packet whose source address it cannot convert
ESP_LOGD(TAG, "Read failed: errno %d", errno);
break;
}
if (len <= 0)
break;
size_t packet_len = static_cast<size_t>(len);
@@ -254,7 +262,9 @@ void UDPComponent::loop() {
continue;
}
ESP_LOGV(TAG, "Received packet of length %zu", packet_len);
this->rx_source_ = reinterpret_cast<sockaddr *>(&source);
this->packet_listeners_.call(std::span<const uint8_t>(buf.data(), packet_len));
this->rx_source_ = nullptr;
}
}
+3
View File
@@ -47,6 +47,8 @@ class UDPComponent final : public Component {
void set_omr_source() { this->poll_pending_ |= POLL_SRC_BIND; }
#endif
template<typename F> void add_listener(F &&listener) { this->packet_listeners_.add(std::forward<F>(listener)); }
/// The sender of the packet being passed to the listeners; valid only during a listener call.
const sockaddr *get_rx_source() const { return this->rx_source_; }
void setup() override;
void loop() override;
void dump_config() override;
@@ -78,6 +80,7 @@ class UDPComponent final : public Component {
StaticFixedVector<SockaddrEntry> sockaddrs_;
const char *const *addresses_{nullptr};
const char *listen_address_{nullptr};
const sockaddr *rx_source_{nullptr};
#ifdef USE_SOCKET_IPV6
uint32_t mcast_ifindex_{0};
#endif
Loaded 100 of 194 files, more files were not shown because too many files have changed in this diff. Show more