autocar3g 0.1.4__tar.gz

autocar3g-0.1.4/PKG-INFO

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: autocar3g
+Version: 0.1.4
+Summary: Pop plus library for Autocar3G
+Home-page: https://github.com/hanback-lab/Autocar3G
+Author: Hanback Electronics CO. Ltd. Research Insitutue
+Author-email: lab@hanback.co.kr
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: paho-mqtt
+Requires-Dist: tensorflow>=2.5.0; platform_system != "Linux" or platform_machine != "aarch64"
+Requires-Dist: torch>=1.13.0; platform_system != "Linux" or platform_machine != "aarch64"
+Requires-Dist: ultralytics; platform_system != "Linux" or platform_machine != "aarch64"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Pop plus :: Autocar3 G
+

autocar3g-0.1.4/README.md

@@ -0,0 +1,2 @@
+# Pop plus :: Autocar3 G
+

autocar3g-0.1.4/autocar3g/AI.py

@@ -0,0 +1,201 @@
+import cv2, time, os, sys
+import numpy as np
+# import tensorrt as trt
+import atexit
+import __main__
+
+import warnings
+warnings.filterwarnings(action='ignore')
+
+IDENTIFIER="_models"
+
+mnist_train_x=None
+mnist_train_y=None
+mnist_test_x=None
+mnist_test_y=None
+
+#---------------------------------------------  Ondevice AI ---------------------------------------------
+
+def import_tensorflow():
+    global tf
+    import tensorflow as tf
+    import tensorflow.keras as __module
+    
+    for k in [m for m in dir(__module) if not "__" in m]:
+        globals()[k]=__module.__dict__[k]
+
+    import tensorflow.keras.models as __module
+    
+    for k in [m for m in dir(__module) if not "__" in m]:
+        globals()[k]=__module.__dict__[k]
+
+    import tensorflow.keras.losses as __module
+    
+    for k in [m for m in dir(__module) if not "__" in m]:
+        globals()[k]=__module.__dict__[k]
+
+    import tensorflow.keras.layers as __module
+    
+    for k in [m for m in dir(__module) if not "__" in m]:
+        globals()[k]=__module.__dict__[k]
+
+    import tensorflow.keras.optimizers as __module
+    
+    for k in [m for m in dir(__module) if not "__" in m]:
+        globals()[k]=__module.__dict__[k]
+
+    import tensorflow.keras.utils as __module
+    
+    for k in [m for m in dir(__module) if not "__" in m]:
+        globals()[k]=__module.__dict__[k]
+
+    gpus=tf.config.experimental.list_physical_devices('GPU')
+
+    for gpu in gpus:
+        tf.config.experimental.set_memory_growth(gpu, True)
+
+def bgr8_to_jpeg(value):
+    return bytes(cv2.imencode('.jpg', value)[1])
+
+from ultralytics import YOLO
+
+class Object_Follow():
+    def __init__(self, camera):
+
+        self.camera = camera
+        self.boxes_image = None
+    
+    def load_model(self, path):    
+        self.model = YOLO(path)
+    
+    def detect(self, image=None, index=None, threshold=0.5, callback=None):
+        if image is None:
+            image=self.camera.read()
+            if image is None:
+                return
+
+        if type(index)==str:
+            try:
+                index=list(self.model.names.values()).index(index)
+            except ValueError:
+                print("index is not available.")
+                return
+
+        result = self.model.predict(source=image, imgsz=640, verbose=False)[0]
+        self.boxes_image = result.plot()
+
+        width = image.shape[1]
+        height = image.shape[0]
+
+        detections = []
+        for b in result.boxes:
+            detected_index = int(b.cls[0].cpu().numpy().astype(int))
+            xywh = b.xywh[0].cpu().numpy()
+            if index is not None:
+                if detected_index != index:
+                    continue
+            detections.append({
+                'index' : detected_index,
+                'label' : self.model.names[detected_index],
+                'x' : xywh[0],
+                'y' : xywh[1],
+                'size_rate' : (xywh[2] * xywh[3]) / (width*height)
+            })
+
+        return detections
+
+import tensorflow as tf
+from tensorflow import keras
+from tensorflow.keras import *
+from tensorflow.keras.models import *
+from tensorflow.keras.losses import *
+from tensorflow.keras.layers import *
+from tensorflow.keras.optimizers import *
+from tensorflow.keras.utils import *
+from autocar3g.camera import Camera
+
+class Track_Follow_TF():
+    MODEL_PATH = 'Track_Follow.h5'
+    dataset_path = 'track_dataset'
+    BATCH_SIZE = 8
+    model=None
+    device=None
+    datasets=None
+    optimizer=None
+    prob=None
+    probWidget=None
+    STAT_DEFINED=0
+    STAT_READY=1
+    _stat=STAT_DEFINED
+
+    def __init__(self,camera:Camera):
+        self.camera = camera
+        import_tensorflow()
+        self.default_path=os.path.abspath(__file__+"/../model/Track_Follow/")
+
+    def _load_layers(self):
+        input1 = keras.layers.Input(shape=(150, 400, 3,))
+        conv1 = keras.layers.Conv2D(filters=16, kernel_size=(3, 3), strides=(2, 2), padding="same", activation="swish")(input1)
+        norm1 = keras.layers.BatchNormalization()(conv1)
+        pool1 = keras.layers.MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(norm1)
+        conv2 = keras.layers.Conv2D(filters=32, kernel_size=(3, 3), strides=(2, 2), padding="same", activation="swish")(pool1)
+        norm2 = keras.layers.BatchNormalization()(conv2)
+        conv3 = keras.layers.Conv2D(filters=32, kernel_size=(3, 3), strides=(1, 1), padding="same", activation="swish")(norm2)
+        norm3 = keras.layers.BatchNormalization()(conv3)
+        add1 = keras.layers.Add()([norm2, norm3])
+        conv4 = keras.layers.Conv2D(filters=64, kernel_size=(3, 3), strides=(2, 2), padding="same", activation="swish")(add1)
+        norm4 = keras.layers.BatchNormalization()(conv4)
+        conv5 = keras.layers.Conv2D(filters=64, kernel_size=(3, 3), strides=(1, 1), padding="same", activation="swish")(norm4)
+        norm5 = keras.layers.BatchNormalization()(conv5)
+        add2 = keras.layers.Add()([norm4, norm5])
+        conv6 = keras.layers.Conv2D(filters=128, kernel_size=(3, 3), strides=(2, 2), padding="same", activation="swish")(add2)
+        norm6 = keras.layers.BatchNormalization()(conv6)
+        conv7 = keras.layers.Conv2D(filters=128, kernel_size=(3, 3), strides=(1, 1), padding="same", activation="swish")(norm6)
+        norm7 = keras.layers.BatchNormalization()(conv7)
+        add3 = keras.layers.Add()([norm6, norm7])
+        conv8 = keras.layers.Conv2D(filters=256, kernel_size=(3, 3), strides=(2, 2), padding="same", activation="swish")(add3)
+        norm7 = keras.layers.BatchNormalization()(conv8)
+        conv9 = keras.layers.Conv2D(filters=512, kernel_size=(3, 3), strides=(2, 2), padding="same", activation="swish")(norm7)
+        norm8 = keras.layers.BatchNormalization()(conv9)
+        flat1 = keras.layers.Flatten()(norm8)
+        dense1 = keras.layers.Dense(128, activation="swish")(flat1)
+        norm9 = keras.layers.BatchNormalization()(dense1)
+        dense2 = keras.layers.Dense(64, activation="swish")(norm9)
+        norm10 = keras.layers.BatchNormalization()(dense2)
+        dense3 = keras.layers.Dense(64, activation="swish")(norm10)
+        norm11 = keras.layers.BatchNormalization()(dense3)
+        dense4 = keras.layers.Dense(2, activation="sigmoid")(norm11)
+        self.model = keras.models.Model(inputs=input1, outputs=dense4)
+
+    def load_model(self,path=MODEL_PATH):
+        if not os.path.exists(path):
+            print(path," doesn't exist.")
+            return
+
+        if self.model is None:
+            self._load_layers()
+            decay=schedules.ExponentialDecay(1.0e-04, decay_steps=800, decay_rate=0.96, staircase=True)
+            adam=Adam(learning_rate=decay, beta_1=0.9, beta_2=0.999, epsilon=1e-07, amsgrad=False)
+            self.model.compile(optimizer=adam, loss='MAE')
+
+        self.model.load_weights(path)
+
+    def run(self, value=None, callback=None):
+        if self.model is None :
+            print("Please load datasets as load_datasets() method or load a trained model as load_model() method.")
+            return
+
+        img = self.camera.read()[120:270,:] if value is None else value
+        x, y = self.model(np.array([img]).astype(np.float32)).numpy()[0]
+        height, width, _ = img.shape
+        cX = int(width * (x))
+        cY = int(height * (y))
+
+        self.value = cv2.circle(img, (cX, cY), 6, (255, 255, 255), 2)
+
+        result={"x":x,"y":y}
+
+        if callback is not None:
+            callback(result)
+
+        return result

