Community outside unmanned delivery method and system based on internal security authentication

Abstract

The application provides a community outside unmanned delivery method and system based on internal security authentication, a community outside unmanned delivery system based on internal security authentication, constructs a "perception-transmission-processing-execution-user" full-link collaborative architecture, and solves three problems of "external robot without repeated authentication entering a community", "one-kilometer range accurate scheduling" and "internal and external permission linkage". The "cloud-edge-end" collaborative architecture is adopted to realize full-process automation of "order initiation-supermarket warehousing-robot scheduling-community entry-unit delivery-user pickup". Through "internal linkage authentication", repeated permission recognition of the robot entering the community from the outside is realized, genetic algorithm is combined to optimize task scheduling, A* algorithm is improved to optimize path planning, and the delivery efficiency and safety are improved. Part of the functions of traditional takeout (community delivery within one kilometer) is replaced, automation and precision of community delivery are realized, and more convenient and safer delivery services are provided for users.

Description

Technical Field

[0001] This invention relates to the field of food delivery technology, and in particular to an unmanned delivery method outside the community based on internal security authentication, as well as an unmanned delivery system, electronic device, and computer-readable storage medium outside the community based on internal security authentication. Background Technology

[0002] Currently, there are two main solutions in the community delivery sector: the traditional food delivery rider model and early unmanned delivery systems. The traditional model relies on human riders, who need to repeatedly complete processes such as community access control registration and unit door calling. On average, each authentication takes 2-3 minutes, and the order scheduling within one kilometer lacks precise optimization, resulting in large fluctuations in delivery time (peak times exceeding 50 minutes). Early unmanned delivery solutions use static permission configurations, requiring manual QR code authorization for robots to enter the community. Unit doors cannot be opened automatically, and path planning does not take into account the dynamic environment (such as the real-time distribution of pedestrians and vehicles), resulting in low obstacle avoidance efficiency.

[0003] Therefore, traditional community delivery has the following main application shortcomings:

[0004] 1. Repetitive and cumbersome identity verification: Riders or robots need to pass two verifications at the community and building entrance multiple times, which is inefficient;

[0005] 2. Insufficient scheduling accuracy: Task allocation was not optimized for a one-kilometer range, resulting in a high robot idle rate (over 30%).

[0006] 3. Fragmented access control system: Community access control and unit door access are independent, making it impossible for robots to pass through autonomously throughout the entire process;

[0007] 4. Poor dynamic adaptability: The path planning does not incorporate real-time environmental data, which easily leads to congestion or collisions, resulting in a delay rate of over 15%. Summary of the Invention

[0008] To address the technical problems existing in the prior art, the present invention provides the following technical solution:

[0009] On the one hand, a method for unmanned delivery outside communities based on internal security authentication is provided. This method is implemented by electronic devices and includes:

[0010] Order initiation steps: Receive delivery orders initiated by users through their user terminals, the orders including delivery addresses;

[0011] Task scheduling steps: Based on the order, use a preset scheduling algorithm to assign suitable delivery tasks to multiple robots;

[0012] Robot pickup process: The assigned robot navigates to the pickup point and completes the pickup.

[0013] Community entry procedure: After the robot arrives at the community entrance and completes real-time identity authentication based on asymmetric encryption, the community access control will automatically open.

[0014] Unit delivery steps: After the robot enters the community, it navigates to the target unit door, and the unit door opens automatically after identity authentication;

[0015] User pickup steps: The robot arrives at the user's door and notifies the user. After verifying the user's pickup voucher, the robot opens the cargo compartment for the user to pick up the goods.

[0016] Preferably, the real-time identity authentication in the community entry step specifically includes:

[0017] The robot sends an authentication request message to the community access control system. The message includes at least the robot's unique identifier, task identifier, timestamp, and a digital signature generated using the robot's private key on the aforementioned information.

[0018] The community access control system uses the pre-stored public key of the robot to verify the digital signature. After successful verification, it queries the database to confirm that the robot identifier has been registered and that the delivery address associated with the task identifier belongs to this community.

[0019] If all verifications pass, the community access control system will trigger an access control opening command.

[0020] Preferably, the preset scheduling algorithm used in the task scheduling step is a genetic algorithm, whose optimization objective is to minimize the total delivery time and total power consumption. The fitness function of the genetic algorithm is:

[0021] F = α * T_total + β * E_total + γ * P_violation,

[0022] Where T_total is the total delivery time, E_total is the total power consumption, P_violation is the constraint violation penalty term, and α, β, and γ are weighting coefficients.

[0023] Preferably, in the unit delivery step, the robot's path planning within the community employs an improved A* algorithm, the heuristic function of which is:

[0024] h(n) = γ * D(n) + δ * cost(n),

[0025] Where D(n) is the Euclidean distance from the current node n to the target point, cost(n) is the dynamic cost calculated based on real-time environmental data, and γ and δ are weighting coefficients.

[0026] Preferably, the method further includes a security monitoring step:

[0027] By deploying edge computing nodes in the community to analyze and monitor video streams in real time, and using target detection algorithms to identify abnormal robot states or abnormal approach behavior of strangers;

[0028] When a preset abnormal situation is detected, an alarm message is sent to the community management system, and the sound and light alarm and security terminal notification are triggered.

[0029] On the other hand, a community-based unmanned delivery system based on internal security authentication for implementing the above-described method is provided, employing a cloud-edge-device collaborative architecture, including:

[0030] The perception layer is used to collect robot status, environmental, and user information.

[0031] The transport layer is used to enable data communication between various components of the system.

[0032] The processing layer is used to perform core decisions such as identity authentication, task scheduling, path planning, and security monitoring.

[0033] The execution layer executes the instructions from the processing layer, controlling robots, access control systems, and related equipment to complete actions.

[0034] The user layer provides users with an interactive interface for placing orders, tracking, and picking up goods.

[0035] Preferably, the processing layer includes an identity authentication system configured as follows:

[0036] Store the device identifier, public key, and community permissions of registered robots;

[0037] Receive authentication requests containing digital signatures sent by the robot;

[0038] Use the corresponding public key to verify the validity of the signature and verify the legality of the robot identifier and task information;

[0039] After successful verification, an opening command is sent to the access control controller in the execution layer.

[0040] Preferably, the processing layer includes a task scheduling system configured to run a genetic algorithm, taking the robot's position, battery level, load, and the start, end, and time window of the order as inputs, and outputting the optimal task-robot allocation scheme through population initialization, fitness calculation, selection, crossover, mutation, and iterative convergence.

[0041] Preferably, the processing layer includes a path planning system configured to run an improved A algorithm, which, based on the traditional A algorithm, introduces a dynamic cost term based on real-time pedestrian density and obstacle information into the heuristic function to plan a safe path that balances path length and traffic efficiency.

[0042] Preferably, the processing layer includes a security monitoring system deployed on the community edge computing node, which integrates a target detection model for real-time analysis of camera video streams, identification of abnormal events such as robot damage or strangers following, and alarms sent to the community management system through the transmission layer when an anomaly is detected.

[0043] On the other hand, an electronic device is provided, comprising: a processor; and a memory storing computer-readable instructions, which, when executed by the processor, implement any of the methods described above for unmanned delivery outside the community based on internal security authentication.

