ICMP

- 嵌入式协议环境准备

[openeuler@tc ~]$ pip install paho-mqtt -i http://mirrors.aliyun.com/pypi/simple/  --trusted-host mirrors.aliyun.com
[openeuler@tc ~]$ pip install aiocoap -i http://mirrors.aliyun.com/pypi/simple/  --trusted-host mirrors.aliyun.com
[openeuler@tc ~]$ pip install modbus -i http://mirrors.aliyun.com/pypi/simple/  --trusted-host mirrors.aliyun.com
[openeuler@tc ~]$ pip install pymodbus  -i http://mirrors.aliyun.com/pypi/simple/  --trusted-host mirrors.aliyun.com
[openeuler@tc ~]$ pip install pyserial  -i http://mirrors.aliyun.com/pypi/simple/  --trusted-host mirrors.aliyun.com

- 嵌入式学习路线

嵌入式学习路线可以分为以下几个阶段：

基础理论阶段：
- 计算机组成原理：理解计算机硬件的基本工作原理，包括CPU、存储器、I/O设备等。
- 操作系统原理：熟悉进程管理、内存管理、文件系统等内容，特别是实时操作系统RTOS的理解。
- 数据结构与算法：这是所有编程技术的基础，对于嵌入式开发也至关重要。
编程语言阶段：
- C语言：嵌入式开发的主流语言，需要深入理解和掌握，包括指针、内存管理等高级用法。
- Python或C++：部分嵌入式应用可能需要Python进行上位机开发，或者C++进行更复杂的应用开发。
嵌入式Linux开发阶段：
- Linux环境搭建与使用：熟练使用Linux命令行工具，了解shell脚本编写。
- 嵌入式Linux编程：学习Linux下驱动开发、系统调用、进程间通信等技术。
- Bootloader和内核裁剪移植：理解Bootloader的作用和工作流程，学会对Linux内核进行定制和裁剪。
嵌入式硬件相关知识：
- 微控制器（MCU）/微处理器（MPU）：学习ARM、MIPS等架构的MCU/MPU工作原理和外设接口。
- 电路设计与PCB制板：具备基本的电路知识，能看懂原理图，理解硬件设计原理。
实战项目阶段：
- STM32等单片机开发：从简单的GPIO控制到复杂的外设驱动开发，结合实际项目进行操作。
- 嵌入式Linux开发板实践：在开发板上实现文件系统操作、设备驱动编写、网络编程等。
进阶提升阶段：
- 实时操作系统RTOS应用开发：如FreeRTOS、RT-Thread等的学习和实践。
- 高级主题：物联网、AIoT、边缘计算等相关技术的学习与实践。
持续跟进与扩展：
- 跟踪最新的嵌入式软硬件技术，例如RISC-V架构、嵌入式人工智能、5G通讯等前沿技术。

以上就是一个较为全面的嵌入式学习路线，每个阶段都需要通过大量的实践操作来巩固所学知识。同时，由于嵌入式领域广泛，可根据自己的兴趣和职业规划进一步细化学习路径。

- ICMP（Internet Control Message Protocol） ping协议

 from scapy.all import IP, ICMP, sr1
'''
    1、pip install scapy 安装包
    2、在Python中，你可以使用第三方库Scapy来构建和解析ICMP（Internet Control Message Protocol）消息。
    3、Scapy是一个功能强大的网络工具，可以用于创建、发送和接收各种网络协议的数据包。
    4、以下是一个简单的Python示例，演示如何使用Scapy发送和接收ICMP消息：
    5、示例中，我们使用Scapy创建了两种不同类型的ICMP消息，一个普通的ICMP请求（不关联ping），另一个是ICMP回显请求（ping）。
    6、然后，我们使用sr1函数发送这些请求并等待响应。最后，我们显示接收到的ICMP响应或回显响应的信息。
'''
 
# 构建 ICMP 请求数据包
target_ip = "www.example.com"
icmp_request = IP(dst=target_ip) / ICMP()
 
# 发送 ICMP 请求并等待响应
icmp_response = sr1(icmp_request, timeout=2, verbose=False)
 
# 处理响应
if icmp_response:
    print("ICMP Response received from", target_ip)
    icmp_response.show()
else:
    print("No ICMP Response received")
 
# 构建 ICMP 回显请求（ping）数据包
ping_request = IP(dst=target_ip) / ICMP(type=8, code=0)  # ICMP Echo Request
 
# 发送 ICMP 回显请求
ping_response = sr1(ping_request, timeout=2, verbose=False)
 
# 处理回显响应
if ping_response:
    print("Ping Response received from", target_ip)
    ping_response.show()
else:
    print("No Ping Response received")

- DDS（Data Distribution Service）实时系统中数据分发和通信的协议

- 发布者示例

 from rticonnextdds_connector import Connector, ConnextDynamicData
 