autocar3g-0.1.4/autocar3g/absclient.py

@@ -0,0 +1,72 @@
+import paho.mqtt.client as mqtt
+from threading import Thread, Lock, Event
+import time, os, signal, traceback
+
+product_file_path = "product"
+
+TIMEOUT_SEC = 5
+
+class AbstractPopClient:
+    with open(product_file_path, 'r') as file:
+        BROKER_DOMAIN = None
+        DEV_NUM = None
+        DEV_NAME = None
+        INSITUTION_NAME = None
+        for line in file:
+            line = line.strip()
+            if line.startswith('BROKER_DOMAIN='):
+                BROKER_DOMAIN = line.split('=')[1].strip()
+            if line.startswith('DEV_NUM='):
+                DEV_NUM = line.split('=')[1].strip()
+            if line.startswith('DEVICE_NAME='):
+                DEV_NAME = line.split('=')[1].strip()
+            if line.startswith('INSITUTION_NAME='):
+                INSITUTION_NAME = line.split('=')[1].strip()
+        if BROKER_DOMAIN is None:
+            raise ValueError("[Error] There is no product file. Please make sure the device has product info")
+
+    def __init__(self):
+        self.__update_lock = Lock()
+        self.__update_time_tag = time.time()
+        self.__close_event = Event()
+
+        self._TOPIC_HEADER = __class__.DEV_NAME + '/' + __class__.INSITUTION_NAME + __class__.DEV_NUM
+        self._client = mqtt.Client()
+        self._client.on_connect = self._on_connect
+        self._client.on_message = self._on_message
+        self._client.connect(__class__.BROKER_DOMAIN)
+        self._client_enabled = False
+        self._client.loop_start()
+
+        wait_time_tag = time.time()
+        while not self._client_enabled:
+            if time.time() - wait_time_tag > 4:
+                raise TimeoutError("Please check the broker connection state.")
+
+    def __connection_check(self):
+        try:
+            while True:
+                if self.__close_event.set():
+                    break
+                self.__update_lock.acquire()
+                if time.time() - self.__update_time_tag > TIMEOUT_SEC:
+                    raise ConnectionError()
+                self.__update_lock.release()
+                time.sleep(1)
+        except ConnectionError:
+            traceback.print_exc()
+            os.kill(os.getpid(), signal.SIGINT)
+            
+    def _on_connect(self, client, userdata, flags, rc):
+        self.__connection_check_thread = Thread(target=self.__connection_check, daemon=True)
+        self.__connection_check_thread.start()
+        self._client_enabled = True
+
+    def _on_message(self, client, userdata, message):
+        self.__update_lock.acquire()
+        self.__update_time_tag = time.time()
+        self.__update_lock.release()
+        self._decode(message)
+
+    def _decode(self, message):
+        raise NotImplementedError()