[0044] On the other hand, a computer-readable storage medium is provided, wherein at least one instruction is stored therein, the at least one instruction being loaded and executed by a processor to implement any of the above-described methods for unmanned delivery outside the community based on internal security authentication.

[0045] The beneficial effects of the technical solutions provided in the embodiments of the present invention include at least the following:

[0046] Employing a cloud-edge-device collaborative architecture, the system automates the entire process from order initiation to supermarket stocking, robot scheduling, community entry, unit delivery, and user pickup. Internal linkage authentication ensures non-duplicative access control for robots entering the community from the outside. Combined with genetic algorithms to optimize task scheduling and improved A* algorithms to optimize path planning, delivery efficiency and security are enhanced. This system will replace some functions of traditional food delivery (community delivery within one kilometer), achieving automated and precise community delivery and providing users with a more convenient and safer delivery service. Attached Figure Description

[0047] To more clearly illustrate the technical solutions in the embodiments of the present invention, the accompanying drawings used in the description of the embodiments will be briefly introduced below. Obviously, the accompanying drawings described below are only some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0048] Figure 1 This is a block diagram of an unmanned delivery system outside a community based on internal security authentication, provided by an embodiment of the present invention;

[0049] Figure 2 This is a flowchart of an unmanned delivery method outside a community based on internal security authentication provided by an embodiment of the present invention;

[0050] Figure 3 This is a schematic diagram of the structure of an electronic device provided in an embodiment of the present invention. Detailed Implementation

[0051] The technical solution of the present invention will now be described with reference to the accompanying drawings.

[0052] In embodiments of the present invention, words such as "exemplarily," "for example," etc., are used to indicate that something is an example, illustration, or description. Any embodiment or design described as "exemplary" in the present invention should not be construed as being more preferred or advantageous than other embodiments or designs. Specifically, the use of the word "exemplary" is intended to present the concept in a concrete manner. Furthermore, in embodiments of the present invention, the meaning expressed by "and / or" can be both, or either one.

[0053] In the embodiments of this invention, the terms "image" and "picture" may sometimes be used interchangeably. It should be noted that, without emphasizing the distinction between them, they convey the same meaning. Similarly, the terms "of," "corresponding (relevant)," and "corresponding" may sometimes be used interchangeably. It should be noted that, without emphasizing the distinction between them, they convey the same meaning.

[0054] In this embodiment of the invention, sometimes a subscript such as W1 may be mistakenly written as a non-subscript form such as W1. When the difference is not emphasized, the meaning they express is the same.

[0055] To make the technical problems, technical solutions and advantages of the present invention clearer, a detailed description will be given below in conjunction with the accompanying drawings and specific embodiments.

[0056] This invention provides a method for unmanned delivery outside a community based on internal security authentication. This method can be implemented by an electronic device, which can be a terminal or a server.

[0057] To realize an unmanned delivery system outside the community based on internal security authentication, it is necessary to build a full-link collaborative architecture of "perception-transmission-processing-execution-user", and to solve three major problems: "external robots can enter the community without repeated authentication", "precise scheduling within a one-kilometer range", and "internal and external permission linkage".

[0058] The following description will be based on our company's design and application system.

[0059] I. System Overall Architecture Design

[0060] like Figure 1 As shown, the system adopts a "cloud-edge-device" collaborative architecture, which is divided into five major modules: perception layer, transmission layer, processing layer, execution layer and user layer, to realize full automation of the process from "order initiation - supermarket preparation - robot scheduling - community entry - unit delivery - user pickup".

[0061] 1.1 Perception Layer: Data Acquisition and Environmental Sensing

[0062] The perception layer is the "eyes" of the system, responsible for collecting information on robot status, supermarket goods, community environment, and users, providing data support for subsequent decision-making.

[0063] Hardware components:

[0064] Robot perception modules include: LiDAR (Velodyne VLP-16, 360° environmental scanning, accuracy ±2cm), RGB-D camera (Kinect Azure, for recognizing QR codes / user faces), GPS module (UBlox NEO-M8N, for centimeter-level positioning), RFID passive tag (13.56MHz, for community access control), power sensor (ACS712, for real-time monitoring of battery power), and ultrasonic sensor (HC-SR04, for obstacle avoidance assistance).

[0065] Community sensing module: access control RFID reader (Newland FR40, for reading robot tags), unit door camera (Hikvision DS-2CD3T46DWD-I3, for identifying users), edge computing node (Lenovo Edge Server, for deploying real-time video analysis models).

[0066] Supermarket sensing modules: pickup terminal (iPad Pro, with QR code scanner), shelf IoT sensor (LoRa module, to detect whether goods are in place), and POS system (Sunmi T1, to connect to delivery orders).

[0067] User perception modules: smartphones (running the delivery app) and smartwatches (receiving pickup notifications).

[0068] Software components:

[0069] Robot perception drivers: LiDAR driver (ros-drivers / velodyne), camera driver (librealsense), and GPS driver (nmea_navsat_driver) under the ROS (Robot Operating System) framework.

[0070] Environmental perception algorithms: LiDAR point cloud clustering (DBSCAN, for pedestrian / vehicle identification), camera target detection (YOLOv5, for QR code / user identification).

[0071] 1.2 Transport Layer: Data Communication and Edge Computing

[0072] The transport layer is the "nerve" of the system, responsible for transmitting data from the perception layer to the processing layer and issuing instructions from the processing layer to the execution layer, ensuring low-latency and highly reliable communication.

[0073] Hardware components:

[0074] 5G base station (Huawei 5G AAU), Wi-Fi 6 router (TP-Link AX11000), edge computing node (Lenovo Edge Server, supporting GPU acceleration), cloud server (Alibaba Cloud ECS, 8 cores and 16GB memory).

[0075] Software components:

[0076] Communication protocol:

[0077] MQTT (Message Queuing Telemetry Transport): Lightweight message transmission (such as order status and task instructions) for robots, supermarkets, community systems and cloud servers, with a latency of ≤100ms.

[0078] HTTP / 2: Used for high-concurrency data transmission between user apps and cloud servers (such as order placement and payment), and supports server push.

[0079] WebSocket: Used for real-time two-way communication between robots and community access control systems (such as access control opening commands), with a latency of ≤50ms.

[0080] Edge computing frameworks: TensorFlow Lite (deploy YOLOv5 models for real-time video analytics) and OpenVINO (accelerate LiDAR point cloud processing).

[0081] 1.3 Processing Layer: Core Decision Making and Intelligent Scheduling

[0082] The processing layer is the "brain" of the system, responsible for core logic such as identity authentication, task scheduling, path planning, and security monitoring, and realizing the key function of "internal linkage authentication".

[0083] Hardware components:

[0084] Cloud servers (Alibaba Cloud ECS, used to deploy core business systems), databases (MySQL 8.0, used to store order, robot, and user data), and caches (Redis 6.0, used to accelerate task scheduling).

[0085] Software components:

[0086] Identity authentication system (core module):

[0087] Function: Enables "internal pre-authentication" of robots, eliminating the need for repeated permission identification.

[0088] design:

[0089] Robot registration: When a robot leaves the factory, it submits a unique device ID, public key (PK), and manufacturer certificate to the community management system. The community system verifies the manufacturer certificate (through a CA authority), binds the robot ID to community permissions (such as accessible unit doors and delivery range), and stores it in the database.

[0090] Real-time authentication: When the robot enters the community, it sends the following information to the community access control system: {

[0091] "robot_id": "R-20230901-001",

[0092] "task_id": "T-20231005-007",

[0093] "timestamp": "2023-10-05 14:30:00",

[0094] "signature": "a1b2c3d4e5f6..." / / Sign the above information using the robot's private key (SK)

[0095] }

[0096] Verification Process: The community access control system verifies the signature (H(M) == D(PK,Signature)) using the robot's public key (PK), where: H is the SHA-256 hash function, which converts the message M (a combination of robot_id, task_id, and timestamp) into a 256-bit fixed-length hash value to ensure message integrity; D is the RSA decryption function, which uses the public key PK to decrypt the signature (Signature) encrypted with the robot's private key (SK) to obtain the decrypted hash value; if the decryption result matches H(M), it proves that the message has not been tampered with and comes from a legitimate robot. After successful verification, the system queries the database to confirm that the robot ID belongs to a registered delivery robot and the task ID is associated with the community order, triggering the access control opening command.

[0097] Task scheduling system:

[0098] Function: Optimize robot task allocation based on robot status (location, battery level, workload), supermarket orders (stock status, product type), and community needs (delivery time window).

[0099] Design: A genetic algorithm (GA) is used to optimize task allocation, with the goal of minimizing total delivery time and power consumption.

[0100] Variable definition: x_ij (0-1 variable, whether robot i performs task j).

[0101] Constraints:

[0102] Each task can only be performed by one robot: Σi=1 to m(x_ij) = 1 (j=1..n, m is the total number of robots, n is the total number of tasks).

[0103] The robot has enough power to complete the task: Σj=1 to n(x_ij * e_ij) ≤ E_i (e_ij is the power consumption of robot i in performing task j, in Wh; E_i is the current remaining power of robot i, in Wh).

[0104] Fitness function: F = α*T_total + β*E_total + γ*P_violation, the operating mechanism is to calculate the comprehensive cost of the task allocation scheme by weighted summation, where:

[0105] T_total: Total delivery time (T_total = Σi=1 to mΣj=1 to n(x_ij * t_ij), where t_ij is the time it takes for robot i to perform task j, in minutes).

[0106] E_total: Total power consumption (E_total = Σi=1 to mΣj=1 to n(x_ij * e_ij), unit: Wh).

[0107] P_violation: Constraint violation penalty (calculation method: if x_ij exceeds the load limit of robot i, add 10 points for every 1kg overload; if the power is insufficient, add 5 points for every 1Wh of power shortage).

[0108] α, β, γ: Weighting coefficients (adjusted according to business needs, for example, α=0.6, β=0.3, γ=0.1).

[0109] Algorithm flow: Initialize population → Calculate fitness → Selection (roulette wheel) → Crossover (single-point crossover) → Mutation (randomly flip genes) → Iterate until convergence → Output optimal task allocation scheme.

[0110] Path planning system: Provides the robot with the optimal path from the supermarket to the community and within the community, avoiding obstacles and congestion. An improved A* algorithm is used, incorporating dynamic cost terms (such as pedestrian density and vehicle flow) to optimize path selection.

[0111] Heuristic function: h(n) = γ*sqrt((x_goal - x_n) 2 + (y_goal - y_n) 2 ) + δ*cost(n), where:

[0112] γ: Heuristic coefficient (set to 1 to balance path exploration and utilization efficiency); sqrt((x_goal -x_n) 2 + (y_goal-y_n) 2 () is the Euclidean distance, which calculates the straight-line distance from node n to the target point, in meters. sqrt is the abbreviation for square root function, used to calculate Euclidean distance.

[0113] δ: Dynamic cost coefficient (taken as 0.5, adjusting the weight of dynamic costs).

[0114] cost(n): The dynamic cost of node n.

[0115] cost(n) = ρ*pedestrian_density(n) + σ*vehicle_density(n), where ρ=0.6 and σ=0.4 are weighting coefficients, set according to the degree of influence of pedestrians and vehicles on delivery within the community; pedestrian_density(n) is the number of pedestrians within 10 meters of node n, and vehicle_density(n) is the number of vehicles.

[0116] Node expansion: Select the node with the smallest f(n) = g(n) + h(n) (g(n) is the actual cost from the starting point to node n) for expansion, and update the path in real time.

[0117] Security monitoring system:

[0118] Functions: Real-time monitoring of robot status and community environment, and identification of abnormal situations (such as robot being damaged or strangers following it).

[0119] Design: The YOLOv5 object detection algorithm is adopted and deployed on the community edge computing node to analyze surveillance video in real time.

[0120] Definition of abnormal conditions:

[0121] Robot damaged: Robot hatch opened (boundary box covers hatch area and confidence level ≥ 0.7), shell damaged (boundary box covers shell area and confidence level ≥ 0.7).

[0122] Stranger following: The distance between the stranger and the robot is ≤2 meters (based on LiDAR point cloud computing distance), and the duration is ≥10 seconds (based on video frame sequence analysis).

[0123] Alarm Process: When an anomaly is detected, the edge computing node sends an alarm message to the community management system via the MQTT protocol ({"event_type": "robot_damaged", "robot_id": "R-20230901-001", "timestamp": "2023-10-05 15:15:30"}), where: event_type is the type of the abnormal event (e.g., robot_damaged indicates robot damage, stranger_follow indicates a stranger following); robot_id is the unique identifier of the abnormal robot; and timestamp is the UTC timestamp of the anomaly (format YYYY-MM-DD HH:MM:SS). After receiving the message, the community system parses the fields, triggers an audible and visual alarm (a continuous 10-second buzzer and flashing red light), and pushes alarm details to the security terminal APP to notify security personnel to handle the situation.

[0124] 1.4 Execution Layer: Task Implementation and Action Control

[0125] The execution layer is the "hands and feet" of the system, responsible for executing the instructions of the processing layer to realize actions such as robot picking up goods, delivery, and access control opening.

[0126] Hardware components:

[0127] Robot execution modules: robotic arm (UR5, load capacity 5kg, accuracy ±0.1mm), electric hatch (push rod motor, stroke 100mm), wheeled chassis (customized, maximum speed 1.5m / s, climbing ability 15°).

[0128] Community execution modules: access control controller (Hikvision DS-K2600, supports relay output), unit door controller (same as access control controller), and audible and visual alarm (Dahua DH-AS810).

[0129] Supermarket execution modules: electronic locks on shelves (customized, supporting LoRa control), and pickup terminal printers (thermal printers that print order QR codes).

[0130] Software components:

[0131] Robot control: robotic arm control (ros-industrial / ur_driver), chassis motion control (ros-controllers / diff_drive_controller), and door control under the ROS framework (custom node, sending PWM signals to the push rod motor).

[0132] Access Control: The community management system calls the access controller API (POST / api / access / open), with parameters including: door_id (unique identifier for the access control device, such as "entrance_01" for the main entrance and "unit_03" for Unit 3) and robot_id (unique ID for the delivery robot). Operating Mechanism: The system sends an HTTP POST request to the access controller. The controller verifies whether the robot_id is in the registered delivery whitelist and whether the door_id matches the task permissions. Upon successful verification, a relay is triggered to close (lasting 5 seconds), driving the access control motor to open. A 200 status code indicates success, while a 403 status code indicates insufficient permissions.

[0133] 1.5 User Layer: Interface and Experience Optimization

[0134] The user layer is the "entry point" of the system, responsible for interactive functions such as user order placement, order tracking, and pickup confirmation.

[0135] Hardware components:

[0136] Smartphones (Android / iOS, running the delivery app) and smartwatches (Apple Watch / Huawei Watch, receiving notifications).

[0137] Software components:

[0138] User App Functions:

[0139] To place an order: Select a product from a nearby supermarket (≤1 km away), fill in the delivery address (community name, unit number, room number), and pay via WeChat or Alipay.

[0140] Tracking: Real-time monitoring of robot location (GPS positioning) and order status (pending preparation → picked up → in delivery → completed).

[0141] Pick-up: After receiving the pickup notification (push / SMS), go to the door and scan the robot's pickup code (QR code) with the APP. After verification, the robot will open the door.

[0142] Evaluation: After picking up the goods, rate the delivery service (star rating + text).

[0143] Notification Module: Cross-platform push notifications are achieved using FCM (Firebase Cloud Messaging) and APNs (Apple PushNotification service). FCM is Google's cloud messaging service for Android devices; APNs is Apple's push service for iOS devices. Operation Mechanism: The cloud server encapsulates notification content (such as pickup reminders) into FCM / APNs format and sends it to the user's device through their respective push gateways. Upon receiving the message, the device displays it in the system notification bar; clicking it redirects to the order details page in the app.

[0144] II. System Interaction Principles and Processes

[0145] like Figure 2 As shown, the system interaction process is divided into six stages: order initiation, supermarket stocking, robot scheduling, community entry, unit delivery, and user pickup. The following is a detailed interaction logic (taking "users ordering fresh produce from nearby supermarkets" as an example):

[0146] 2.1 Order Initiation (User Layer → Processing Layer)

[0147] Users open the delivery app, select the "Nearby Supermarkets" category, and browse products (such as "Fresh Apples", priced at 10 yuan per jin).

[0148] The user selects the quantity of goods (2 catties), fills in the delivery address ("Unit 3, Room 101, XX Community"), and clicks "Submit Order".

[0149] The app sends a POST request to the cloud server's order API (https: / / api.delivery.com / order) with the following parameters: {

[0150] "user_id": "U-20230801-001",

[0151] "product_id": "P-20230905-002",

[0152] "quantity": 2,

[0153] "delivery_address": {

[0154] "community": "XX Community"

[0155] "unit": "3 units",

[0156] "room": "Room 101"

[0157] },

[0158] "payment_info": "wechat_pay:1234567890"

[0159] }

