Hello, We recently bought a AK-FFC 4P module. We want to be able to run uart script in standalone mode. We ran the uart scirpt (from the example folder) in "normal" mode with a computer and scoped the uart GPIO with an oscilloscope, and we were able to validate that it works. So then we tried to use this script in standalone mode. To do that, we used this [page](https://docs.luxonis.com/projects/api/en/latest/tutorials/standalone_mode/). We flashed the bootloader. And tried to modify the uart script to match the expected structure for the standalone mode. So we modified the script from : `#!/usr/bin/env python3` `'''` `NOTE: This should only be run on OAK-FFC-4P, as other OAK cameras might have different GPIO configuration!` `'''` `import depthai as dai` `import time` `# Start defining a pipeline` `pipeline = dai.Pipeline()` `script = pipeline.create(dai.node.Script)` `script.setScript("""` ` import serial` ` import time` ` ser = serial.Serial("/dev/ttyS0", baudrate=115200)` ` i = 0` ` while True:` ` i += 1` ` time.sleep(0.1)` ` serString = f'TEST_{i}'` ` ser.write(serString.encode())` `""")` `# Define script for output` `script.setProcessor(dai.ProcessorType.LEON_CSS)` `config = dai.Device.Config()` `# Get argument first` `GPIO = dai.BoardConfig.GPIO` `config.board.gpio[15] = GPIO(GPIO.OUTPUT, GPIO.ALT_MODE_2)` `config.board.gpio[16] = GPIO(GPIO.INPUT, GPIO.ALT_MODE_2)` `config.board.uart[0] = dai.BoardConfig.UART()` `with dai.Device(config) as device:` ` device.startPipeline(pipeline)` ` print("Pipeline started")` ` while True:` ` time.sleep(1)` to this : `#!/usr/bin/env python3` `'''` `NOTE: This should only be run on OAK-FFC-4P, as other OAK cameras might have different GPIO configuration!` `'''` `import depthai as dai` `import time` `# Start defining a pipeline` `pipeline = dai.Pipeline()` `script = pipeline.create(dai.node.Script)` `script.setScript("""` ` import serial` ` import time` ` ser = serial.Serial("/dev/ttyS0", baudrate=115200)` ` i = 0` ` while True:` ` i += 1` ` time.sleep(0.1)` ` serString = f'TEST_{i}'` ` ser.write(serString.encode())` `""")` `# Define script for output` `script.setProcessor(dai.ProcessorType.LEON_CSS)` `config = dai.Device.Config()` `# Get argument first` `GPIO = dai.BoardConfig.GPIO` `config.board.gpio[15] = GPIO(GPIO.OUTPUT, GPIO.ALT_MODE_2)` `config.board.gpio[16] = GPIO(GPIO.INPUT, GPIO.ALT_MODE_2)` `config.board.uart[0] = dai.BoardConfig.UART()` `# Flash the pipeline` `(f, bl) = dai.DeviceBootloader.getFirstAvailableDevice()` `bootloader = dai.DeviceBootloader(bl)` `progress = lambda p : print(f'Flashing progress: {p*100:.1f}%')` `bootloader.flash(progress, pipeline)` We ran it, wait until the flash complete, rebooted the board. But we were not able to see uart data on the oscilloscope. 1\. Do you think we modified the code correctly to run in standalone mode, or did we make a mistake ? 2\. How to be sure that the pipeline is well flashed in the memory and is running on boot since we can not have logs ? Do you have a basic example which for example blinks a led or something like that which would allow us to properly verify that a pipeline is indeed operating? Thank you very much.

Hi @"GuillaumeHupi"#2680 1. The pipeline you have uploaded doesn't know you have enabled the uart, so no signal comes through. You need to modify your code to: ``` config = dai.Device.Config() # Get argument first GPIO = dai.BoardConfig.GPIO config.board.gpio[15] = GPIO(GPIO.OUTPUT, GPIO.ALT_MODE_2) config.board.gpio[16] = GPIO(GPIO.INPUT, GPIO.ALT_MODE_2) config.board.uart[0] = dai.BoardConfig.UART() pipeline.setBoardConfig(config.board) # set the config to pipeline object with dai.Device(pipeline) as device: print("Pipeline started") while True: time.sleep(1) ``` 2. You can't know for sure unless you log the data on FLASH and then read from it. You can check if it is working via UART (I can confirm the code works). Thanks, Jaka

Hi @"jakaskerl"#p22695 Thank you for your answer ! I added the `pipeline.setBoardConfig(config.board) # set the config to pipeline object` line inside my code, but not the part with the while loop since it is a standalone mode and would never reach the bootloader flashing part. So my final code is : `#!/usr/bin/env python3'''` `NOTE: This should only be run on OAK-FFC-4P, as other OAK cameras might have different GPIO configuration!` `'''` `import depthai as dai` `import time` `# Start defining a pipeline` `pipeline = dai.Pipeline()` `script = pipeline.create(dai.node.Script)` `script.setScript("""` ` import serial` ` import time` ` ser = serial.Serial("/dev/ttyS0", baudrate=115200)` ` i = 0` ` while True:` ` i += 1` ` time.sleep(0.1)` ` serString = f'TEST_{i}'` ` ser.write(serString.encode())` `""")` `# Define script for output` `script.setProcessor(dai.ProcessorType.LEON_CSS)` `config = dai.Device.Config()` `# Get argument first` `GPIO = dai.BoardConfig.GPIO` `config.board.gpio[15] = GPIO(GPIO.OUTPUT, GPIO.ALT_MODE_2)` `config.board.gpio[16] = GPIO(GPIO.INPUT, GPIO.ALT_MODE_2)` `config.board.uart[0] = dai.BoardConfig.UART()` `pipeline.setBoardConfig(config.board) # set the config to pipeline object` `# Flash the pipeline` `(f, bl) = dai.DeviceBootloader.getFirstAvailableDevice()` `bootloader = dai.DeviceBootloader(bl)` `progress = lambda p : print(f'Flashing progress: {p*100:.1f}%')` `bootloader.flash(progress, pipeline)` (btw, do you have any tips for formatting the code on the forum? I had to redo all the newlines by hand so that the code appeared in a single block unlike the first messages, but the indentation on the other hand was skipped.) And like this, it is working as expected thank you! Saving logs on Flash could be useful later if we need to do debugging in standalone mode. How do I save data on flash? Is there a tutorial somewhere? Thanks, Guillaume

@"GuillaumeHupi"#p22787 Uh, yes thanks, I copied the wrong code part :/. You can create code blocks using ``` on both sides of the code. Should be similar to this: https://docs.luxonis.com/projects/api/en/latest/samples/Script/script_emmc_access/ but for NOR flash. Keep in mind the storage is extremely limited (16MB on my board), which pretty much gets taken up by the FW and bootloader. Since the board also has EMMC, I'd suggest storing logs there, but we need to enable EMMC for USB devices (currently only works on POE mode). Thanks, Jaka

@"jakaskerl"#p22792 Oh Ok thank you ! My AK-FFC 4P has a SD card slot. Would it be possible to save logs on SD card instead of EMMC ? Should we use a similar script than EMMC but replace "/media/mmcsd-0-0/" by an other media path ? Thanks, Guillaume

@"GuillaumeHupi"#p22793 Yes, https://github.com/luxonis/depthai-python/tree/sdcard_no_eth_updated on this branch, the SD should work. Path is the same. https://github.com/luxonis/depthai-python/blob/sdcard_no_eth_updated/examples/Script/script_jpeg_to_sdcard.py Thanks, Jaka

@"jakaskerl"#p22803 OK thanks! I don't think we'll use it right away, but I'll save it for later. Thank you very much for all your answers, it helps us a lot! Have a nice day! Guillaume

Hello again, I try to adapt the [object tracker script](https://github.com/luxonis/depthai-python/blob/main/examples/ObjectTracker/object_tracker.py) to run as standalone. But I'm not sure on how to do it. I tried to comment the whole part with ``` with dai.Device(pipeline) as device: ``` And to add this just before : ``` (f, bl) = dai.DeviceBootloader.getFirstAvailableDevice() bootloader = dai.DeviceBootloader(bl) progress = lambda p : print(f'Flashing progress: {p*100:.1f}%') bootloader.flash(progress, pipeline) ``` But when I execute it, in terminal, the progress bar remains at 0% during few seconds and then the script stops without having flashed the pipeline. I tried many different things but I always got the same behavior. I think I'm not adapting the script well so that it works standalone but I don't know how to do it. I hope you can help me. Thank you

@"GuillaumeHupi"#p25768 use ``` (f, bl) = dai.DeviceBootloader.getFirstAvailableDevice() bootloader = dai.DeviceBootloader(bl) progress = lambda p : print(f'Flashing progress: {p*100:.1f}%') (r, errmsg) = bootloader.flash(progress, pipeline, memory=dai.DeviceBootloader.Memory.EMMC) if r: print("Flash OK") ``` To get errors logged. Thanks, Jaka

@"jakaskerl"#p25789 Ok thank you for the tip. So I got the error "No eMMC memory available". I tried to add eMMC configuration inside my script by adding : ``` # Set board config board = dai.BoardConfig() board.emmc = True config = dai.Device.Config() config.board = board pipeline.setBoardConfig(board) ``` So my script is like this : ``` #!/usr/bin/env python3 from pathlib import Path import cv2 import depthai as dai import numpy as np import time import argparse labelMap = ["background", "aeroplane", "bicycle", "bird", "boat", "bottle", "bus", "car", "cat", "chair", "cow", "diningtable", "dog", "horse", "motorbike", "person", "pottedplant", "sheep", "sofa", "train", "tvmonitor"] nnPathDefault = str((Path(__file__).parent / Path('../models/mobilenet-ssd_openvino_2021.4_6shave.blob')).resolve().absolute()) parser = argparse.ArgumentParser() parser.add_argument('nnPath', nargs='?', help="Path to mobilenet detection network blob", default=nnPathDefault) parser.add_argument('-ff', '--full_frame', action="store_true", help="Perform tracking on full RGB frame", default=False) args = parser.parse_args() fullFrameTracking = args.full_frame # Create pipeline pipeline = dai.Pipeline() # Define sources and outputs camRgb = pipeline.create(dai.node.ColorCamera) detectionNetwork = pipeline.create(dai.node.MobileNetDetectionNetwork) objectTracker = pipeline.create(dai.node.ObjectTracker) xlinkOut = pipeline.create(dai.node.XLinkOut) trackerOut = pipeline.create(dai.node.XLinkOut) xlinkOut.setStreamName("preview") trackerOut.setStreamName("tracklets") # Properties camRgb.setPreviewSize(300, 300) camRgb.setResolution(dai.ColorCameraProperties.SensorResolution.THE_1080_P) camRgb.setInterleaved(False) camRgb.setColorOrder(dai.ColorCameraProperties.ColorOrder.BGR) camRgb.setFps(40) # testing MobileNet DetectionNetwork detectionNetwork.setBlobPath(args.nnPath) detectionNetwork.setConfidenceThreshold(0.5) detectionNetwork.input.setBlocking(False) objectTracker.setDetectionLabelsToTrack([15,7]) # track only person # possible tracking types: ZERO_TERM_COLOR_HISTOGRAM, ZERO_TERM_IMAGELESS, SHORT_TERM_IMAGELESS, SHORT_TERM_KCF objectTracker.setTrackerType(dai.TrackerType.ZERO_TERM_COLOR_HISTOGRAM) # take the smallest ID when new object is tracked, possible options: SMALLEST_ID, UNIQUE_ID objectTracker.setTrackerIdAssignmentPolicy(dai.TrackerIdAssignmentPolicy.SMALLEST_ID) # Linking camRgb.preview.link(detectionNetwork.input) objectTracker.passthroughTrackerFrame.link(xlinkOut.input) if fullFrameTracking: camRgb.video.link(objectTracker.inputTrackerFrame) else: detectionNetwork.passthrough.link(objectTracker.inputTrackerFrame) detectionNetwork.passthrough.link(objectTracker.inputDetectionFrame) detectionNetwork.out.link(objectTracker.inputDetections) objectTracker.out.link(trackerOut.input) # Set board config board = dai.BoardConfig() board.emmc = True config = dai.Device.Config() config.board = board pipeline.setBoardConfig(board) (f, bl) = dai.DeviceBootloader.getFirstAvailableDevice() bootloader = dai.DeviceBootloader(bl) progress = lambda p : print(f'Flashing progress: {p*100:.1f}%') (r, errmsg) = bootloader.flash(progress, pipeline, memory=dai.DeviceBootloader.Memory.EMMC) if r: print("Flash OK") else : print(errmsg) ``` But I got the same error. I think the board I use (**OAK-FFC 4P**) has no eMMC. I couldn't find it mentioned in the docs and I tried to checked the bootloader version I got this and I can not see eMMC informations : ``` Found device with name: 1.1.2 Version: 0.0.27 USB Bootloader - supports only Flash memory Memory 'Memory.FLASH' size: 33554432, info: JEDEC ID: 20 BB 19 ``` But I don't understand why I am able to flash this script : ``` #!/usr/bin/env python3 ''' NOTE: This should only be run on OAK-FFC-4P, as other OAK cameras might have different GPIO configuration! ''' import depthai as dai import time # Start defining a pipeline pipeline = dai.Pipeline() script = pipeline.create(dai.node.Script) script.setScript(""" import serial import time ser = serial.Serial("/dev/ttyS0", baudrate=115200) i = 0 while True: i += 1 time.sleep(0.1) serString = f'TEST_{i}' ser.write(serString.encode()) """) # Define script for output script.setProcessor(dai.ProcessorType.LEON_CSS) config = dai.Device.Config() # Get argument first GPIO = dai.BoardConfig.GPIO config.board.gpio[15] = GPIO(GPIO.OUTPUT, GPIO.ALT_MODE_2) config.board.gpio[16] = GPIO(GPIO.INPUT, GPIO.ALT_MODE_2) config.board.uart[0] = dai.BoardConfig.UART() pipeline.setBoardConfig(config.board) # set the config to pipeline object # Flash the pipeline (f, bl) = dai.DeviceBootloader.getFirstAvailableDevice() bootloader = dai.DeviceBootloader(bl) progress = lambda p : print(f'Flashing progress: {p*100:.1f}%') bootloader.flash(progress, pipeline) ``` And not the object-tracker one.

Hi @"GuillaumeHupi"#p25795 FFC-4P should have the EMMC, but I think you might be using an old bootloader or no bootloader at all. First, use device_manager.py script to flash a bootloader onto it (USB bootloader - via DANGER ZONE tab). Then rerun the script and EMMC should show up. It is physically present on the board on OAK-SOM-Pro. Thanks, Jaka

Unable to run uart script in standalone mode

jakaskerl

Hi @GuillaumeHupi
I don't have access to a r7 FFC-4P, will try to get my hands on one, then report back.

EDIT:
You are correct, the rev7 disables the USB stack when NETWORK bootloader is flashed. Forwarded to FW team.
Will ping you when this has been resolved.

Thanks,
Jaka

GuillaumeHupi

Hi jakaskerl

Ok thank you very much !

« Previous Page