autocar3g-0.1.4/autocar3g/camera.py

@@ -0,0 +1,170 @@
+import socket
+import struct
+import logging
+import time
+import threading
+
+import cv2
+import numpy as np
+
+logger = logging.getLogger(__name__)
+
+MAX = 1400
+TO = 2.0
+HDR_FMT = ">IHHQI"
+HDR_SIZE = struct.calcsize(HDR_FMT)
+
+SERVER_PORT = 5000
+
+class Camera:
+    with open("product", 'r') as file:
+        SERVER_IP = None
+        for line in file:
+            line = line.strip()
+            if line.startswith('CAMERA_DOMAIN='):
+                SERVER_IP = line.split('=')[1].strip()
+        if SERVER_IP is None:
+            raise "[Error] There is no product file. Please make sure the device has product info"
+
+    def __init__(self, server_ip=SERVER_IP, server_port=SERVER_PORT, client_port=None, start_timeout=5.0, no_data_timeout=5.0):
+        self.server_ip = server_ip
+        self.server_port = server_port
+        self.client_port = client_port
+
+        self.start_timeout = start_timeout
+        self.no_data_timeout = no_data_timeout
+
+        self._sock = None
+        self._thread = None
+        self._running = threading.Event()
+
+        self._last_frame = None
+        self._last_frame_id = None
+        self._lock = threading.Lock()
+
+        self._first_frame_event = threading.Event()
+
+    def start(self):
+        if self._running.is_set():
+            return
+        self._sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        self._sock.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 1 << 20)
+        if self.client_port is None:
+            self._sock.bind(("", 0))
+            self.client_port = self._sock.getsockname()[1]
+        else:
+            self._sock.bind(("", self.client_port))
+        self._sock.settimeout(1.0)
+        self._running.set()
+        self._first_frame_event.clear()
+        try:
+            self._sock.sendto(b"HELLO", (self.server_ip, self.server_port))
+        except Exception as e:
+            logger.error("failed to send HELLO: %s", e)
+        self._thread = threading.Thread(target=self._recv_loop, daemon=True)
+        self._thread.start()
+        logger.info("Camera started on port %d", self.client_port)
+        if not self._first_frame_event.wait(timeout=self.start_timeout):
+            logger.error("no frame received within %.1f seconds after start", self.start_timeout)
+            self.stop()
+            raise RuntimeError("no frame received from server")
+
+    def stop(self):
+        if not self._running.is_set():
+            return
+        self._running.clear()
+        if self._sock is not None:
+            try:
+                self._sock.sendto(b"BYE", (self.server_ip, self.server_port))
+            except Exception:
+                pass
+            try:
+                self._sock.close()
+            except Exception:
+                pass
+            self._sock = None
+        if self._thread is not None:
+            self._thread.join(timeout=2.0)
+            self._thread = None
+        logger.info("Camera stopped")
+
+    def _recv_loop(self):
+        fbuf = {}
+        frame_count = 0
+        last_data_time = time.time()
+        while self._running.is_set():
+            now = time.time()
+            if now - last_data_time > self.no_data_timeout:
+                logger.error("no camera data for %.1f seconds, stopping client", self.no_data_timeout)
+                self._running.clear()
+                break
+            try:
+                try:
+                    d, _ = self._sock.recvfrom(MAX)
+                except socket.timeout:
+                    now = time.time()
+                    drop = [k for k, v in fbuf.items() if now - v["t"] > TO]
+                    for k in drop:
+                        del fbuf[k]
+                    continue
+            except OSError:
+                break
+            last_data_time = time.time()
+            if len(d) < HDR_SIZE:
+                continue
+            try:
+                fid, idx, tot, ts_us, size = struct.unpack(HDR_FMT, d[:HDR_SIZE])
+            except struct.error:
+                continue
+            pay = d[HDR_SIZE:]
+            f = fbuf.get(fid)
+            if f is None:
+                f = {"t": time.time(), "tot": tot, "p": {}, "ts": ts_us, "sz": size}
+                fbuf[fid] = f
+            f["p"][idx] = pay
+            if len(f["p"]) == f["tot"]:
+                try:
+                    j = b"".join(f["p"][i] for i in range(f["tot"]))
+                except KeyError:
+                    del fbuf[fid]
+                    continue
+                if len(j) != f["sz"]:
+                    logger.warning("size mismatch frame=%d expected=%d got=%d", fid, f["sz"], len(j))
+                a = np.frombuffer(j, np.uint8)
+                img = cv2.imdecode(a, cv2.IMREAD_COLOR)
+                if img is not None:
+                    with self._lock:
+                        self._last_frame = img
+                        self._last_frame_id = fid
+                    if not self._first_frame_event.is_set():
+                        self._first_frame_event.set()
+                    frame_count += 1
+                    if frame_count % 100 == 0:
+                        logger.info("received frame=%d", fid)
+                del fbuf[fid]
+
+    def read(self, copy=True):
+        with self._lock:
+            if self._last_frame is None:
+                return None
+            if copy:
+                return self._last_frame.copy()
+            return self._last_frame
+
+
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
+    client = Camera()
+    try:
+        client.start()
+    except RuntimeError as e:
+        logger.error("failed to start client: %s", e)
+    else:
+        try:
+            while True:
+                frame = client.read()
+                time.sleep(0.01)
+        except KeyboardInterrupt:
+            pass
+        finally:
+            client.stop()