[0160] The cloud server verifies the payment information (by calling the WeChat Pay "Unified Order" API: https: / / api.mch.weixin.qq.com / pay / unifiedorder), with parameters including out_trade_no (order ID, such as T-20231005-007), total_fee (order amount, in cents), body (product description, such as "2 jin of fresh apples"), and spbill_create_ip (user IP). After polling the "Query Order" API to confirm that the payment status is "SUCCESS", the order ID is generated and stored in the MySQL database. At the same time, an MQTT message is sent to the order topic (topic / supermarket / order) of the supermarket system.

[0161] 2.2 Supermarket Inventory Preparation (Processing Layer → Supermarket Perception Layer)

[0162] The supermarket system subscribes to the topic / supermarket / order, and after receiving an MQTT message, it parses the order ID, product information, and delivery address; it generates a stock preparation task order (including order ID, product SKU, and shelf location), and pushes it to the stock preparation staff's terminal through the supermarket management system's employee-side APP; after receiving the task, the stock preparation staff goes to the corresponding shelf to pick up the goods, and scans the product's QR code to mark the stock preparation as complete.

[0163] The supermarket system subscribes to the topic / supermarket / order. Upon receiving an MQTT message, it updates the order status to "pending" and notifies the stock clerk (via a pop-up notification in the supermarket management system).

[0164] The stock clerk picks the goods from the shelf according to the order information (product ID: P-20230905-002, quantity: 2 jin) and puts the goods into the picking area.

[0165] The stock clerk scans the product's QR code (P-20230905-002) using a pickup terminal (iPad Pro) and sends a PUT request to the supermarket system's stock preparation interface (https: / / api.supermarket.com / stock) with the following parameters: {

[0166] "order_id": "T-20231005-007",

[0167] "product_id": "P-20230905-002",

[0168] "quantity": 2,

[0169] "stock_status": "ready"

[0170] }

[0171] The supermarket system updates the order status to "ready" and sends an MQTT message to the delivery system's scheduling topic (topic / delivery / schedule).

[0172] 2.3 Robot Scheduling (Processing Layer → Execution Layer)

[0173] The delivery system's scheduling module subscribes to the topic / delivery / schedule. Upon receiving a message, it invokes a genetic algorithm to optimize task allocation. The genetic algorithm's operation mechanism is as follows: Initialize the population (randomly generate the task-robot allocation matrix) → Calculate fitness (F=α*T_total+β*E_total+γ*P_violation, where α=0.6, β=0.3, and γ=0.1 are weighting coefficients) → Selection (using roulette wheel to select individuals with high fitness) → Crossover (single-point crossover to exchange gene segments) → Mutation (randomly flipping 0.1% of genes) → Iterate 100 times until convergence, outputting the optimal allocation scheme.

[0174] Scheduling algorithm input:

[0175] Robot list: R-20230901-001 (Location: Supermarket A entrance, Battery: 80%, Load: 0), R-20230901-002 (Location: Community B entrance, Battery: 50%, Load: 1).

[0176] Task list: T-20231005-007 (Start point: Supermarket A, End point: Unit 3, Room 101, XX Community).

[0177] Algorithm output: Select R-20230901-001 to execute the task, based on: distance cost (R1 is only 50 meters from supermarket A, while R2 requires 200 meters), power cost (R1 has 80% remaining power to cover the entire delivery route, while R2 has only 50%), load cost (R1 currently has 0 load and no additional consumption), and the overall fitness F=0.6*10+0.3*5+0.1*0=7.5 is the minimum value.

[0178] The delivery system sends an MQTT message to the task topic (topic / robot / R-20230901-001 / task) of robot R-20230901-001, with the following parameters: {

[0179] "task_id": "T-20231005-007",

[0180] "supermarket_address": "Supermarket A, No. 100, XX Road",

[0181] "community_address": "Unit 3, Room 101, XX Community",

[0182] "product_info": "2 jin of fresh apples"

[0183] }

[0184] 2.4 Robot Pickup (Execution Layer → Supermarket Perception Layer)

[0185] After receiving the task message, robot R-20230901-001 parses the parameters and starts the picking process.

[0186] The robot uses GPS to navigate to the entrance of supermarket A (No. 100, XX Road). Upon arrival, it uses an RGB-D camera to scan the order QR code (T-20231005-007) on the pickup terminal.

