mirror of
https://github.com/openmv/openmv.git
synced 2025-09-26 23:09:13 +08:00
Merge pull request #2400 from openmv/flash_optimization
imlib/apriltag: Switch to libm's sin/cos.
This commit is contained in:
commit
a58a1ebc33
@ -1,102 +0,0 @@
|
||||
# This work is licensed under the MIT license.
|
||||
# Copyright (c) 2013-2023 OpenMV LLC. All rights reserved.
|
||||
# https://github.com/openmv/openmv/blob/master/LICENSE
|
||||
#
|
||||
# This example demonstrates a simple temperature sensor peripheral.
|
||||
#
|
||||
# The sensor's local value updates every second, and it will notify
|
||||
# any connected central every 10 seconds.
|
||||
|
||||
import bluetooth
|
||||
import random
|
||||
import struct
|
||||
import time
|
||||
from ble_advertising import advertising_payload
|
||||
from machine import LED
|
||||
from micropython import const
|
||||
|
||||
_IRQ_CENTRAL_CONNECT = const(1)
|
||||
_IRQ_CENTRAL_DISCONNECT = const(2)
|
||||
_IRQ_GATTS_INDICATE_DONE = const(20)
|
||||
|
||||
_FLAG_READ = const(0x0002)
|
||||
_FLAG_NOTIFY = const(0x0010)
|
||||
_FLAG_INDICATE = const(0x0020)
|
||||
|
||||
# org.bluetooth.service.environmental_sensing
|
||||
_ENV_SENSE_UUID = bluetooth.UUID(0x181A)
|
||||
# org.bluetooth.characteristic.temperature
|
||||
_TEMP_CHAR = (
|
||||
bluetooth.UUID(0x2A6E),
|
||||
_FLAG_READ | _FLAG_NOTIFY | _FLAG_INDICATE,
|
||||
)
|
||||
_ENV_SENSE_SERVICE = (
|
||||
_ENV_SENSE_UUID,
|
||||
(_TEMP_CHAR,),
|
||||
)
|
||||
|
||||
# org.bluetooth.characteristic.gap.appearance.xml
|
||||
_ADV_APPEARANCE_GENERIC_THERMOMETER = const(768)
|
||||
|
||||
|
||||
class BLETemperature:
|
||||
def __init__(self, ble, name="mpy-temp"):
|
||||
self._ble = ble
|
||||
self._ble.active(True)
|
||||
self._ble.irq(self._irq)
|
||||
((self._handle,),) = self._ble.gatts_register_services((_ENV_SENSE_SERVICE,))
|
||||
self._connections = set()
|
||||
self._payload = advertising_payload(
|
||||
name=name,
|
||||
services=[_ENV_SENSE_UUID],
|
||||
appearance=_ADV_APPEARANCE_GENERIC_THERMOMETER,
|
||||
)
|
||||
self._advertise()
|
||||
self.led = LED("LED_BLUE")
|
||||
|
||||
def _irq(self, event, data):
|
||||
# Track connections so we can send notifications.
|
||||
if event == _IRQ_CENTRAL_CONNECT:
|
||||
conn_handle, _, _ = data
|
||||
self._connections.add(conn_handle)
|
||||
self.led.on()
|
||||
elif event == _IRQ_CENTRAL_DISCONNECT:
|
||||
conn_handle, _, _ = data
|
||||
self._connections.remove(conn_handle)
|
||||
# Start advertising again to allow a new connection.
|
||||
self._advertise()
|
||||
self.led.off()
|
||||
elif event == _IRQ_GATTS_INDICATE_DONE:
|
||||
conn_handle, value_handle, status = data
|
||||
|
||||
def set_temperature(self, temp_deg_c, notify=False, indicate=False):
|
||||
# Data is sint16 in degrees Celsius with a resolution of 0.01 degrees Celsius.
|
||||
# Write the local value, ready for a central to read.
|
||||
self._ble.gatts_write(self._handle, struct.pack("<h", int(temp_deg_c * 100)))
|
||||
if notify or indicate:
|
||||
for conn_handle in self._connections:
|
||||
if notify:
|
||||
# Notify connected centrals.
|
||||
self._ble.gatts_notify(conn_handle, self._handle)
|
||||
if indicate:
|
||||
# Indicate connected centrals.
|
||||
self._ble.gatts_indicate(conn_handle, self._handle)
|
||||
|
||||
def _advertise(self, interval_us=500000):
|
||||
self._ble.gap_advertise(interval_us, adv_data=self._payload)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
ble = bluetooth.BLE()
|
||||
temp = BLETemperature(ble)
|
||||
|
||||
t = 25
|
||||
i = 0
|
||||
|
||||
while True:
|
||||
# Write every second, notify every 10 seconds.
|
||||
i = (i + 1) % 10
|
||||
temp.set_temperature(t, notify=i == 0, indicate=False)
|
||||
# Random walk the temperature.
|
||||
t += random.uniform(-0.5, 0.5)
|
||||
time.sleep_ms(1000)
|
@ -1,116 +0,0 @@
|
||||
# The MIT License (MIT)
|
||||
#
|
||||
# Copyright (c) 2013-2021 Damien P. George
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
# of this software and associated documentation files (the "Software"), to deal
|
||||
# in the Software without restriction, including without limitation the rights
|
||||
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
# copies of the Software, and to permit persons to whom the Software is
|
||||
# furnished to do so, subject to the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included in
|
||||
# all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
# THE SOFTWARE.
|
||||
#
|
||||
#
|
||||
# Helpers for generating BLE advertising payloads.
|
||||
|
||||
from micropython import const
|
||||
import struct
|
||||
import bluetooth
|
||||
|
||||
# Advertising payloads are repeated packets of the following form:
|
||||
# 1 byte data length (N + 1)
|
||||
# 1 byte type (see constants below)
|
||||
# N bytes type-specific data
|
||||
|
||||
_ADV_TYPE_FLAGS = const(0x01)
|
||||
_ADV_TYPE_NAME = const(0x09)
|
||||
_ADV_TYPE_UUID16_COMPLETE = const(0x3)
|
||||
_ADV_TYPE_UUID32_COMPLETE = const(0x5)
|
||||
_ADV_TYPE_UUID128_COMPLETE = const(0x7)
|
||||
_ADV_TYPE_UUID16_MORE = const(0x2)
|
||||
_ADV_TYPE_UUID32_MORE = const(0x4)
|
||||
_ADV_TYPE_UUID128_MORE = const(0x6)
|
||||
_ADV_TYPE_APPEARANCE = const(0x19)
|
||||
|
||||
|
||||
# Generate a payload to be passed to gap_advertise(adv_data=...).
|
||||
def advertising_payload(limited_disc=False, br_edr=False, name=None, services=None, appearance=0):
|
||||
payload = bytearray()
|
||||
|
||||
def _append(adv_type, value):
|
||||
nonlocal payload
|
||||
payload += struct.pack("BB", len(value) + 1, adv_type) + value
|
||||
|
||||
_append(
|
||||
_ADV_TYPE_FLAGS,
|
||||
struct.pack("B", (0x01 if limited_disc else 0x02) + (0x18 if br_edr else 0x04)),
|
||||
)
|
||||
|
||||
if name:
|
||||
_append(_ADV_TYPE_NAME, name)
|
||||
|
||||
if services:
|
||||
for uuid in services:
|
||||
b = bytes(uuid)
|
||||
if len(b) == 2:
|
||||
_append(_ADV_TYPE_UUID16_COMPLETE, b)
|
||||
elif len(b) == 4:
|
||||
_append(_ADV_TYPE_UUID32_COMPLETE, b)
|
||||
elif len(b) == 16:
|
||||
_append(_ADV_TYPE_UUID128_COMPLETE, b)
|
||||
|
||||
# See org.bluetooth.characteristic.gap.appearance.xml
|
||||
if appearance:
|
||||
_append(_ADV_TYPE_APPEARANCE, struct.pack("<h", appearance))
|
||||
|
||||
return payload
|
||||
|
||||
|
||||
def decode_field(payload, adv_type):
|
||||
i = 0
|
||||
result = []
|
||||
while i + 1 < len(payload):
|
||||
if payload[i + 1] == adv_type:
|
||||
result.append(payload[i + 2 : i + payload[i] + 1])
|
||||
i += 1 + payload[i]
|
||||
return result
|
||||
|
||||
|
||||
def decode_name(payload):
|
||||
n = decode_field(payload, _ADV_TYPE_NAME)
|
||||
return str(n[0], "utf-8") if n else ""
|
||||
|
||||
|
||||
def decode_services(payload):
|
||||
services = []
|
||||
for u in decode_field(payload, _ADV_TYPE_UUID16_COMPLETE):
|
||||
services.append(bluetooth.UUID(struct.unpack("<h", u)[0]))
|
||||
for u in decode_field(payload, _ADV_TYPE_UUID32_COMPLETE):
|
||||
services.append(bluetooth.UUID(struct.unpack("<d", u)[0]))
|
||||
for u in decode_field(payload, _ADV_TYPE_UUID128_COMPLETE):
|
||||
services.append(bluetooth.UUID(u))
|
||||
return services
|
||||
|
||||
|
||||
def demo():
|
||||
payload = advertising_payload(
|
||||
name="micropython",
|
||||
services=[bluetooth.UUID(0x181A), bluetooth.UUID("6E400001-B5A3-F393-E0A9-E50E24DCCA9E")],
|
||||
)
|
||||
print(payload)
|
||||
print(decode_name(payload))
|
||||
print(decode_services(payload))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
demo()
|
@ -9,7 +9,6 @@ import gc
|
||||
import machine
|
||||
import omv
|
||||
import select
|
||||
import socket
|
||||
import struct
|
||||
import time
|
||||
|
||||
@ -703,350 +702,3 @@ class rpc_usb_vcp_slave(rpc_slave):
|
||||
|
||||
def put_bytes(self, data, timeout_ms): # protected
|
||||
self.__usb_vcp.send(data, timeout=timeout_ms)
|
||||
|
||||
|
||||
class rpc_network_master(rpc_master):
|
||||
def __valid_tcp_socket(self): # private
|
||||
if self.__tcp__socket is None:
|
||||
try:
|
||||
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
||||
s.bind(self.__myaddr)
|
||||
s.listen(0)
|
||||
s.settimeout(1)
|
||||
self.__tcp__socket, addr = s.accept()
|
||||
s.close()
|
||||
except OSError:
|
||||
self.__tcp__socket = None
|
||||
return self.__tcp__socket is not None
|
||||
|
||||
def __close_tcp_socket(self): # private
|
||||
self.__tcp__socket.close()
|
||||
self.__tcp__socket = None
|
||||
|
||||
def __valid_udp_socket(self): # private
|
||||
if self.__udp__socket is None:
|
||||
try:
|
||||
self.__udp__socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
|
||||
self.__udp__socket.bind(self.__myaddr)
|
||||
except OSError:
|
||||
self.__udp__socket = None
|
||||
return self.__udp__socket is not None
|
||||
|
||||
def __close_udp_socket(self): # private
|
||||
self.__udp__socket.close()
|
||||
self.__udp__socket = None
|
||||
|
||||
def __init__(self, network_if, port=0x1DBA): # private
|
||||
self._udp_limit = 1400
|
||||
self._timeout_scale = 10
|
||||
self.__network = network_if
|
||||
self.__myip = self.__network.ifconfig()[0]
|
||||
self.__myaddr = (self.__myip, port)
|
||||
self.__slave_addr = (ip, port)
|
||||
self.__tcp__socket = None
|
||||
self.__udp__socket = None
|
||||
print("IP Address:Port %s:%d\nRunning..." % self.__myaddr)
|
||||
rpc_master.__init__(self)
|
||||
|
||||
def _flush(self): # protected
|
||||
if self.__valid_udp_socket():
|
||||
try:
|
||||
self.__udp__socket.settimeout(0.001)
|
||||
while True:
|
||||
data, addr = self.__udp__socket.recvfrom(1400)
|
||||
if not len(data):
|
||||
break
|
||||
except OSError:
|
||||
self.__close_udp_socket()
|
||||
if self.__tcp__socket is not None:
|
||||
try:
|
||||
self.__tcp__socket.settimeout(0.001)
|
||||
while True:
|
||||
data = self.__tcp__socket.recv(1400)
|
||||
if not len(data):
|
||||
break
|
||||
except OSError:
|
||||
self.__close_tcp_socket()
|
||||
|
||||
def get_bytes(self, buff, timeout_ms): # protected
|
||||
i = 0
|
||||
l = len(buff)
|
||||
if l <= self._udp_limit:
|
||||
if self.__valid_udp_socket():
|
||||
try:
|
||||
self.__udp__socket.settimeout(
|
||||
self._get_short_timeout * 0.001 * self._timeout_scale
|
||||
)
|
||||
while l:
|
||||
data, addr = self.__udp__socket.recvfrom(min(l, 1400))
|
||||
data_len = len(data)
|
||||
if not data_len:
|
||||
break
|
||||
buff[i : i + data_len] = data
|
||||
i += data_len
|
||||
l -= data_len
|
||||
# We don't need to close the socket on error since it's connectionless.
|
||||
except OSError:
|
||||
self.__close_udp_socket()
|
||||
elif self.__valid_tcp_socket():
|
||||
try:
|
||||
self.__tcp__socket.settimeout(timeout_ms * 0.001)
|
||||
while l:
|
||||
data = self.__tcp__socket.recv(min(l, 1400))
|
||||
data_len = len(data)
|
||||
if not data_len:
|
||||
break
|
||||
buff[i : i + data_len] = data
|
||||
i += data_len
|
||||
l -= data_len
|
||||
if l:
|
||||
self.__close_tcp_socket()
|
||||
except OSError:
|
||||
self.__close_tcp_socket()
|
||||
return buff if not l else None
|
||||
|
||||
def put_bytes(self, data, timeout_ms): # protected
|
||||
i = 0
|
||||
l = len(data)
|
||||
if l <= self._udp_limit:
|
||||
if self.__valid_udp_socket():
|
||||
try:
|
||||
self.__udp__socket.settimeout(
|
||||
self._put_short_timeout * 0.001 * self._timeout_scale
|
||||
)
|
||||
while l:
|
||||
data_len = self.__udp__socket.sendto(
|
||||
data[i : i + min(l, 1400)], self.__slave_addr
|
||||
)
|
||||
if not data_len:
|
||||
break
|
||||
i += data_len
|
||||
l -= data_len
|
||||
if l:
|
||||
self.__close_udp_socket()
|
||||
except OSError:
|
||||
self.__close_udp_socket()
|
||||
elif self.__valid_tcp_socket():
|
||||
try:
|
||||
self.__tcp__socket.settimeout(timeout_ms * 0.001)
|
||||
while l:
|
||||
data_len = self.__tcp__socket.send(data[i : i + min(l, 1400)])
|
||||
if not data_len:
|
||||
break
|
||||
i += data_len
|
||||
l -= data_len
|
||||
if l:
|
||||
self.__close_tcp_socket()
|
||||
except OSError:
|
||||
self.__close_tcp_socket()
|
||||
|
||||
def _stream_get_bytes(self, buff, timeout_ms): # protected
|
||||
i = 0
|
||||
l = len(buff)
|
||||
if self.__valid_tcp_socket():
|
||||
try:
|
||||
self.__tcp__socket.settimeout(timeout_ms * 0.001)
|
||||
while l:
|
||||
data = self.__tcp__socket.recv(min(l, 1400))
|
||||
data_len = len(data)
|
||||
if not data_len:
|
||||
break
|
||||
buff[i : i + data_len] = data
|
||||
i += data_len
|
||||
l -= data_len
|
||||
if l:
|
||||
self.__close_tcp_socket()
|
||||
except OSError:
|
||||
self.__close_tcp_socket()
|
||||
return buff if not l else None
|
||||
|
||||
def _stream_put_bytes(self, data, timeout_ms): # protected
|
||||
i = 0
|
||||
l = len(data)
|
||||
if self.__valid_tcp_socket():
|
||||
try:
|
||||
self.__tcp__socket.settimeout(timeout_ms * 0.001)
|
||||
while l:
|
||||
data_len = self.__tcp__socket.send(data[i : i + min(l, 1400)])
|
||||
if not data_len:
|
||||
break
|
||||
i += data_len
|
||||
l -= data_len
|
||||
if l:
|
||||
self.__close_tcp_socket()
|
||||
except OSError:
|
||||
self.__close_tcp_socket()
|
||||
if l:
|
||||
raise OSError # Stop Stream.
|
||||
|
||||
|
||||
class rpc_network_slave(rpc_slave):
|
||||
def __valid_tcp_socket(self): # private
|
||||
if self.__tcp__socket is None:
|
||||
try:
|
||||
self.__tcp__socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
||||
self.__tcp__socket.connect(self.__master_addr)
|
||||
except OSError:
|
||||
self.__tcp__socket = None
|
||||
return self.__tcp__socket is not None
|
||||
|
||||
def __close_tcp_socket(self): # private
|
||||
self.__tcp__socket.close()
|
||||
self.__tcp__socket = None
|
||||
|
||||
def __valid_udp_socket(self): # private
|
||||
if self.__udp__socket is None:
|
||||
try:
|
||||
self.__udp__socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
|
||||
self.__udp__socket.bind(self.__myaddr)
|
||||
except OSError:
|
||||
self.__udp__socket = None
|
||||
return self.__udp__socket is not None
|
||||
|
||||
def __close_udp_socket(self): # private
|
||||
self.__udp__socket.close()
|
||||
self.__udp__socket = None
|
||||
|
||||
def __init__(self, network_if, port=0x1DBA): # private
|
||||
self._udp_limit = 1400
|
||||
self._timeout_scale = 10
|
||||
self.__network = network_if
|
||||
self.__myip = self.__network.ifconfig()[0]
|
||||
self.__myaddr = (self.__myip, port)
|
||||
self.__master_addr = None
|
||||
self.__tcp__socket = None
|
||||
self.__udp__socket = None
|
||||
print("IP Address:Port %s:%d\nRunning..." % self.__myaddr)
|
||||
rpc_slave.__init__(self)
|
||||
|
||||
def _flush(self): # protected
|
||||
if self.__valid_udp_socket():
|
||||
try:
|
||||
self.__udp__socket.settimeout(0.001)
|
||||
while True:
|
||||
data, addr = self.__udp__socket.recvfrom(1400)
|
||||
if not len(data):
|
||||
break
|
||||
except OSError:
|
||||
self.__close_udp_socket()
|
||||
if self.__tcp__socket is not None:
|
||||
try:
|
||||
self.__tcp__socket.settimeout(0.001)
|
||||
while True:
|
||||
data = self.__tcp__socket.recv(1400)
|
||||
if not len(data):
|
||||
break
|
||||
except OSError:
|
||||
self.__close_tcp_socket()
|
||||
|
||||
def get_bytes(self, buff, timeout_ms): # protected
|
||||
i = 0
|
||||
l = len(buff)
|
||||
if l <= self._udp_limit:
|
||||
if self.__valid_udp_socket():
|
||||
try:
|
||||
self.__udp__socket.settimeout(
|
||||
self._get_short_timeout * 0.001 * self._timeout_scale
|
||||
)
|
||||
while l:
|
||||
data, addr = self.__udp__socket.recvfrom(min(l, 1400))
|
||||
data_len = len(data)
|
||||
if not data_len:
|
||||
break
|
||||
buff[i : i + data_len] = data
|
||||
self.__master_addr = addr
|
||||
i += data_len
|
||||
l -= data_len
|
||||
# We don't need to close the socket on error since it's connectionless.
|
||||
except OSError:
|
||||
self.__close_udp_socket()
|
||||
elif self.__valid_tcp_socket():
|
||||
try:
|
||||
self.__tcp__socket.settimeout(timeout_ms * 0.001)
|
||||
while l:
|
||||
data = self.__tcp__socket.recv(min(l, 1400))
|
||||
data_len = len(data)
|
||||
if not data_len:
|
||||
break
|
||||
buff[i : i + data_len] = data
|
||||
i += data_len
|
||||
l -= data_len
|
||||
if l:
|
||||
self.__close_tcp_socket()
|
||||
except OSError:
|
||||
self.__close_tcp_socket()
|
||||
return buff if not l else None
|
||||
|
||||
def put_bytes(self, data, timeout_ms): # protected
|
||||
i = 0
|
||||
l = len(data)
|
||||
if l <= self._udp_limit:
|
||||
if self.__valid_udp_socket():
|
||||
try:
|
||||
self.__udp__socket.settimeout(
|
||||
self._put_short_timeout * 0.001 * self._timeout_scale
|
||||
)
|
||||
while l:
|
||||
data_len = self.__udp__socket.sendto(
|
||||
data[i : i + min(l, 1400)], self.__master_addr
|
||||
)
|
||||
if not data_len:
|
||||
break
|
||||
i += data_len
|
||||
l -= data_len
|
||||
if l:
|
||||
self.__close_udp_socket()
|
||||
except OSError:
|
||||
self.__close_udp_socket()
|
||||
elif self.__valid_tcp_socket():
|
||||
try:
|
||||
self.__tcp__socket.settimeout(timeout_ms * 0.001)
|
||||
while l:
|
||||
data_len = self.__tcp__socket.send(data[i : i + min(l, 1400)])
|
||||
if not data_len:
|
||||
break
|
||||
i += data_len
|
||||
l -= data_len
|
||||
if l:
|
||||
self.__close_tcp_socket()
|
||||
except OSError:
|
||||
self.__close_tcp_socket()
|
||||
|
||||
def _stream_get_bytes(self, buff, timeout_ms): # protected
|
||||
i = 0
|
||||
l = len(buff)
|
||||
if self.__valid_tcp_socket():
|
||||
try:
|
||||
self.__tcp__socket.settimeout(timeout_ms * 0.001)
|
||||
while l:
|
||||
data = self.__tcp__socket.recv(min(l, 1400))
|
||||
data_len = len(data)
|
||||
if not data_len:
|
||||
break
|
||||
buff[i : i + data_len] = data
|
||||
i += data_len
|
||||
l -= data_len
|
||||
if l:
|
||||
self.__close_tcp_socket()
|
||||
except OSError:
|
||||
self.__close_tcp_socket()
|
||||
return buff if not l else None
|
||||
|
||||
def _stream_put_bytes(self, data, timeout_ms): # protected
|
||||
i = 0
|
||||
l = len(data)
|
||||
if self.__valid_tcp_socket():
|
||||
try:
|
||||
self.__tcp__socket.settimeout(timeout_ms * 0.001)
|
||||
while l:
|
||||
data_len = self.__tcp__socket.send(data[i : i + min(l, 1400)])
|
||||
if not data_len:
|
||||
break
|
||||
i += data_len
|
||||
l -= data_len
|
||||
if l:
|
||||
self.__close_tcp_socket()
|
||||
except OSError:
|
||||
self.__close_tcp_socket()
|
||||
if l:
|
||||
raise OSError # Stop Stream.
|
||||
|
@ -6,6 +6,8 @@
|
||||
# This work is licensed under the MIT license, see the file LICENSE for details.
|
||||
#
|
||||
# ST Makefile
|
||||
override CFLAGS += -Os
|
||||
|
||||
SRCS = $(wildcard src/*.c)
|
||||
OBJS = $(addprefix $(BUILD)/, $(SRCS:.c=.o))
|
||||
OBJ_DIRS = $(sort $(dir $(OBJS)))
|
||||
|
@ -6,6 +6,8 @@
|
||||
# This work is licensed under the MIT license, see the file LICENSE for details.
|
||||
#
|
||||
# ST Makefile
|
||||
override CFLAGS += -Os
|
||||
|
||||
SRCS = $(wildcard src/*.c)
|
||||
OBJS = $(addprefix $(BUILD)/, $(SRCS:.c=.o))
|
||||
OBJ_DIRS = $(sort $(dir $(OBJS)))
|
||||
|
@ -6,6 +6,8 @@
|
||||
# This work is licensed under the MIT license, see the file LICENSE for details.
|
||||
#
|
||||
# VL53L5CX Makefile
|
||||
override CFLAGS += -Os
|
||||
|
||||
SRCS = $(wildcard src/*.c)
|
||||
OBJS = $(addprefix $(BUILD)/, $(SRCS:.c=.o))
|
||||
OBJ_DIRS = $(sort $(dir $(OBJS)))
|
||||
|
@ -29,4 +29,3 @@ freeze ("$(OMV_LIB_DIR)/", "mutex.py")
|
||||
|
||||
# Bluetooth
|
||||
require("aioble")
|
||||
freeze ("$(OMV_LIB_DIR)/", "ble_advertising.py")
|
||||
|
@ -24,4 +24,3 @@ require("logging")
|
||||
|
||||
# Bluetooth
|
||||
require("aioble")
|
||||
freeze ("$(OMV_LIB_DIR)/", "ble_advertising.py")
|
||||
|
@ -29,4 +29,3 @@ freeze ("$(OMV_LIB_DIR)/", "mutex.py")
|
||||
|
||||
# Bluetooth
|
||||
require("aioble")
|
||||
freeze ("$(OMV_LIB_DIR)/", "ble_advertising.py")
|
||||
|
@ -33,4 +33,3 @@ freeze ("$(OMV_LIB_DIR)/", "mutex.py")
|
||||
|
||||
# Bluetooth
|
||||
require("aioble")
|
||||
freeze ("$(OMV_LIB_DIR)/", "ble_advertising.py")
|
||||
|
@ -32,4 +32,3 @@ freeze ("$(OMV_LIB_DIR)/", "mutex.py")
|
||||
|
||||
# Bluetooth
|
||||
require("aioble")
|
||||
freeze ("$(OMV_LIB_DIR)/", "ble_advertising.py")
|
||||
|
@ -73,8 +73,6 @@ either expressed or implied, of the Regents of The University of Michigan.
|
||||
#define log2(x) fast_log2(x)
|
||||
#undef log2f
|
||||
#define log2f(x) fast_log2(x)
|
||||
#define sin(x) arm_sin_f32(x)
|
||||
#define cos(x) arm_cos_f32(x)
|
||||
#define fmin(a, b) ({ __typeof__ (a) _a = (a); __typeof__ (b) _b = (b); _a < _b ? _a : _b; })
|
||||
#define fminf(a, b) ({ __typeof__ (a) _a = (a); __typeof__ (b) _b = (b); _a < _b ? _a : _b; })
|
||||
#define fmax(a, b) ({ __typeof__ (a) _a = (a); __typeof__ (b) _b = (b); _a > _b ? _a : _b; })
|
||||
|
Loading…
Reference in New Issue
Block a user