autocar3g-0.1.4/autocar3g/driving.py

@@ -0,0 +1,47 @@
+import struct
+import time
+from autocar3g.absclient import AbstractPopClient
+
+class Driving(AbstractPopClient):
+    def __init__(self, wait=True):
+        super().__init__()
+        self._client.subscribe(self._TOPIC_HEADER + '/drive/steering')
+        self._client.subscribe(self._TOPIC_HEADER + '/drive/throttle')
+        self._client.subscribe(self._TOPIC_HEADER+'/int')
+        self.__steering_value = None
+        self.__throttle_value = None
+        self.__wait = wait
+
+    def _decode(self, message):
+        if 'steering' in message.topic:
+            self.__steering_value = struct.unpack("<f", message.payload)[0]
+        elif 'throttle' in message.topic:
+            self.__throttle_value = struct.unpack("<i", message.payload)[0]
+        else:
+            print(message.payload)
+
+    @property
+    def steering(self):
+        while self.__steering_value is None and self.__wait: time.sleep(0.01)
+        value = self.__steering_value
+        self.__steering_value = None
+        return value
+
+    @steering.setter
+    def steering(self, value:float):
+        if value < -1.0 or value > 1.0:
+            raise ValueError("Wrong steering value.")
+        self._client.publish(self._TOPIC_HEADER+"/drive/set", struct.pack('<fi', value, self.throttle), 0)
+
+    @property
+    def throttle(self):
+        while self.__throttle_value is None and self.__wait: time.sleep(0.01)
+        value = self.__throttle_value
+        self.__throttle_value = None
+        return value
+
+    @throttle.setter
+    def throttle(self, value:int):
+        if value < -99 or value > 99:
+            raise ValueError("Wrong throttle value.")
+        self._client.publish(self._TOPIC_HEADER+"/drive/set", struct.pack('<fi', self.steering, value), 0)