[0187] The robot sends a GET request to the supermarket system's pickup interface (https: / / api.supermarket.com / pickup), with the following parameters: robot_id=R-20230901-001 (unique robot identifier) ​​and order_id=T-20231005-007 (order ID). The supermarket system's verification logic is as follows: check if robot_id is on the delivery whitelist → check if order_id is in a ready state → return the product location information (shelf 3, item number A01, coordinates X=5.2m, Y=3.8m).

[0188] The supermarket system verifies the robot ID (whether it belongs to the delivery system) and the order ID (whether the goods have been prepared), and returns the product location information (shelf 3, number A01).

[0189] The robot uses LiDAR to navigate to the third shelf. The shelf's IoT sensors detect the robot's approach and send a signal to the supermarket system.

[0190] The supermarket system sends a command to the shelf electronic lock (POST / api / shelf / unlock, parameters: shelf_id=A01 (unique shelf ID), timeout=10s (unlock timeout)). The electronic lock's response mechanism is as follows: upon receiving the command, it verifies the validity of the shelf_id → drives the motor to unlock → returns 200 OK (unlock successful) or 404 Not Found (shelf does not exist) → automatically locks after 10 seconds.

[0191] The robot uses its robotic arm to pick up the goods (grab 2 pounds of apples), put them into the hatch, and closes the hatch.

[0192] The robot sends a POST request to the supermarket system's pickup confirmation interface (https: / / api.supermarket.com / pickup / confirm) with the following parameters: robot_id=R-20230901-001, order_id=T-20231005-007, and pickup_time=2023-10-05 15:05:00 (pickup timestamp). The supermarket system verifies the parameters' validity, updates the order status to "picked," returns a 200 OK response, and sends an MQTT message to the delivery system.

[0193] The supermarket system updates the order status to "picked" and sends an MQTT message to the order status topic (topic / order / status) of the delivery system.

[0194] 2.5 Community Entry (Execution Layer → Processing Layer → Execution Layer)

[0195] After robot R-20230901-001 completes the pickup, it initiates the delivery process and uses GPS navigation to the entrance of XX Community (No. 200, XX Road).

[0196] Upon arrival at the community entrance, the robot's RFID tag is read by the access control RFID reader (Newland FR40), obtaining the robot ID (R-20230901-001).

[0197] The RFID reader sends a POST request to the community management system's access control interface (https: / / api.community.com / access) with the following parameters: {

[0198] "robot_id": "R-20230901-001",

[0199] "task_id": "T-20231005-007",

[0200] "timestamp": "2023-10-05 15:10:00",

[0201] "signature": "a1b2c3d4e5f6..." / / Robot private key signature

[0202] "task_id": "T-20231005-007",

[0203] "timestamp": "2023-10-05 15:00:00",

[0204] "signature": "a1b2c3d4e5f6..." / / Robot private key signature

[0205] }

[0206] The community management system verifies the signature (H(M) == D(PK, Signature)), where: H is the SHA-256 hash function, which converts the message M (a concatenated string of robot_id + task_id + timestamp) into a 256-bit fixed-length hash value; D is the RSA decryption function, which uses the robot's public key PK to decrypt the Signature encrypted with the private key, obtaining the decrypted hash value; if the two are equal, the signature is verified as valid. The database is then queried for confirmation.

[0207] Robot IDR-20230901-001 is a registered delivery robot.

[0208] The delivery address associated with task IDT-20231005-007 is Room 101, Unit 3, XX Community.

[0209] After successful verification, the community management system sends a POST request to the access control API (https: / / api.community.com / door / open, parameter: door_id=entrance_1) to trigger the access control to open (the relay closes and the door opens).

[0210] The robot entered the community and used a combination of lidar and GPS to navigate to the entrance of Unit 3 (Unit 3, XX Community).

[0211] 2.6 Unit Delivery (Execution Layer → Processing Layer → Execution Layer)

[0212] The robot arrives at the entrance of Unit 3 and sends a POST request to the unit door interface of the community management system (https: / / api.community.com / unit / access) with the following parameters: {

[0213] "robot_id": "R-20230901-001",

[0214] "task_id": "T-20231005-007",

[0215] "unit_id": "3 units",

[0216] "timestamp": "2023-10-05 15:10:00",

[0217] "signature": "f6e5d4c3b2a1..." / / Robot private key signature

[0218] }

[0219] Combined with 2.7 User Pickup (Execution Layer → User Layer)

[0220] The robot arrives at the door of Room 101 and sends a POST request to the cloud server's notification interface (https: / / api.delivery.com / notify) with the following parameters: user_id=U-20230801-001 (unique user identifier), order_id=T-20231005-007 (order ID), and pickup_code=123456 (pickup code, generated by MD5 hashing the first 6 digits of order_id + timestamp, valid for 10 minutes). The interface operates by associating the user with the order upon receiving the parameters, generating the pickup code, storing it in the database, and triggering a push notification.

[0221] The cloud server sends a pickup notification to the user's APP via FCM / APNs ("Your order has been delivered to the door of Room 101. Please scan the pickup code with the APP to pick up your order").

[0222] Users open the app, click the "Pick Up" button, and scan the pickup code (QR code) on the robot's door.

[0223] The APP sends a POST request to the cloud server's pickup verification interface (https: / / api.delivery.com / pickup / verify), with the following parameters: user_id=U-20230801-001, order_id=T-20231005-007, and pickup_code=123456.

[0224] The cloud server verifies the pickup code logic as follows: 1. Check if the pickup_code is bound to the order_id; 2. Verify if the pickup code is within its valid time (generation time + 10 minutes); 3. Confirm that the pickup code has not been used. If all three steps pass, return "Verification passed"; otherwise, return "Invalid or expired pickup code".

[0225] Once the robot receives the verification message (MQTT topic: topic / robot / R-20230901-001 / pickup), it sends a PWM signal to the push rod motor to open the hatch (stroke 100mm, time 2 seconds).

[0226] The customer picks up the package (2 jin of apples) and closes the cargo door.

[0227] The robot sends a PUT request to the delivery system's task interface (https: / / api.delivery.com / task / complete), with the following parameters: robot_id=R-20230901-001, order_id=T-20231005-007, and status=completed.

[0228] The delivery system updates the order status to "Completed" and sends an MQTT message to the order topic (topic / user / U-20230801-001 / order) in the user's app. The user's app updates the order status and prompts "Please rate the delivery service".

[0229] III. Intelligent Model / Algorithm Optimization Design

[0230] 3.1 Task Scheduling: Optimization using Genetic Algorithm (GA)

[0231] Problem Description: Assume there are 3 robots (R1, R2, R3) and 5 tasks (T1-T5). The starting point (supermarket) and ending point (community) of each task are different. The initial position, battery level, and load of the robots are also different. We need to optimize the task allocation and minimize the total delivery time and power consumption.

[0232] Algorithm Design:

[0233] Population initialization: 100 chromosomes are randomly generated (each chromosome is a 3×5 0-1 matrix, representing the allocation relationship between robots and tasks).