'''
    DDS（Data Distribution Service）是一种用于实时系统中数据分发和通信的协议。
    DDS提供了一种高性能、松耦合、实时性强的消息传递机制。
    在Python中，你可以使用第三方的DDS库来实现DDS通信。
    其中一种流行的DDS实现是RTI Connext DDS。
    以下是一个简单的示例，演示如何使用RTI Connext DDS的Python API进行发布和订阅消息：
    首先，确保你已经安装了RTI Connext DDS，并按照相关的文档设置好你的环境。
    然后，你可以使用以下代码示例：
'''
 
# 创建DDS连接
connector = Connector('MyPublisher::MyParticipantLibrary::MyParticipant', 'MyPublisher::MyPublisherProfile')
 
# 获取输出实体
output_entity = connector.getOutput('MyPublisher::MyWriter::MyWriterProfile')
 
# 创建DynamicData实例
output_data = ConnextDynamicData(output_entity.type)
 
# 准备发送的数据
data_values = {'x': 42, 'y': 3.14, 'message': 'Hello, DDS!'}
output_data.set_dictionary(data_values)
 
# 发布数据
output_entity.instance.set_values_from(output_data)
output_entity.write()
 
# 关闭连接
connector.close()

- 订阅者示例

 from rticonnextdds_connector import Connector, ConnextDynamicData
'''
    这是一个简化的示例。在实际应用中，你需要更多的错误处理和配置。
    此外，确保配置文件（MyPublisher.xml和MySubscriber.xml）中的实体和配置与你的DDS实例匹配。
    确保查阅RTI Connext DDS的文档以获取更详细的信息和配置。
'''
 
# 创建DDS连接
connector = Connector('MySubscriber::MyParticipantLibrary::MyParticipant', 'MySubscriber::MySubscriberProfile')
 
# 获取输入实体
input_entity = connector.getInput('MySubscriber::MyReader::MyReaderProfile')
 
# 创建DynamicData实例
input_data = ConnextDynamicData(input_entity.type)
 
# 订阅数据
input_entity.read()
 
# 获取数据
for sample in input_entity.samples.valid_data_iter:
    input_data.copy_from(sample.get_dictionary())
 
    # 处理接收到的数据
    received_values = input_data.get_dictionary()
    print("Received Data:", received_values)
 
# 关闭连接
connector.close()