autocar3g-0.1.4/autocar3g/encoder.py

@@ -0,0 +1,19 @@
+import struct
+import time
+from autocar3g.absclient import AbstractPopClient
+
+class Encoder(AbstractPopClient):
+    def __init__(self, wait=True):
+        super().__init__()
+        self._client.subscribe(self._TOPIC_HEADER + '/encoder')
+        self.__value = None
+        self.__wait = wait
+
+    def _decode(self, message):
+        self.__value = tuple(struct.unpack("<ii", message.payload))
+
+    def read(self):
+        while self.__value is None and self.__wait: time.sleep(0.01)
+        value = self.__value
+        self.__value = None
+        return value

autocar3g-0.1.4/autocar3g/imu.py

@@ -0,0 +1,55 @@
+import struct
+import math
+import time
+from .absclient import AbstractPopClient
+
+class Imu(AbstractPopClient):
+    def __init__(self, wait=True):
+        super().__init__()
+        self._client.subscribe(self._TOPIC_HEADER + '/imu')
+        self.__accel_value = None
+        self.__gyro_value = None
+        self.__quat_value = None
+        self.__wait = wait
+
+    def _decode(self, message):
+        unpacked = struct.unpack('<10d', message.payload)
+        self.__accel_value = tuple(unpacked[0:3])
+        self.__gyro_value = tuple(unpacked[3:6])
+        self.__quat_value = tuple(unpacked[6:10])
+
+    def accel(self):
+        while self.__accel_value is None and self.__wait : time.sleep(0.01)
+        value = self.__accel_value
+        # self.__accel_value = None
+        return value
+    
+    def gyro(self):
+        while self.__gyro_value is None and self.__wait : time.sleep(0.01)
+        value = self.__gyro_value
+        # self.__gyro_value = None
+        return value
+    
+    def euler(self):
+        w,x,y,z = self.quat()
+        
+        t0 = +2.0 * (w*x + y*z)
+        t1 = +1.0 - 2.0 * (x*x + y*y)
+        roll = math.atan2(t0, t1)
+
+        t2 = +2.0 * (w*y - z*x)
+        t2 = +1.0 if t2 > +1.0 else t2
+        t2 = -1.0 if t2 < -1.0 else t2
+        pitch = math.asin(t2)
+
+        t3 = +2.0 * (w*z + x*y)
+        t4 = +1.0 - 2.0 * (y*y + z*z)
+        yaw = math.atan2(t3, t4)
+
+        return (roll, pitch, yaw)
+
+    def quat(self):
+        while self.__quat_value is None and self.__wait : time.sleep(0.01)
+        value = self.__quat_value
+        self.__quat_value = None
+        return value