[0234] Fitness calculation: For each chromosome (task assignment matrix), calculate three core metrics: 1. Total delivery time T_total = Σ i,j(x_ij*t_ij), where x_ij is a 0-1 variable representing the time robot i takes to execute task j, and t_ij is the travel time from robot i to the starting point of task j plus the delivery time for task j; 2. Total power consumption E_total = Σ i,j (x_ij*e_ij), where e_ij is the power consumption (in Wh) of robot i performing task j; 3. Constraint violation penalty P_violation: If the robot load exceeds the 5kg limit, 10 points are added for every 1kg overload; if the power is insufficient to complete the task, 5 points are added for every 1Wh of power shortage. Substituting into the fitness function F=0.6*T_total+0.3*E_total+0.1*P_violation, the weight coefficients α=0.6 (time priority is the highest), β=0.3 (power consumption is the second highest), and γ=0.1 (penalty term). The smaller the F value, the better the task allocation scheme.

[0235] Selection operation: A roulette wheel selection algorithm is used, with the following mechanism: 1. Calculate the reciprocal of the fitness of each chromosome, 1 / F_i (because a smaller F is better); 2. Calculate the selection probability P_i = (1 / F_i) / Σj = 1 to N(1 / F_j) (N is the population size); 3. Generate a random number between 0 and 1. If the number falls within the probability range of the corresponding chromosome, that chromosome is selected. For example, for three chromosomes F1=10, F2=20, and F3=30, the selection probabilities are 6 / 11≈54.5%, 3 / 11≈27.3%, and 2 / 11≈18.2%, respectively. The chromosome with the smaller F has a higher probability of being selected.

[0236] Crossover operation: Select two parent chromosomes C1 and C2 (a 3×5 0-1 matrix), randomly select a crossover point k (e.g., k=2, i.e., the 2nd column), and swap the gene segments to the right of the crossover point.

[0237] Example:

[0238] C1=[[1,0,0,0,0],[0,1,0,0,0],[0,0,1,0,0]], C2=[[0,1,0,0,0],[1,0,0,0,0],[0,0,1,0,0]],

[0239] After the intersection point k=2,

[0240] C1'=[[1,1,0,0,0],[0,0,0,0,0],[0,0,1,0,0]],

[0241] C2'=[[0,0,0,0,0],[1,1,0,0,0],[0,0,1,0,0]], generates offspring chromosomes that retain the superior genes of the parent generation.

[0242] Mutation operation: Set the mutation probability p=0.01 (to balance diversity and stability). For each gene on each chromosome, generate a random number between 0 and 1. If the number is less than p, flip the gene (0 becomes 1 or 1 becomes 0). Example: Chromosome C3=[[1,0,0],[0,1,0],[0,0,1]], a certain gene C3[1][2] has a random number less than 0.01. After flipping, C3'=[[1,0,0],[0,1,1],[0,0,1]], which increases population diversity and avoids premature convergence.

[0243] Iteration Termination: After 100 iterations, the fitness converges (the optimal F change is ≤1% in 10 consecutive iterations), and the optimal chromosome (task allocation scheme) is output.

[0244] Compared to random assignment, the genetic algorithm-optimized delivery time is reduced by 30% and the total power consumption is reduced by 25%.

[0245] 3.2 Path Planning: Improved A* Algorithm

[0246] Problem description: The robot needs to navigate within the community, from the entrance of Unit 3 to the entrance of Room 101, avoiding pedestrians within the unit (such as "Aunt Wang" taking a walk in the corridor).

[0247] Algorithm Design:

[0248] Map building: Scan the internal environment of the community with LiDAR and generate a raster map (50×50 grid, each grid is 0.5m×0.5m in size).

[0249] Dynamic cost calculation: Pedestrian positions are detected in real time by cameras, and the pedestrian_density of each grid is updated (for example, the pedestrian_density of the grid (10,15) where "Aunt Wang" is located is 1).

[0250] Path planning: An improved A* algorithm is used, with the core formula being f(n) = g(n) + h(n), where g(n) is the actual path cost (distance + time) from the starting point to the current node n; and h(n) is the improved heuristic function, h(n) = γ*sqrt((x_goal - x_n)). 2 +(y_goal-y_n) 2 )+δ*cost(n), γ=1 (Euclidean distance weight), δ=0.5 (dynamic cost weight); cost(n) is the dynamic cost of node n, cost(n)=ρ*pedestrian_density(n)+σ*obstacle_cost(n), ρ=0.6 (pedestrian influence weight), σ=0.4 (obstacle influence weight).

[0251] Algorithm operation mechanism: The dynamic cost of the grid map is updated in real time, and the node with the smallest f(n) is expanded each time to avoid pedestrians and obstacles.

[0252] The improved A* algorithm can avoid pedestrians in the unit in real time (such as Aunt Wang taking a walk in the corridor). The path length increases by 5% compared to the traditional A* algorithm (from 10 meters to 10.5 meters), but the delivery time is reduced from 15 minutes to 12 minutes, a reduction of 20% (without waiting for pedestrians to avoid it), which significantly improves delivery efficiency.

[0253] IV. System Performance Testing and Optimization

[0254] 4.1 Test Environment

[0255] Community: XX Community (3 units, 100 households, area 5000㎡).

[0256] Supermarkets: 3 supermarkets within 1 kilometer (Supermarket A, Supermarket B, Supermarket C).

[0257] Robots: 5 delivery robots (R1-R5, each with a 5kg load capacity and an 8-hour battery life).

[0258] Users: 100 volunteers (simulating ordering and picking up goods).

[0259] 4.2 Test Indicators

[0260] Delivery efficiency: average delivery time (from order placement to pickup), order completion rate (≥95%).

[0261] Security: Accuracy of abnormal situation identification (≥90%), and error rate of identity authentication (≤0.1%).

[0262] User experience: App response time (≤2 seconds), pickup waiting time (≤5 minutes).

[0263] 4.3 Test Results

[0264] index Test value Target value Average delivery time (from order placement to pickup) 35 minutes ≤40 minutes Order completion rate (number of completed orders / total number of orders) 98% ≥95% Anomaly identification accuracy (number of correct identifications / total number of anomalies) 92% ≥90% Identity authentication error rate (number of incorrect authentications / total number of authentications) 0.05% ≤0.1% App response time (from user action to interface feedback) 1.2 seconds ≤2 seconds Pickup waiting time (from robot arrival to user pickup) 3 minutes ≤5 minutes

[0265] 4.4 Optimization Measures

[0266] Delivery efficiency optimization: The number of robots was increased (from 5 to 8), and the scheduling system redistributed tasks through a genetic algorithm. The average number of tasks per robot decreased from 1.2 to 0.75, reducing robot waiting time and cross-regional travel distance. The average delivery time was reduced from 35 minutes to 28 minutes.

[0267] Security optimization: The number of surveillance cameras has been increased (from 10 to 20) to cover all public areas of the community (such as unit entrances and corridors). The YOLOv5 model deployed on the edge computing nodes can acquire more video data, reduce missed detections, and improve the accuracy of anomaly identification from 92% to 95%.

[0268] User experience optimization: The app interface has been optimized (simplifying the ordering process), and a "schedule delivery" function has been added (users can select a delivery time window, such as "18:00-19:00"). The waiting time for picking up goods has been reduced from 3 minutes to 2 minutes.

[0269] This system achieves non-duplicative access control for robots entering the community from outside through "internal linkage authentication." Combined with genetic algorithms to optimize task scheduling and improved A* algorithms to optimize path planning, it enhances delivery efficiency and security. Future expansion will include the following functionalities:

[0270] Multi-scenario support: Supports various delivery scenarios such as express delivery, fresh food, and medicine (for example, temperature monitoring is required for medicine delivery, and temperature sensors can be added inside the robot cabin).

[0271] Intelligent device linkage: When linked with intelligent elevators (such as "elevator in Unit 3 of XX Community"), the robot can automatically call the elevator and go directly to the user's floor.

[0272] Algorithm Upgrade: Reinforcement Learning (RL) is adopted to optimize task scheduling, such as the Deep Q-Network (DQN) algorithm. The operating mechanism involves the interaction between the agent (scheduling system) and the environment (robot, task, community). A neural network fits the Q-value function, and the strategy is adjusted based on reward signals. The core formula is Q(s,a) ← Q(s,a) + α[r + γ*maxa'Q(s',a') - Q(s,a)], where α = 0.1 (learning rate), r is the immediate reward (e.g., shorter delivery time +10 points, lower power consumption +5 points), γ = 0.9 (discount factor), s is the current state (robot position, number of tasks), a is the action (assigning tasks to the robot), s' is the next state, and a' is the next action. Through this algorithm, the scheduling system can learn the optimal strategy in real time, improving the real-time performance and adaptability of scheduling.

[0273] The implementation of this system will replace some functions of traditional food delivery (community delivery within one kilometer), realize the automation and precision of community delivery, and provide users with more convenient and safer delivery services.

[0274] Figure 3 This is a schematic diagram of the structure of an electronic device provided in an embodiment of the present invention, such as... Figure 3As shown, optionally, electronic device 410 may include a first processor 2001.

[0275] Optionally, the electronic device 410 may also include a memory 2002 and a transceiver 2003.

[0276] The first processor 2001, memory 2002, and transceiver 2003 can be connected via a communication bus.

[0277] The following is combined with Figure 3 A detailed description of each component of electronic device 410 is provided below:

[0278] The first processor 2001 is the control center of the electronic device 410. It can be a single processor or a collective term for multiple processing elements. For example, the first processor 2001 can be one or more central processing units (CPUs), application-specific integrated circuits (ASICs), or one or more integrated circuits configured to implement embodiments of the present invention, such as one or more digital signal processors (DSPs), or one or more field-programmable gate arrays (FPGAs).

[0279] Optionally, the first processor 2001 can perform various functions of the electronic device 410 by running or executing software programs stored in the memory 2002 and calling data stored in the memory 2002.

[0280] In a specific implementation, as one example, the first processor 2001 may include one or more CPUs, for example... Figure 3 CPU0 and CPU1 are shown in the diagram.

[0281] In a specific implementation, as one example, the electronic device 410 may also include multiple processors, for example... Figure 3 The first processor 2001 and the second processor 2004 are shown in the diagram. Each of these processors can be a single-core processor or a multi-core processor. Here, a processor can refer to one or more devices, circuits, and / or processing cores used to process data (such as computer program instructions).

[0282] The memory 2002 is used to store the software program that executes the present invention, and is controlled by the first processor 2001 to execute it. The specific implementation method can be referred to the above method embodiment, and will not be repeated here.

[0283] Optionally, the memory 2002 may be a read-only memory (ROM) or other type of static storage device capable of storing static information and instructions, random access memory (RAM) or other type of dynamic storage device capable of storing information and instructions, or electrically erasable programmable read-only memory (EEPROM), compact disc read-only memory (CD-ROM) or other optical disc storage, optical disc storage (including compressed optical discs, laser discs, optical discs, digital universal optical discs, Blu-ray discs, etc.), magnetic disk storage media or other magnetic storage devices, or any other medium capable of carrying or storing desired program code in the form of instructions or data structures and accessible by a computer, but not limited thereto. The memory 2002 may be integrated with the first processor 2001 or may exist independently and be connected via the interface circuit of the electronic device 410. Figure 3 (Not shown in the image) is coupled to the first processor 2001, and this embodiment of the invention does not specifically limit this.

[0284] The transceiver 2003 is used to communicate with network devices or with terminal devices.

[0285] Alternatively, transceiver 2003 may include a receiver and a transmitter. Figure 3 (Not shown separately). The receiver is used to implement the receiving function, and the transmitter is used to implement the transmitting function.

[0286] Optionally, the transceiver 2003 can be integrated with the first processor 2001, or it can exist independently and be connected via the interface circuit of the electronic device 410. Figure 3 (Not shown in the image) is coupled to the first processor 2001, and this embodiment of the invention does not specifically limit this.

[0287] It should be noted that, Figure 3 The structure of the electronic device 410 shown does not constitute a limitation on the router. Actual knowledge structure identification devices may include more or fewer components than shown, or combine certain components, or have different component arrangements.

[0288] Furthermore, the technical effects of the electronic device 410 can be referred to the technical effects of the unmanned delivery method outside the community based on internal security authentication described in the above method embodiments, and will not be repeated here.

[0289] It should be understood that the first processor 2001 in the embodiments of the present invention may be a central processing unit (CPU), or it may be other general-purpose processors, digital signal processors (DSPs), application-specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs), or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components, etc. The general-purpose processor may be a microprocessor or any conventional processor, etc.

[0290] It should also be understood that the memory in the embodiments of the present invention can be volatile memory or non-volatile memory, or may include both volatile and non-volatile memory. The non-volatile memory can be read-only memory (ROM), programmable read-only memory (PROM), erasable programmable read-only memory (EPROM), electrically erasable programmable read-only memory (EEPROM), or flash memory. The volatile memory can be random access memory (RAM), which is used as an external cache. By way of example, but not limitation, many forms of random access memory (RAM) are available, such as static RAM (SRAM), dynamic RAM (DRAM), synchronous DRAM (SDRAM), double data rate synchronous DRAM (DDR SDRAM), enhanced synchronous DRAM (ESDRAM), synchronous linked DRAM (SLDRAM), and direct rambus RAM (DR RAM).

[0291] The above embodiments can be implemented, in whole or in part, by software, hardware (such as circuits), firmware, or any other combination thereof. When implemented using software, the above embodiments can be implemented, in whole or in part, as a computer program product. The computer program product includes one or more computer instructions or computer programs. When the computer instructions or computer programs are loaded or executed on a computer, all or part of the processes or functions described in the embodiments of the present invention are generated. The computer can be a general-purpose computer, a special-purpose computer, a computer network, or other programmable system. The computer instructions can be stored in a computer-readable storage medium or transmitted from one computer-readable storage medium to another. For example, the computer instructions can be transmitted from one website, computer, server, or data center to another website, computer, server, or data center via wired (e.g., infrared, wireless, microwave, etc.) means. The computer-readable storage medium can be any available medium that a computer can access or a data storage device such as a server or data center that includes one or more sets of available media. The available medium can be a magnetic medium (e.g., floppy disk, hard disk, magnetic tape), an optical medium (e.g., DVD), or a semiconductor medium. A semiconductor medium can be a solid-state drive.