- SOME/IP (Service-Oriented Middleware for Embedded Systems over IP）嵌入式中间件协议

SOME/IP（Service-Oriented Middleware for Embedded Systems over IP）是一种用于嵌入式系统的面向服务的中间件协议，它运行在IP网络上。

该协议旨在简化嵌入式系统之间的通信，支持各种服务和功能。以下是一个简单的表格，介绍了SOME/IP协议的一些关键特性：

特性	描述
协议类型	面向服务的中间件协议
用途	用于嵌入式系统之间的通信，支持各种服务和功能
通信层	基于IP网络，支持IPv4和IPv6
传输层	通常使用UDP作为传输层协议，也可以支持TCP
服务模型	提供服务注册、发现和调用机制，支持异步和同步通信
数据序列化	使用MessagePack等轻量级二进制序列化格式
安全性	可以支持加密和认证机制，保障通信的安全性
会话管理	提供可选的会话管理机制，支持长连接和短连接
广播和组播	支持广播和组播通信，适用于多播消息
QoS支持	提供服务质量（Quality of Service，QoS）支持，确保通信的可靠性和实时性
接口定义语言	通常使用AUTOSAR标准中定义的Service Interface Description Language（SIDL）
典型应用领域	汽车领域是SOME/IP的主要应用领域，例如汽车电子控制单元（ECU）之间的通信

请注意，SOME/IP协议的具体实现和使用可能因应用领域和厂商而有所不同，上述表格提供了一般性的特性。在实际应用中，建议查阅相关规范和文档以获取详细的信息。

SOME/IP协议的Python实现通常需要使用第三方库或模块，而目前并没有标准的Python库专门用于SOME/IP。

然而，你可以使用一些支持UDP通信和消息序列化的库来创建自己的SOME/IP通信实现。

以下是一个简单的Python示例，使用Socket和MessagePack库模拟SOME/IP的部分功能：

 import socket
import struct
import msgpack
 
'''
    SOME/IP协议的Python实现通常需要使用第三方库或模块，而目前并没有标准的Python库专门用于SOME/IP。
    然而，你可以使用一些支持UDP通信和消息序列化的库来创建自己的SOME/IP通信实现。
    以下是Python简单示例，使用Socket和MessagePack库模拟SOME/IP的部分功能,实际应用中可能需要更多的功能和错误处理。
    此外，确保接收端服务器（在示例中是localhost:12345）能够解析和处理SOME/IP消息。
'''
 
# 定义SOME/IP消息头
def create_someip_header(service_id, method_id):
    header = {
        "message_id": 0,  # 消息ID，通常在实际应用中需要唯一标识每个消息
        "length": 0,      # 消息长度，后续根据实际消息内容计算
        "request_id": 1,  # 请求ID，用于匹配请求和响应
        "protocol_version": 1,  # SOME/IP协议版本
        "interface_version": 1, # 接口版本
        "message_type": 0x01,   # 请求消息类型
        "return_code": 0,       # 返回代码，通常为0表示成功
        "service_id": service_id,  # 服务ID
        "method_id": method_id,    # 方法ID
    }
    return msgpack.packb(header)
 
# 发送SOME/IP消息
def send_someip_message(service_id, method_id, payload):
    # 创建Socket连接
    with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
        # 服务器地址和端口
        server_address = ('localhost', 12345)
        
        # 构造SOME/IP消息头
        header = create_someip_header(service_id, method_id)
 
        # 计算消息长度
        length = len(header) + len(payload)
        struct.pack_into('!I', header, 4, length)
 
        # 合并消息头和有效载荷
        message = header + payload
 
        # 发送消息
        s.sendto(message, server_address)
 
# 例子：发送一个简单的SOME/IP消息
service_id = 0x1234
method_id = 0x5678
payload_data = {'param1': 42, 'param2': 'Hello, SOME/IP!'}
payload = msgpack.packb(payload_data)
 
send_someip_message(service_id, method_id, payload)

- mqtt 协议

轻量级消息传输协议，消息队列遥测传输，发布和订阅，适用于远程通信和带宽有限环境。IBM 1999年为连接油管远程传感器而设计。现在为开放OASIS标准。

OASIS（结构化信息标准促进组织，Organization for the Advancement of Structured Information Standards）是一个推进电子商务标准的发展、融合与采纳的非盈利性国际化组织。

import paho.mqtt.client as mqtt
import time

"""
　　创建了一个 MQTT 客户端，连接到指定的 MQTT 代理服务器，并订阅了一个主题（"example_topic"）。
　　然后，它进入一个循环，等待用户输入消息并将其发布到指定的主题。
　　同时，它也监听来自订阅主题的消息，并在收到消息时调用 on_message 函数来处理消息。
　　这里需要将 broker_address 更改为实际的 MQTT 代理服务器地址，并根据你的需求更改主题名称和其他设置。此示例用于演示基本的 MQTT 消息发布和订阅功能。
"""


# MQTT 代理服务器的地址和端口
broker_address = "mqtt.eclipse.org"
port = 1883

# 创建 MQTT 客户端
client = mqtt.Client("Python_Client")

# 连接到 MQTT 代理服务器
client.connect(broker_address, port)

# 订阅一个主题
def on_message(client, userdata, message):
    print(f"Received message '{message.payload}' on topic '{message.topic}'")

client.on_message = on_message
client.subscribe("example_topic")

# 启动 MQTT 客户端的循环
client.loop_start()

# 发布消息
while True:
    message = input("Enter a message to publish: ")
    client.publish("example_topic", message)
    time.sleep(1)

# 程序结束时断开连接
client.disconnect()

- coap 协议

轻量级受限应用web传输协议，专门为紧凑设备设计的web协议。使能够映射http模型以简化从物理网到web世界的集成。

1、coap在UDP之上，减少TCP连接开销。

2、异步消息转换：支持非确认和确认消息，前者不需应答，后者需要

3、资源发现：使设设备能够自己宣告或发现网络中的资源

4、四种请求类型：GET、POST、PUT、DELETE

- CoAP（Constrained Application Protocol）协议是一种专门为受限设备（例如微控制器）和受限网络而设计的物联网协议，在 RFC 7252 中有定义。其特点可以通过表格形式呈现：

特点	描述
基于消息模型	定义了四种消息类型（可确认、不可确认、确认应答和复位），以实现可靠或不可靠的数据传输。
基于请求/响应模型	支持四种请求方法（GET、PUT、POST 和 DELETE），以对服务器端的资源进行操作。
基于二进制格式	消息头部最小只有4字节，节省带宽和内存。
支持 URI 和内容类型	以便对资源进行标识和协商。
支持代理和缓存功能	以提高网络效率和可扩展性。
支持 IP 多播	以实现一对多的通信场景。
支持观察模式	以实现服务器端资源的变化通知。
支持安全传输	基于数据报传输层安全（DTLS）协议，以保护数据的机密性、完整性和认证性。
运行在 UDP 上	CoAP 协议运行在 UDP 上，而 HTTP 协议运行在 TCP 上。

- CoAP 协议和 HTTP 协议在设计目标、特性和应用场景等方面存在一些区别，以下是它们的主要区别：

区别	CoAP	HTTP
设计目标	主要针对资源受限的物联网设备和网络。	主要用于万维网和互联网应用。
消息格式	基于二进制，头部较小。	基于文本，头部较大。
请求方法	支持 GET、PUT、POST、DELETE 等方法。	支持更多方法，如 GET、POST、PUT、DELETE、HEAD 等。
传输层	通常运行在 UDP 上。	通常运行在 TCP 上。
资源消耗	较小的开销，适用于低功耗设备。	相对较大的开销。
可靠性	提供可选的可靠性机制。	默认使用 TCP 的可靠连接。
安全性	支持 DTLS 等安全协议。	支持 HTTPS 等安全协议。
应用场景	适用于物联网、传感器网络等。	适用于 Web 应用、浏览器交互等。

file:///opt/lindows/vscode/vscodeProject/lindows/python/hardware/f_coap_client.py

import logging
import asyncio
import aiocoap

"""
    安装包：pip install aiocoap
    CoAP服务器提供一个资源 "hello"，用于响应 GET 请求，并返回 "Hello, CoAP World!"。
    CoAP（Constrained Application Protocol）是一种用于受限环境的轻量级应用层协议，通常用于物联网（IoT）设备之间的通信。
    CoAP客户端构建一个 GET 请求，请求服务器上的资源。确保将服务器示例中的 coap://localhost/hello 替换为你的服务器地址和资源路径。
    CoAP是一种轻量级协议，适用于受限环境，适合IoT设备和嵌入式系统。
"""

# 设置日志级别以查看详细信息
logging.basicConfig(level=logging.INFO)

async def coap_client():
    protocol = await aiocoap.Context.create_client_context()

    # 构建CoAP请求
    request = aiocoap.Message(code=aiocoap.GET)
    request.set_request_uri('coap://localhost/hello')

    try:
        response = await protocol.request(request).response
        print("Response: %s" % response.payload.decode('utf-8'))
    except Exception as e:
        print("Failed to fetch resource:")
        print(e)

if __name__ == "__main__":
    asyncio.get_event_loop().run_until_complete(coap_client())

file:///opt/lindows/vscode/vscodeProject/lindows/python/hardware/f_coap_server.py

import logging
import asyncio
import aiocoap.resource as resource
import aiocoap

# 设置日志级别以查看详细信息
logging.basicConfig(level=logging.INFO)

# 定义一个CoAP资源
class HelloWorldResource(resource.Resource):
    def __init__(self):
        super(HelloWorldResource, self).__init__()

    async def render_get(self, request):
        return aiocoap.Message(payload=b"Hello, CoAP World!")

# 创建CoAP服务器
root = resource.Site()
root.add_resource(('hello',), HelloWorldResource())

# 运行服务器
def main():
    asyncio.Task(aiocoap.Context.create_server_context(root))
    asyncio.get_event_loop().run_forever()

if __name__ == "__main__":
    main()

- modbus 协议 / freemodbus

file:///opt/lindows/vscode/vscodeProject/lindows/python/hardware/f_mobbus_client.py

from pymodbus.client.sync import ModbusTcpClient

"""
    Modbus是一种用于工业自动化和通信的通信协议，它被广泛用于监控和控制设备。
    以下是一个简单的Python Modbus示例，使用pymodbus库来与Modbus设备通信。
    在这个示例中，我们将使用Modbus TCP通信，它是一种常见的Modbus通信方式。
    Modbus客户端连接到Modbus服务器，读取保持寄存器中的数据，然后断开连接。
    Modbus服务器创建一个数据存储块，该块包含保持寄存器中的数据，并在指定的IP地址和端口上启动Modbus TCP服务器。
    请注意，这只是一个非常简单的示例，你可以根据你的具体需求和Modbus设备的特点来进行更复杂的通信和数据处理。
    Modbus有多个变种和数据类型，你需要根据你的设备和协议规范进行适当的设置。
"""

# Modbus服务器的IP地址和端口
server_ip = '127.0.0.1'
server_port = 502

# 创建Modbus TCP客户端
client = ModbusTcpClient(server_ip, port=server_port)

# 连接到Modbus服务器
client.connect()

# 读取保持寄存器中的数据
result = client.read_holding_registers(0, 2, unit=1)  # 从单元ID 1中读取前两个保持寄存器

if not result.isError():
    print(f'Read data: {result.registers}')
else:
    print(f'Error reading data: {result.message}')

# 断开连接
client.close()

file:///opt/lindows/vscode/vscodeProject/lindows/python/hardware/f_mobbus_server.py

from pymodbus.server.sync import StartTcpServer
from pymodbus.datastore import ModbusSequentialDataBlock
from pymodbus.datastore import ModbusServerContext

# 创建Modbus服务器上的数据存储块
store = ModbusServerContext(slaves=1, single=True)
block = ModbusSequentialDataBlock(0, [0, 1, 2, 3], 0, [0]*4)
store.register(block, 0)

# 启动Modbus TCP服务器
StartTcpServer(store, address=('127.0.0.1', 502))

- rs485 协议

import serial
import time

"""
    安装包：pip install pyserial
    Python中与RS-485通信的示例需要使用适当的硬件支持（例如RS-485适配器）以及串口通信库，通常使用pyserial库进行RS-485通信。
    以下是一个简单的Python RS-485示例，假设你已经配置好了RS-485硬件。
    在这个示例中，我们使用pyserial库配置了RS-485通信参数，包括串口设备路径、波特率、校验位、停止位、数据位和超时时间。
    然后，我们发送了一个字符串数据并尝试读取从RS-485设备返回的响应数据。
    确保将port设置为你的RS-485串口设备的路径（通常是/dev/ttyUSB0或/dev/ttyS0等，具体取决于你的系统）。
    此示例仅用于演示RS-485通信的基本原理，你可以根据你的应用需求进行更复杂的通信和数据处理。
"""

# 配置串口参数
ser = serial.Serial(
    port='/dev/ttyUSB0',  # 串口设备路径，根据实际情况修改
    baudrate=9600,        # 波特率
    parity=serial.PARITY_NONE,
    stopbits=serial.STOPBITS_ONE,
    bytesize=serial.EIGHTBITS,
    timeout=1            # 超时时间（秒）
)

try:
    # 发送数据
    ser.write(b'Hello, RS-485!')

    # 读取数据
    response = ser.readline().decode('utf-8').strip()
    print(f'Received: {response}')

except Exception as e:
    print(f'Error: {e}')

finally:
    # 关闭串口连接
    ser.close()

- tcp 协议

/opt/lindows/vscode/vscodeProject/lindows/python/hardware/f_tcp_client.py

import socket

"""
    TCP/IP 服务器等待客户端连接，接收来自客户端的数据，发送响应数据，然后关闭客户端连接。
    TCP协议提供了可靠的、面向连接的通信，适用于需要稳定数据传输的应用程序。
    确保在服务器和客户端示例中的 server_address 中设置正确的IP地址和端口号，以便它们能够相互通信。
    这只是一个简单的示例，你可以根据需要构建更复杂的 TCP/IP 应用程序
"""

# 创建TCP客户端套接字
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 服务器地址和端口
server_address = ('127.0.0.1', 12345)

# 连接到服务器
client_socket.connect(server_address)

# 发送数据给服务器
message = "Hello, TCP Server!"
client_socket.send(message.encode('utf-8'))

# 接收服务器的响应
response = client_socket.recv(1024)
print(f"Received response: {response.decode('utf-8')}")

# 关闭客户端连接
client_socket.close()

/opt/lindows/vscode/vscodeProject/lindows/python/hardware/f_tcp_server.py

import socket

# 创建TCP服务器套接字
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 绑定服务器地址和端口
server_address = ('127.0.0.1', 12345)
server_socket.bind(server_address)

# 监听客户端连接
server_socket.listen(5)
print("TCP Server is listening...")

while True:
    # 等待客户端连接
    client_socket, client_address = server_socket.accept()
    print(f"Connected to client: {client_address}")

    # 接收客户端发送的数据
    data = client_socket.recv(1024)
    if data:
        print(f"Received data: {data.decode('utf-8')}")

    # 发送响应数据给客户端
    response = "Hello, TCP Client!"
    client_socket.send(response.encode('utf-8'))

    # 关闭客户端连接
    client_socket.close()

- udp 协议

/opt/lindows/vscode/vscodeProject/lindows/python/hardware/f_udp_client.py

import socket

"""
    Python UDP（User Datagram Protocol）示例，其中一个程序作为UDP服务器接收消息，另一个程序作为UDP客户端发送消息。
    UDP是一种面向无连接的协议，通常用于实现简单的消息传递。
    UDP是一种无连接协议，不提供可靠的数据传输，也不保证消息的顺序。
    因此，在实际应用中，你可能需要添加错误检查和恢复机制来处理丢失的消息或消息乱序的情况，具体取决于你的需求。
"""

# 创建UDP套接字
client_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

# 服务器地址和端口
server_address = ('localhost', 12345)

while True:
    message = input("Enter a message to send to the server: ")
    if not message:
        break

    # 发送消息到服务器
    client_socket.sendto(message.encode(), server_address)

# 关闭套接字
client_socket.close()

/opt/lindows/vscode/vscodeProject/lindows/python/hardware/f_udp_server.py

import socket

# 创建UDP套接字
server_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

# 绑定服务器地址和端口
server_address = ('localhost', 12345)
server_socket.bind(server_address)

print("UDP Server is listening...")

while True:
    # 接收来自客户端的数据
    data, client_address = server_socket.recvfrom(1024)
    print(f"Received message: {data.decode()} from {client_address}")

# 关闭套接字
server_socket.close()

- http 协议

/opt/lindows/vscode/vscodeProject/lindows/python/hardware/f_http_client.py

import requests

"""
    在Python中，你可以使用内置的HTTP库 http.server 来创建一个简单的HTTP服务器，或使用第三方库 requests 来创建HTTP客户端。
    在这个示例中，我们使用第三方库 requests 发起一个HTTP GET请求，然后检查响应的状态码和解析响应数据。
    此示例中，我们使用一个公共的 JSONPlaceholder API 作为示例，你可以根据自己的需求修改URL。
"""

# 发起HTTP GET请求
url = "https://jsonplaceholder.typicode.com/posts/1"
response = requests.get(url)

# 检查响应状态码
if response.status_code == 200:
    # 解析响应数据
    data = response.json()
    print("Response data:")
    print(data)
else:
    print(f"Failed to retrieve data. Status code: {response.status_code}")

/opt/lindows/vscode/vscodeProject/lindows/python/hardware/f_http_server.py

# 导入HTTP服务器模块
import http.server
import socketserver

# 指定端口号
port = 8000

# 创建HTTP服务器
with socketserver.TCPServer(("", port), http.server.SimpleHTTPRequestHandler) as httpd:
    print(f"HTTP server is running on port {port}")
    httpd.serve_forever()

- https 协议

/opt/lindows/vscode/vscodeProject/lindows/python/hardware/f_https_client.py

import requests

"""
    在Python中创建一个HTTPS服务器和使用HTTPS客户端，你需要使用SSL/TLS协议来加密通信。分别使用内置库和第三方库requests
    我们创建一个HTTPS服务器并配置SSL证书和密钥文件（server.pem）。你需要自己生成或获取有效的SSL证书和密钥文件。
    在HTTPS客户端示例中，我们使用 requests 库发送一个HTTPS GET请求，同时提供了服务器的SSL证书文件（server.pem）来验证服务器的身份。
    请确保将示例URL替换为你要访问的实际HTTPS网站。
    这只是一个简单的HTTPS服务器和HTTPS客户端示例。
    要在生产环境中使用HTTPS，你需要获取有效的SSL证书，通常从信任的证书颁发机构（CA）购买或申请。
    不要在生产环境中使用自签名证书（像上面示例中的server.pem），因为浏览器和应用程序通常不会信任它们。
"""

# 发起HTTPS GET请求
url = "https://example.com"  # 请将示例URL替换为实际的HTTPS网站
response = requests.get(url, verify="server.pem")

# 检查响应状态码
if response.status_code == 200:
    # 处理响应数据
    data = response.text
    print("Response data:")
    print(data)
else:
    print(f"Failed to retrieve data. Status code: {response.status_code}")

/opt/lindows/vscode/vscodeProject/lindows/python/hardware/f_https_server.py

import http.server
import socketserver
import ssl



# 指定端口号
port = 8443

# 创建HTTP服务器
with socketserver.TCPServer(("", port), http.server.SimpleHTTPRequestHandler) as httpd:
    # 配置SSL证书和密钥
    httpd.socket = ssl.wrap_socket(httpd.socket, certfile="server.pem", server_side=True)

    print(f"HTTPS server is running on port {port}")
    httpd.serve_forever()

- 韦根接口/门禁系统

韦根接口（Wiegand Interface）是一种常用于门禁系统中的通信接口，主要用于传输身份验证数据，如门禁卡或读卡器的信息。它是由韦根公司（Wiegand）在1980年代初开发的一种技术。
韦根接口的主要特点是简单和可靠。它使用两根线（数据线和地线）来传输数据，每根线上传输的信号是单向的。数据线可以传输0和1的信号，其中一根线用于传输0，另一根线用于传输1。这种接口能够传输较长的数据序列，通常用于门禁卡号等信息的传输。
韦根接口广泛应用于各种门禁系统、电子门锁和身份验证设备中。由于其简单和可靠的特点，它成为了门禁系统领域的一种标准接口。

在Python中，要实现与韦根接口的通信，通常需要使用特定的硬件，例如韦根读卡器，以及相应的库来读取数据。以下是一个简单的Python示例，展示了如何使用wiegand库来读取韦根接口的数据。请注意，这需要相应的硬件支持。
首先，你需要安装wiegand库，这可以通过pip完成：

pip install wiegand

然后，你可以编写一个简单的Python脚本来读取韦根数据：

	from wiegand import Wiegand
	# 创建Wiegand对象实例
	w = Wiegand()
	# 定义一个函数来处理读取到的数据
	def data_received(data):
	print(f"Data received: {data}")
	# 绑定data_received函数到data_event事件
	w.data_event += data_received
	# 启动Wiegand监听
	w.start()
	# 持续运行，直到你决定停止
	try:
	while True:
	pass
	except KeyboardInterrupt:
	print("Stopping Wiegand reader...")
	# 停止Wiegand监听
	w.stop()

这个脚本创建了一个Wiegand对象，并将其连接到data_event事件。每当韦根读卡器读取到数据时，data_received函数就会被调用，并打印出接收到的数据。脚本会一直运行，直到你手动停止它。
请注意，这个示例假设你已经正确配置了硬件，并且wiegand库支持你的系统。不同的韦根读卡器和系统可能需要不同的配置和驱动程序。因此，你可能需要根据你的具体硬件和系统环境来调整这个示例。

- PLC 编程相关 / 电气工程师

以下是一些常见的 PLC 品牌：

1. 西门子（Siemens）：在工业自动化领域具有广泛的应用和良好的口碑。
2. 三菱（Mitsubishi）：产品性能稳定，性价比较高。
3. 欧姆龙（Omron）：提供多种类型的 PLC 产品。
4. 施耐德（Schneider）：具有丰富的产品线和强大的技术支持。
5. ABB：在电力和工业自动化领域有一定的市场份额。
6. 台达（Delta）：国内知名品牌，产品涵盖多个领域。
7. 汇川（Inovance）：近年来发展迅速，在一些领域得到广泛应用。
8. 信捷（Xinje）：提供多种规格和类型的 PLC 产品。
这些品牌在市场上都有一定的知名度和用户基础，你可以根据项目的具体需求、预算和技术要求来选择适合的品牌。

以下是一些适合初学者学习 PLC 的平台或网站：

1. 西门子官方网站：提供丰富的产品信息、技术文档和教程。
2. 工控网：包含 PLC 相关的技术文章、案例分享和论坛交流。
3. 电子发烧友论坛：有大量的 PLC 学习资源和交流版块。
4. 技成培训网：专业的工控技术学习平台，提供 PLC 课程和资料。
5. 自动化之家：涵盖各种自动化技术，包括 PLC 的学习资源。
6. PLC 爱好者论坛：聚集了众多 PLC 爱好者，可进行交流和学习。
7. 工控人家园：提供工控技术的交流和学习平台。
8. 中华工控网：包含工控行业的新闻、技术文章和产品信息。
通过这些平台或网站，你可以获取到丰富的学习资源，与其他学习者交流经验，加快自己的学习进度。

初学者学习 PLC 通常需要具备以下基础知识：

1. 电气控制基础：了解电路原理、继电器等基础电气元件的工作原理。
2. 计算机基础：熟悉计算机操作和基本概念。
3. 数学基础：具备一定的逻辑思维和数学运算能力。
4. 电路知识：如直流电、交流电等。
5. 自动化概念：了解自动化系统的基本组成和工作原理。
6. 编程基础：虽然 PLC 编程语言相对简单，但有编程基础会更容易上手。
7. 物理基础：对物理概念有一定的了解。
8. 电子元件知识：例如传感器、接触器等。
9. 系统集成概念：理解各个组件如何协同工作。
具备这些基础知识将有助于更好地理解和掌握 PLC 编程技术。同时，学习者还需要具备以下素质：
10. 学习兴趣和动力。
11. 耐心和细心，注重细节。
12. 良好的问题解决能力。
13. 实践动手能力，通过实际操作加深理解。
14. 持续学习的态度，跟上技术的发展。

支持(0) 反对(0)

end

posted @ 2023-03-09 21:50 siemens800 阅读(59) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· directory server / openldap / Lightweight Directory Access Protocol / Free IPA / phpladpadmin / ladp browser

· java io / Serializable / Externalizable / ProtoBuf / ZSTD

· IOT设备中常见的协议简单论述

· Python中socket解读

阅读排行：
· 阿里最新开源QwQ-32B，效果媲美deepseek-r1满血版，部署成本又又又降低了！
· SQL Server 2025 AI相关能力初探
· 单线程的Redis速度为什么快？
· AI编程工具终极对决：字节Trae VS Cursor，谁才是开发者新宠？
· 开源Multi-agent AI智能体框架aevatar.ai，欢迎大家贡献代码

天行健 - Lindows

python hardware / mqtt / CoAP / modbus / freemodbus / rs485 / tcp / udp / http / https / SOME / DDS / ICMP

- 嵌入式协议环境准备

- 嵌入式学习路线

- ICMP（Internet Control Message Protocol） ping协议

- DDS（Data Distribution Service）实时系统中数据分发和通信的协议

- SOME/IP (Service-Oriented Middleware for Embedded Systems over IP）嵌入式中间件协议

- mqtt 协议

- coap 协议

- modbus 协议 / freemodbus

- rs485 协议

- tcp 协议

- udp 协议

- http 协议

- https 协议

- 韦根接口/门禁系统

- PLC 编程相关 / 电气工程师

公告

搜索

积分与排名

随笔分类 (387)

	from scapy.all import IP, ICMP, sr1
	'''
	1、pip install scapy 安装包
	2、在Python中，你可以使用第三方库Scapy来构建和解析ICMP（Internet Control Message Protocol）消息。
	3、Scapy是一个功能强大的网络工具，可以用于创建、发送和接收各种网络协议的数据包。
	4、以下是一个简单的Python示例，演示如何使用Scapy发送和接收ICMP消息：
	5、示例中，我们使用Scapy创建了两种不同类型的ICMP消息，一个普通的ICMP请求（不关联ping），另一个是ICMP回显请求（ping）。
	6、然后，我们使用sr1函数发送这些请求并等待响应。最后，我们显示接收到的ICMP响应或回显响应的信息。
	'''

	# 构建 ICMP 请求数据包
	target_ip = "www.example.com"
	icmp_request = IP(dst=target_ip) / ICMP()

	# 发送 ICMP 请求并等待响应
	icmp_response = sr1(icmp_request, timeout=2, verbose=False)

	# 处理响应
	if icmp_response:
	print("ICMP Response received from", target_ip)
	icmp_response.show()
	else:
	print("No ICMP Response received")

	# 构建 ICMP 回显请求（ping）数据包
	ping_request = IP(dst=target_ip) / ICMP(type=8, code=0) # ICMP Echo Request

	# 发送 ICMP 回显请求
	ping_response = sr1(ping_request, timeout=2, verbose=False)

	# 处理回显响应
	if ping_response:
	print("Ping Response received from", target_ip)
	ping_response.show()
	else:
	print("No Ping Response received")

	from rticonnextdds_connector import Connector, ConnextDynamicData

	'''
	DDS（Data Distribution Service）是一种用于实时系统中数据分发和通信的协议。
	DDS提供了一种高性能、松耦合、实时性强的消息传递机制。
	在Python中，你可以使用第三方的DDS库来实现DDS通信。
	其中一种流行的DDS实现是RTI Connext DDS。
	以下是一个简单的示例，演示如何使用RTI Connext DDS的Python API进行发布和订阅消息：
	首先，确保你已经安装了RTI Connext DDS，并按照相关的文档设置好你的环境。
	然后，你可以使用以下代码示例：
	'''

	# 创建DDS连接
	connector = Connector('MyPublisher::MyParticipantLibrary::MyParticipant', 'MyPublisher::MyPublisherProfile')

	# 获取输出实体
	output_entity = connector.getOutput('MyPublisher::MyWriter::MyWriterProfile')

	# 创建DynamicData实例
	output_data = ConnextDynamicData(output_entity.type)

	# 准备发送的数据
	data_values = {'x': 42, 'y': 3.14, 'message': 'Hello, DDS!'}
	output_data.set_dictionary(data_values)

	# 发布数据
	output_entity.instance.set_values_from(output_data)
	output_entity.write()

	# 关闭连接
	connector.close()

	from rticonnextdds_connector import Connector, ConnextDynamicData
	'''
	这是一个简化的示例。在实际应用中，你需要更多的错误处理和配置。
	此外，确保配置文件（MyPublisher.xml和MySubscriber.xml）中的实体和配置与你的DDS实例匹配。
	确保查阅RTI Connext DDS的文档以获取更详细的信息和配置。
	'''

	# 创建DDS连接
	connector = Connector('MySubscriber::MyParticipantLibrary::MyParticipant', 'MySubscriber::MySubscriberProfile')

	# 获取输入实体
	input_entity = connector.getInput('MySubscriber::MyReader::MyReaderProfile')

	# 创建DynamicData实例
	input_data = ConnextDynamicData(input_entity.type)

	# 订阅数据
	input_entity.read()

	# 获取数据
	for sample in input_entity.samples.valid_data_iter:
	input_data.copy_from(sample.get_dictionary())

	# 处理接收到的数据
	received_values = input_data.get_dictionary()
	print("Received Data:", received_values)

	# 关闭连接
	connector.close()

	import socket
	import struct
	import msgpack

	'''
	SOME/IP协议的Python实现通常需要使用第三方库或模块，而目前并没有标准的Python库专门用于SOME/IP。
	然而，你可以使用一些支持UDP通信和消息序列化的库来创建自己的SOME/IP通信实现。
	以下是Python简单示例，使用Socket和MessagePack库模拟SOME/IP的部分功能,实际应用中可能需要更多的功能和错误处理。
	此外，确保接收端服务器（在示例中是localhost:12345）能够解析和处理SOME/IP消息。
	'''

	# 定义SOME/IP消息头
	def create_someip_header(service_id, method_id):
	header = {
	"message_id": 0, # 消息ID，通常在实际应用中需要唯一标识每个消息
	"length": 0, # 消息长度，后续根据实际消息内容计算
	"request_id": 1, # 请求ID，用于匹配请求和响应
	"protocol_version": 1, # SOME/IP协议版本
	"interface_version": 1, # 接口版本
	"message_type": 0x01, # 请求消息类型
	"return_code": 0, # 返回代码，通常为0表示成功
	"service_id": service_id, # 服务ID
	"method_id": method_id, # 方法ID
	}
	return msgpack.packb(header)

	# 发送SOME/IP消息
	def send_someip_message(service_id, method_id, payload):
	# 创建Socket连接
	with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
	# 服务器地址和端口
	server_address = ('localhost', 12345)

	# 构造SOME/IP消息头
	header = create_someip_header(service_id, method_id)

	# 计算消息长度
	length = len(header) + len(payload)
	struct.pack_into('!I', header, 4, length)

	# 合并消息头和有效载荷
	message = header + payload

	# 发送消息
	s.sendto(message, server_address)

	# 例子：发送一个简单的SOME/IP消息
	service_id = 0x1234
	method_id = 0x5678
	payload_data = {'param1': 42, 'param2': 'Hello, SOME/IP!'}
	payload = msgpack.packb(payload_data)

	send_someip_message(service_id, method_id, payload)

天行健 - Lindows

python hardware / mqtt / CoAP / modbus / freemodbus / rs485 / tcp / udp / http / https / SOME / DDS / ICMP

- 嵌入式协议环境准备

- 嵌入式学习路线

- ICMP（Internet Control Message Protocol） ping协议

- DDS（Data Distribution Service）实时系统中数据分发和通信的协议

- SOME/IP (Service-Oriented Middleware for Embedded Systems over IP） 嵌入式中间件协议

- mqtt 协议

- coap 协议

- modbus 协议 / freemodbus

- rs485 协议

- tcp 协议

- udp 协议

- http 协议

- https 协议

- 韦根接口/门禁系统

- PLC 编程相关 / 电气工程师

公告

搜索

积分与排名

随笔分类 (387)

- SOME/IP (Service-Oriented Middleware for Embedded Systems over IP）嵌入式中间件协议