autocar3g-0.1.4/autocar3g/led.py

@@ -0,0 +1,17 @@
+import struct
+import time
+from autocar3g.absclient import AbstractPopClient
+
+class Led(AbstractPopClient):
+    def __init__(self, wait=True):
+        super().__init__()
+        self._client.subscribe(self._TOPIC_HEADER + '/drive/steering')
+
+    def _decode(self, message):
+        pass
+
+    def onoff(self, front, rear):
+        value = 0
+        value += 1 if front else 0
+        value += 2 if rear else 0
+        self._client.publish(self._TOPIC_HEADER+"/lamp/set", struct.pack('<i', value), 0)

autocar3g-0.1.4/autocar3g/lidar.py

@@ -0,0 +1,36 @@
+import struct
+import math
+import time
+from autocar3g.absclient import AbstractPopClient
+
+class LiDAR(AbstractPopClient):
+    def __init__(self, wait=True):
+        super().__init__()
+        self._client.subscribe(self._TOPIC_HEADER + '/scan')
+        self.__value = None
+        self.__wait = wait
+
+    def _decode(self, message):
+        header_ffi = '<ffI'
+        header_size = struct.calcsize(header_ffi)
+
+        angle_min, angle_increment, n = struct.unpack(
+            header_ffi, message.payload[:header_size]
+        )
+
+        ranges_fmt = '<{}f'.format(n)
+        ranges = struct.unpack(
+            ranges_fmt, message.payload[header_size:]
+        )
+
+        self.__value = {
+            'angle_min' : angle_min,
+            'angle_increment' : angle_increment,
+            'ranges' : ranges
+        }
+
+    def read(self):
+        while self.__value is None and self.__wait : time.sleep(0.01)
+        value = self.__value
+        self.__value = None
+        return value