[0292] It should be understood that the term "and / or" in this article is merely a description of the relationship between related objects, indicating that three relationships can exist. For example, A and / or B can represent: A existing alone, A and B existing simultaneously, or B existing alone. A and B can be singular or plural. Additionally, the character " / " in this article generally indicates an "or" relationship between the preceding and following related objects, but it can also represent an "and / or" relationship. Please refer to the context for a more accurate understanding.

[0293] In this invention, "at least one" means one or more, and "more than one" means two or more. "At least one of the following" or similar expressions refer to any combination of these items, including any combination of a single item or a plurality of items. For example, at least one of a, b, or c can represent: a, b, c, ab, ac, bc, or abc, where a, b, and c can be a single item or multiple items.

[0294] It should be understood that, in various embodiments of the present invention, the order of the above-mentioned process numbers does not imply the order of execution. The execution order of each process should be determined by its function and internal logic, and should not constitute any limitation on the implementation process of the embodiments of the present invention.

[0295] Those skilled in the art will recognize that the units and algorithm steps of the various examples described in conjunction with the embodiments disclosed herein can be implemented in electronic hardware, or a combination of computer software and electronic hardware. Whether these functions are implemented in hardware or software depends on the specific application and design constraints of the technical solution. Those skilled in the art can use different methods to implement the described functions for each specific application, but such implementations should not be considered beyond the scope of this invention.

[0296] Those skilled in the art will clearly understand that, for the sake of convenience and brevity, the specific working processes of the devices, systems, and units described above can be referred to the corresponding processes in the foregoing method embodiments, and will not be repeated here.

[0297] In the embodiments provided by this invention, it should be understood that the disclosed devices, systems, and methods can be implemented in other ways. For example, the system embodiments described above are merely illustrative; for instance, the division of units is only a logical functional division, and in actual implementation, there may be other division methods. For example, multiple units or components may be combined or integrated into another device, or some features may be ignored or not executed. Furthermore, the coupling or direct coupling or communication connection shown or discussed may be through some interfaces; the indirect coupling or communication connection between systems or units may be electrical, mechanical, or other forms.

[0298] The units described as separate components may or may not be physically separate. The components shown as units may or may not be physical units; that is, they may be located in one place or distributed across multiple network units. Some or all of the units can be selected to achieve the purpose of this embodiment according to actual needs.

[0299] In addition, the functional units in the various embodiments of the present invention can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit.

[0300] If the aforementioned functions are implemented as software functional units and sold or used as independent products, they can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of this invention, or the part that contributes to the prior art, or a part of the technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute all or part of the steps of the methods described in the various embodiments of this invention. The aforementioned storage medium includes various media capable of storing program code, such as USB flash drives, portable hard drives, read-only memory (ROM), random access memory (RAM), magnetic disks, or optical disks.

[0301] The above description is merely a specific embodiment of the present invention, but the scope of protection of the present invention is not limited thereto. Any variations or substitutions that can be easily conceived by those skilled in the art within the technical scope disclosed in the present invention should be included within the scope of protection of the present invention. Therefore, the scope of protection of the present invention should be determined by the scope of the claims.

Claims

1. A method for unmanned delivery outside a community based on internal security authentication, characterized in that, Includes the following steps: Order initiation steps: Receive delivery orders initiated by users through their user terminals, the orders including delivery addresses; Task scheduling steps: Based on the order, use a preset scheduling algorithm to assign suitable delivery tasks to multiple robots; Robot pickup process: The assigned robot navigates to the pickup point and completes the pickup. Community entry procedure: After the robot arrives at the community entrance and completes real-time identity authentication based on asymmetric encryption, the community access control will automatically open. Unit delivery steps: After the robot enters the community, it navigates to the target unit door, and the unit door opens automatically after identity authentication; User pickup steps: The robot arrives at the user's door and notifies the user. After verifying the user's pickup voucher, the robot opens the cargo compartment for the user to pick up the goods.

2. The method according to claim 1, characterized in that, The real-time identity authentication process in the community entry step specifically includes: The robot sends an authentication request message to the community access control system. The message includes at least the robot's unique identifier, task identifier, timestamp, and a digital signature generated using the robot's private key on the aforementioned information. The community access control system uses the pre-stored public key of the robot to verify the digital signature. After successful verification, it queries the database to confirm that the robot identifier has been registered and that the delivery address associated with the task identifier belongs to this community. If all verifications pass, the community access control system will trigger an access control opening command.

3. The method according to claim 1, characterized in that, The pre-defined scheduling algorithm used in the task scheduling step is a genetic algorithm, whose optimization objective is to minimize the total delivery time and total power consumption. The fitness function of the genetic algorithm is: F = α * T_total + β * E_total + γ * P_violation, Where T_total is the total delivery time, E_total is the total power consumption, P_violation is the constraint violation penalty term, and α, β, and γ are weighting coefficients.

4. The method according to claim 1, characterized in that, In the unit delivery step, the robot's path planning within the community employs an improved A* algorithm, whose heuristic function is: h(n) = γ * D(n) + δ * cost(n), Where D(n) is the Euclidean distance from the current node n to the target point, cost(n) is the dynamic cost calculated based on real-time environmental data, and γ and δ are weighting coefficients.

5. The method according to claim 1, characterized in that, The method also includes a security monitoring step: By deploying edge computing nodes in the community to analyze and monitor video streams in real time, and using target detection algorithms to identify abnormal robot states or abnormal approach behavior of strangers; When a preset abnormal situation is detected, an alarm message is sent to the community management system, and the sound and light alarm and security terminal notification are triggered.

6. A community-based unmanned delivery system based on internal security authentication for implementing the method of any one of claims 1-5, characterized in that, Adopting a cloud-edge-device collaborative architecture, including: The perception layer is used to collect robot status, environmental, and user information. The transport layer is used to enable data communication between various components of the system. The processing layer is used to perform core decisions such as identity authentication, task scheduling, path planning, and security monitoring. The execution layer executes the instructions from the processing layer, controlling robots, access control systems, and related equipment to complete actions. The user layer provides users with an interactive interface for placing orders, tracking, and picking up goods.

7. The system according to claim 6, characterized in that, The processing layer includes an identity authentication system, which is configured as follows: Store the device identifier, public key, and community permissions of registered robots; Receive authentication requests containing digital signatures sent by the robot; Use the corresponding public key to verify the validity of the signature and verify the legality of the robot identifier and task information; After successful verification, an opening command is sent to the access control controller in the execution layer.

8. The system according to claim 6, characterized in that, The processing layer includes a task scheduling system configured to run a genetic algorithm, taking the robot's position, battery level, load, and the start, end, and time window of the order as inputs. Through population initialization, fitness calculation, selection, crossover, mutation, and iterative convergence, it outputs the optimal task-robot allocation scheme.

9. The system according to claim 6, characterized in that, The processing layer includes a path planning system configured to run an improved A algorithm. This algorithm, based on the traditional A algorithm, introduces a dynamic cost term in the heuristic function based on real-time pedestrian density and obstacle information to plan a safe path that balances path length and traffic efficiency.

10. The system according to claim 6, characterized in that, The processing layer includes a security monitoring system deployed at the community edge computing node. It integrates a target detection model to analyze camera video streams in real time, identify abnormal events such as robot damage or strangers following the robot, and send an alarm to the community management system through the transmission layer when an anomaly is detected.

Images