autocar3g-0.1.4/autocar3g/ultrasonic.py

@@ -0,0 +1,19 @@
+import struct
+import time
+from autocar3g.absclient import AbstractPopClient
+
+class Ultrasonic(AbstractPopClient):
+    def __init__(self, wait=True):
+        super().__init__()
+        self._client.subscribe(self._TOPIC_HEADER + '/ultra')
+        self.__value = None
+        self.__wait = wait
+
+    def _decode(self, message):
+        self.__value = tuple(struct.unpack("<ii", message.payload))
+
+    def read(self):
+        while self.__value is None and self.__wait: time.sleep(0.01)
+        value = self.__value
+        self.__value = None
+        return value

autocar3g-0.1.4/autocar3g.egg-info/PKG-INFO

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: autocar3g
+Version: 0.1.4
+Summary: Pop plus library for Autocar3G
+Home-page: https://github.com/hanback-lab/Autocar3G
+Author: Hanback Electronics CO. Ltd. Research Insitutue
+Author-email: lab@hanback.co.kr
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: paho-mqtt
+Requires-Dist: tensorflow>=2.5.0; platform_system != "Linux" or platform_machine != "aarch64"
+Requires-Dist: torch>=1.13.0; platform_system != "Linux" or platform_machine != "aarch64"
+Requires-Dist: ultralytics; platform_system != "Linux" or platform_machine != "aarch64"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Pop plus :: Autocar3 G
+

autocar3g-0.1.4/autocar3g.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+README.md
+setup.py
+autocar3g/AI.py
+autocar3g/__init__.py
+autocar3g/absclient.py
+autocar3g/camera.py
+autocar3g/driving.py
+autocar3g/encoder.py
+autocar3g/imu.py
+autocar3g/led.py
+autocar3g/lidar.py
+autocar3g/ultrasonic.py
+autocar3g.egg-info/PKG-INFO
+autocar3g.egg-info/SOURCES.txt
+autocar3g.egg-info/dependency_links.txt
+autocar3g.egg-info/requires.txt
+autocar3g.egg-info/top_level.txt

autocar3g-0.1.4/autocar3g.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

autocar3g-0.1.4/autocar3g.egg-info/requires.txt

@@ -0,0 +1,6 @@
+paho-mqtt
+
+[:platform_system != "Linux" or platform_machine != "aarch64"]
+tensorflow>=2.5.0
+torch>=1.13.0
+ultralytics

autocar3g-0.1.4/autocar3g.egg-info/top_level.txt

@@ -0,0 +1 @@
+autocar3g

autocar3g-0.1.4/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

autocar3g-0.1.4/setup.py

@@ -0,0 +1,28 @@
+from setuptools import setup, find_packages
+
+with open("README.md", "r") as fh:
+    long_description = fh.read()
+
+setup(
+    name="autocar3g", # Replace with your own username
+    version="0.1.4",
+    author="Hanback Electronics CO. Ltd. Research Insitutue",
+    author_email="lab@hanback.co.kr",
+    description="Pop plus library for Autocar3G",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/hanback-lab/Autocar3G",
+    packages=find_packages(),
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    install_requires=[
+        'paho-mqtt',
+        'tensorflow>=2.5.0; platform_system != "Linux" or platform_machine != "aarch64"',
+        'torch>=1.13.0; platform_system != "Linux" or platform_machine != "aarch64"',
+        'ultralytics; platform_system != "Linux" or platform_machine != "aarch64"'
+    ],
+    python_requires='>=3.8',
+)