GVKun编程网logo

Raspberry Pi 和 Arduino 不与 Python Serial 通信（arduino和raspberry的区别）

2

这篇文章主要围绕RaspberryPi和Arduino不与PythonSerial通信和arduino和raspberry的区别展开，旨在为您提供一份详细的参考资料。我们将全面介绍RaspberryP

这篇文章主要围绕Raspberry Pi 和 Arduino 不与 Python Serial 通信和arduino和raspberry的区别展开，旨在为您提供一份详细的参考资料。我们将全面介绍Raspberry Pi 和 Arduino 不与 Python Serial 通信的优缺点，解答arduino和raspberry的区别的相关问题，同时也会为您带来Arduino + RFID 读取 IC 卡 Arduino uno中获得RFID的UID 并通过串口转发RFID卡号、Arduino - Raspberry Pi，使用 D-BUS API 的蓝牙连接、Arduino JSON over Serial，Json.Parse 返回意外的 JSON 输入、Arduino Serial.Available() 在 255 个字节后为假的实用方法。

本文目录一览：

Raspberry Pi 和 Arduino 不与 Python Serial 通信（arduino和raspberry的区别）

Raspberry Pi 和 Arduino 不与 Python Serial 通信（arduino和raspberry的区别）

如何解决Raspberry Pi 和 Arduino 不与 Python Serial 通信

我正在尝试让 RaspBerry Pi 向 Arduino 发送串行命令，然后 Arduino 解释该命令并相应地打开或关闭引脚。我已经编写了一个 python 脚本，它简单地接受命令（它是一个整数）并将其转换为字符串，然后再对其进行编码并通过串行方式将其发送到 Arduino。当我在命令行上尝试每个命令时，我得到了预期的结果并且 Arduino 会打开，但是当我尝试使用命令作为参数运行脚本时，它不起作用。一路上我没有收到任何错误，并且在发送命令之前的所有打印都符合预期。我大致遵循本教程：

https://roboticsbackend.com/raspberry-pi-arduino-serial-communication/

Python 代码：

  1. import serial
  2. import sys
  3. import time
  5. command = sys.argv[1]
  7. if __name__ == ''__main__'':
  8.     print(command)
  9.     ser=serial.Serial(''/dev/ttyACM0'',9600,timeout=1)
  10.     print((str(command)+"\\n").encode(''ascii''))
  11.     ser.write((str(command)+"\\n").encode(''ascii''))
  12.     time.sleep(0.2)
  13.     response = ser.readline().decode(''ascii'').rstrip()
  14.     f=open(''/home/pi/responselog.txt'',''w'')
  15.     f.write(response)
  16.     f.close()
  17.     ser.close()

通过脚本尝试命令 118 时返回：

  1. 118
  2. b''118\\n''

通过Python shell执行write命令时返回：

  1. 4

Arduino 代码：

  1. #define F_cpu 16000000L //defines clock frequency
  3. #include <avr/io.h> // Call in the AVR/IO library
  4. #include <avr/delay.h> //Call in the AVR/delay library
  5. #include <Arduino.h> //Call in the Arduino library
  7. int incomingByte = 0;
  8. int incoming[3];
  10. int command = 0;
  11. int ActivePump = 1;
  12. int error = 0;
  14. void setup() {
  15.   Serial.begin(9600);
  17.   // Set data direction registers for digital pins: each bit is set to 1 for output,0 for input
  18.   DDRA = 0xFF;
  19.   DDRB = 0b00001111;
  20.   DDRC = 0xFF;
  21.   DDRD = 0x8F;
  22.   DDRE = 0x38;
  23.   DDRG = 0x27;
  24.   DDRH = 0x08;
  25.   DDRJ = 0x00;
  26.   DDRL = 0xFF;
  29.   //Set inital port values for digital pins
  30.   PORTA = 0;
  31.   PORTB = 0xF0;
  32.   PORTC = 0;
  33.   PORTD = 0;
  34.   PORTE = 0;
  35.   PORTG = 0;
  36.   PORTH = 0x73;
  37.   PORTJ = 0x03;
  38.   PORTL = 0;
  39. }
  41. /*int ReadFlowRate(SensorNum) {
  42.   SIGNAL(TIMER0_COMPA_vect){
  43.     
  44.   }
  46. }*/
  48. int ActivatePump(){
  49.   if((PINB4 && ActivePump == 1) || (PINB5 && ActivePump == 2)){
  51.     error = 1;
  52.     return 1;
  53.   }
  55.   if(ActivePump == 1){
  56.     PORTE += 0x10;
  57.     return 0;
  58.   } else {
  59.     PORTE += 0x20;
  60.     return 0;
  61.   }
  62. }
  64. void StopPump(){
  65.   if(ActivePump == 1){
  66.     PORTE -= 0x10;
  67.   } else {
  68.     PORTE -= 0x20;
  69.   }
  70. }
  72. void OpenMains(){
  73.   PORTG += 0x20;
  74.   PORTE += 0x08;
  75.   PORTH += 0x08;
  76. }
  78. void CloseMains(){
  79.   PORTG -= 0x20;
  80.   PORTE -= 0x08;
  81.   PORTH -= 0x08;
  82. }
  84. void loop() {
  85.   if(Serial.available()){
  87.     char First = Serial.read();
  88.     // Serial.println(First); Debugging for serial communication
  89.     if(First >= ''0'' && First <= ''9''){
  90.         command = (command*10)+(First-48); 
  91.       } /*code for debugging the serial communication
  93.       else if(First == 10){ 
  95.         Serial.print("Command received: ");
  96.         Serial.println(command);      
  97.         }
  99.     Serial.print("Command received: ");
  100.     Serial.println(command);*/
  101.     }
  103.     int commandClass = command/100;
  104.     int SubCommand = command-(commandClass*100);
  106.     if(commandClass == 1){
  108.       //1xx commands turn on digital pins
  110.       switch(SubCommand){
  111.         case 02:
  112.           PORTE += 0x10;
  113.           command = 0;
  114.           break;
  115.         case 03:
  116.           PORTE += 0x20;
  117.           command = 0;
  118.           break;
  119.         case 04:
  120.           PORTG += 0x20;
  121.           command = 0;
  122.           break;
  123.         case 05:
  124.           PORTE += 0x08;
  125.           command = 0;
  126.           break;
  127.         case 06:
  128.           PORTH += 0x08;
  129.           command = 0;
  130.           Serial.println("Received");
  131.           break;
  132.         //Skipping 107-117 because those are input pins
  133.         case 18:
  134.           PORTD += 0x08;
  135.           command = 0;
  136.           break;
  137.         case 19:
  138.           PORTD += 0x04;
  139.           command = 0;
  140.           break;
  141.         case 20:
  142.           PORTD +=0x02;
  143.           command = 0;
  144.           break;
  145.         case 21:
  146.           PORTD += 0x01;
  147.           command = 0;
  148.           break;
  149.         case 22:
  150.           PORTA += 0x01;
  151.           command = 0;
  152.           break;
  153.         case 23:
  154.           PORTA +=0x02;
  155.           command = 0;
  156.           break;
  157.         case 24:
  158.           PORTA += 0x04;
  159.           command = 0;
  160.           break;
  161.         case 25:
  162.           PORTA += 0x08;
  163.           command = 0;
  164.           break;
  165.         case 26:
  166.           PORTA += 0x10;
  167.           command = 0;
  168.           break;
  169.         case 27:
  170.           PORTA += 0x20;
  171.           command = 0;
  172.           break;
  173.         case 28:
  174.           PORTA += 0x40;
  175.           command = 0;
  176.           break;
  177.         case 29:
  178.           PORTA += 0x80;
  179.           command = 0;
  180.           break;
  181.         case 30:
  182.           PORTC += 0x80;
  183.           command = 0;
  184.           break;
  185.         case 31:
  186.           PORTC += 0x40;
  187.           command = 0;
  188.           break;
  189.         case 32:
  190.           PORTC += 0x20;
  191.           command = 0;
  192.           break;
  193.         case 33:
  194.           PORTC += 0x10;
  195.           command = 0;
  196.           break;
  197.         case 34:
  198.           PORTC += 0x08;
  199.           command = 0;
  200.           break;
  201.         case 35:
  202.           PORTC += 0x04;
  203.           command = 0;
  204.           break;
  205.         case 36:
  206.           PORTC +=0x02;
  207.           command = 0;
  208.           break;
  209.         case 37:
  210.           PORTC += 0x01;
  211.           command = 0;
  212.           break;
  213.         case 38:
  214.           PORTD += 0x80;
  215.           command = 0;
  216.           break;
  217.         case 39:
  218.           PORTG += 0x04;
  219.           command = 0;
  220.           break;
  221.         case 40:
  222.           PORTG +=0x02;
  223.           command = 0;
  224.           break;
  225.         case 41:
  226.           PORTG += 0x01;
  227.           command = 0;
  228.           break;
  229.         case 42:
  230.           PORTL += 0x80;
  231.           command = 0;
  232.           break;
  233.         case 43:
  234.           PORTL += 0x40;
  235.           command = 0;
  236.           break;
  237.         case 44:
  238.           PORTL += 0x20;
  239.           command = 0;
  240.           break;
  241.         case 45:
  242.           PORTL += 0x10;
  243.           command = 0;
  244.           break;
  245.         case 46:
  246.           PORTL += 0x08;
  247.           command = 0;
  248.           break;
  249.         case 47:
  250.           PORTL += 0x04;
  251.           command = 0;
  252.           break;
  253.         case 48:
  254.           PORTL +=0x02;
  255.           command = 0;
  256.           break;
  257.         case 49:
  258.           PORTL += 0x01;
  259.           command = 0;
  260.           break;
  261.         case 50:
  262.           PORTB += 0x08;
  263.           command = 0;
  264.           break;
  265.         case 51:
  266.           PORTB += 0x04;
  267.           command = 0;
  268.           break;
  269.         case 52:
  270.           PORTB +=0x02;
  271.           command = 0;
  272.           break;
  273.         case 53:
  274.           PORTB += 0x01;
  275.           command = 0;
  276.           break;
  277.       }
  278.     } else if(commandClass==2){
  280.       //2xx commands turn off digital pins
  282.       switch(SubCommand){
  283.         case 02:
  284.           PORTE -= 0x10;
  285.           command = 0;
  286.           break;
  287.         case 03:
  288.           PORTE -= 0x20;
  289.           command = 0;
  290.           break;
  291.         case 04:
  292.           PORTG -= 0x20;
  293.           command = 0;
  294.           break;
  295.         case 05:
  296.           PORTE -= 0x08;
  297.           command = 0;
  298.           break;
  299.         case 06:
  300.           PORTH -= 0x08;
  301.           command = 0;
  302.           break;
  303.         //Skipping 207-217 because those are input pins
  304.         case 18:
  305.           PORTD -= 0x08;
  306.           command = 0;
  307.           break;
  308.         case 19:
  309.           PORTD -= 0x04;
  310.           command = 0;
  311.           break;
  312.         case 20:
  313.           PORTD -=0x02;
  314.           command = 0;
  315.           break;
  316.         case 21:
  317.           PORTD -= 0x01;
  318.           command = 0;
  319.           break;
  320.         case 22:
  321.           PORTA -= 0x01;
  322.           command = 0;
  323.           break;
  324.         case 23:
  325.           PORTA -=0x02;
  326.           command = 0;
  327.           break;
  328.         case 24:
  329.           PORTA -= 0x04;
  330.           command = 0;
  331.           break;
  332.         case 25:
  333.           PORTA -= 0x08;
  334.           command = 0;
  335.           break;
  336.         case 26:
  337.           PORTA -= 0x10;
  338.           command = 0;
  339.           break;
  340.         case 27:
  341.           PORTA -= 0x20;
  342.           command = 0;
  343.           break;
  344.         case 28:
  345.           PORTA -= 0x40;
  346.           command = 0;
  347.           break;
  348.         case 29:
  349.           PORTA -= 0x80;
  350.           command = 0;
  351.           break;
  352.         case 30:
  353.           PORTC -= 0x80;
  354.           command = 0;
  355.           break;
  356.         case 31:
  357.           PORTC -= 0x40;
  358.           command = 0;
  359.           break;
  360.         case 32:
  361.           PORTC -= 0x20;
  362.           command = 0;
  363.           break;
  364.         case 33:
  365.           PORTC -= 0x10;
  366.           command = 0;
  367.           break;
  368.         case 34:
  369.           PORTC -= 0x08;
  370.           command = 0;
  371.           break;
  372.         case 35:
  373.           PORTC -= 0x04;
  374.           command = 0;
  375.           break;
  376.         case 36:
  377.           PORTC -=0x02;
  378.           command = 0;
  379.           break;
  380.         case 37:
  381.           PORTC -= 0x01;
  382.           command = 0;
  383.           break;
  384.         case 38:
  385.           PORTD -= 0x80;
  386.           command = 0;
  387.           break;
  388.         case 39:
  389.           PORTG -= 0x04;
  390.           command = 0;
  391.           break;
  392.         case 40:
  393.           PORTG -=0x02;
  394.           command = 0;
  395.           break;
  396.         case 41:
  397.           PORTG -= 0x01;
  398.           command = 0;
  399.           break;
  400.         case 42:
  401.           PORTL -= 0x80;
  402.           command = 0;
  403.           break;
  404.         case 43:
  405.           PORTL -= 0x40;
  406.           command = 0;
  407.           break;
  408.         case 44:
  409.           PORTL -= 0x20;
  410.           command = 0;
  411.           break;
  412.         case 45:
  413.           PORTL -= 0x10;
  414.           command = 0;
  415.           break;
  416.         case 46:
  417.           PORTL -= 0x08;
  418.           command = 0;
  419.           break;
  420.         case 47:
  421.           PORTL -= 0x04;
  422.           command = 0;
  423.           break;
  424.         case 48:
  425.           PORTL -=0x02;
  426.           command = 0;
  427.           break;
  428.         case 49:
  429.           PORTL -= 0x01;
  430.           command = 0;
  431.           break;
  432.         case 50:
  433.           PORTB -= 0x08;
  434.           command = 0;
  435.           break;
  436.         case 51:
  437.           PORTB -= 0x04;
  438.           command = 0;
  439.           break;
  440.         case 52:
  441.           PORTB -=0x02;
  442.           command = 0;
  443.           break;
  444.         case 53:
  445.           PORTB -= 0x01;
  446.           command = 0;
  447.           break;
  448.       }
  449.     } else if(commandClass==3){
  451.       //3xx commands control pumps (302 & 303) and activate and deactivate water change (318-389)
  452.       switch(SubCommand){
  453.         case 02:
  454.           ActivePump = 1;
  455.           command = 0;
  456.           break;
  457.         case 03:
  458.           ActivePump = 2;
  459.           break;
  460.         case 18:
  461.           int errorCheck = ActivatePump();
  462.           if(errorCheck == 0){
  463.             OpenMains();
  464.             PORTD += 0x08;
  465.             command = 0;
  466.             break;
  467.           } else {
  468.             command = 0;
  469.             break;
  470.           }
  471.         case 54:
  472.           PORTD -= 0x08;
  473.           CloseMains();
  474.           StopPump();
  475.           break;
  477.       }
  478.     } else if(commandClass == 4){
  480.       //4xx commands read analog inputs
  481.       switch(SubCommand){
  483.       }
  484.     } else if(commandClass == 5){
  486.       //5xx commands read digital inputs
  487.       switch(SubCommand){
  489.       }
  490.     }/*case 400:
  491.         int initalRead; 
  492.         initialRead = analogRead(A0);
  493.         Serial.println(initialRead);
  494.         command = 0;
  495.         break;*/    
  497. }

编辑：我想通了。显然 ser.readline() 命令抛出了一个异常，该异常在我将监控程序连接到串行端口之前由于某种原因没有打印出来，然后它抛出了异常。我注释掉了那行，现在它完美无缺。

编辑 2： 好吧，我说得太早了。如果没有连接串行监视器程序，脚本仍然无法运行。

Arduino + RFID 读取 IC 卡 Arduino uno中获得RFID的UID 并通过串口转发RFID卡号

Arduino + RFID 读取 IC 卡 Arduino uno中获得RFID的UID 并通过串口转发RFID卡号

RFID简介：射频识别即RFID（Radio Frequency IDentification）技术，又称无线射频识别，是一种通信技术，可通过无线电讯号识别特定目标并读写相关数据，而无需识别系统与特定目标之间建立机械或光学接触。常用的有低频（125k~134.2K）、高频（13.56Mhz）、超高频，微波等技术。RFID读写器也分移动式的和固定式的，目前RFID技术应用很广，如：图书馆，门禁系统，食品安全溯源等。

硬件准备

（基于Arduino的开发板、MFRC522读卡器模块）
Arduino Uno * 1
在这里插入图片描述
RFID-RC522 模块 * 1
在这里插入图片描述
IC卡 * 1-2
在这里插入图片描述
RFID技术现在都非常成熟和应用广泛，今天我们就来看看这个RFID如何实现读取里面的数据

接线

Arduino Uno <—> RFID-RC522
10 <—> SDA
13 <—> SCK
11 <—> MOSI
12 <—> MISO
null <—> IRQ
GND <—> GND
9 <—> RST
3.3V <—> 3.3V

需要用到RFID-RC522的库

法一、下载：https://github.com/miguelbalboa/rfid
下载解压到Arduino IDE的安装路径里的库文件夹libraries
https://download.csdn.net/download/v86337286/11813061

法二、点开管理库，在搜索栏里输入RC522，找到图中的库，
在这里插入图片描述
在这里插入图片描述
点击安装（我这图是已经安装过）
在这里插入图片描述

示例代码 .

Arduino + RFID 读取 IC 卡信息

读取 IC 卡信息后并通过串口将卡号及0扇区卡号数据打印出来，其他15个扇区不显示扇区内容
代码如下

/*
 * --------------------------------------------------------------------------------------------------------------------
 * Example sketch/program showing how to read data from a PICC to serial.
 * --------------------------------------------------------------------------------------------------------------------
 * This is a MFRC522 library example; for further details and other examples see: https://github.com/miguelbalboa/rfid
 * 
 * Example sketch/program showing how to read data from a PICC (that is: a RFID Tag or Card) using a MFRC522 based RFID
 * Reader on the Arduino SPI interface.
 * 
 * When the Arduino and the MFRC522 module are connected (see the pin layout below), load this sketch into Arduino IDE
 * then verify/compile and upload it. To see the output: use Tools, Serial Monitor of the IDE (hit Ctrl+Shft+M). When
 * you present a PICC (that is: a RFID Tag or Card) at reading distance of the MFRC522 Reader/PCD, the serial output
 * will show the ID/UID, type and any data blocks it can read. Note: you may see "Timeout in communication" messages
 * when removing the PICC from reading distance too early.
 * 
 * If your reader supports it, this sketch/program will read all the PICCs presented (that is: multiple tag reading).
 * So if you stack two or more PICCs on top of each other and present them to the reader, it will first output all
 * details of the first and then the next PICC. Note that this may take some time as all data blocks are dumped, so
 * keep the PICCs at reading distance until complete.
 * 
 * @license Released into the public domain.
 * 
 * Typical pin layout used:
 * -----------------------------------------------------------------------------------------
 *             MFRC522      Arduino       Arduino   Arduino    Arduino          Arduino
 *             Reader/PCD   Uno/101       Mega      Nano v3    Leonardo/Micro   Pro Micro
 * Signal      Pin          Pin           Pin       Pin        Pin              Pin
 * -----------------------------------------------------------------------------------------
 * RST/Reset   RST          9             5         D9         RESET/ICSP-5     RST
 * SPI SS      SDA(SS)      10            53        D10        10               10
 * SPI MOSI    MOSI         11 / ICSP-4   51        D11        ICSP-4           16
 * SPI MISO    MISO         12 / ICSP-1   50        D12        ICSP-1           14
 * SPI SCK     SCK          13 / ICSP-3   52        D13        ICSP-3           15
 */
 
#include <SPI.h>
#include <MFRC522.h>
 
#define RST_PIN         9          // Configurable, see typical pin layout above
#define SS_PIN          10         // Configurable, see typical pin layout above
 
MFRC522 mfrc522(SS_PIN, RST_PIN);  // Create MFRC522 instance
 
void setup() {
    Serial.begin(9600);     // Initialize serial communications with the PC
    while (!Serial);        // Do nothing if no serial port is opened (added for Arduinos based on ATMEGA32U4)
    SPI.begin();            // Init SPI bus
    mfrc522.PCD_Init();     // Init MFRC522
    mfrc522.PCD_DumpVersionToSerial();  // Show details of PCD - MFRC522 Card Reader details
    Serial.println(F("Scan PICC to see UID, SAK, type, and data blocks..."));
}
 
void loop() {
    // Look for new cards
    if ( ! mfrc522.PICC_IsNewCardPresent()) {
        return;
    }
 
    // Select one of the cards
    if ( ! mfrc522.PICC_ReadCardSerial()) {
        return;
    }
 
    // Dump debug info about the card; PICC_HaltA() is automatically called
    mfrc522.PICC_DumpToSerial(&(mfrc522.uid));
}

运行此代码并将其中一张卡放入RFID卡时，很多信息显示在Arduino IDE的串行监视器上
在这里插入图片描述

看完了上面那如何在Arduino中获得RFID的UID？

Arduino uno中只获得RFID的UID 并通过串口转发

法一

创建了另一个函数： PICC_DumpDetailsToSerialUid(Uid *uid)


函数如下

//This is just for read UID!
void MFRC522::PICC_DumpDetailsToSerialUid(Uid *uid){
Serial.print(F(“Card JUST UID :”));
for (byte i = 0; i < uid->size; i++) {
if(uid->uidByte[i] < 0x10)
Serial.print(F(" 0"));
else
Serial.print(F(" "));
Serial.print(uid->uidByte[i], HEX);
}
Serial.println();
}

可以把它放在你需要的任何地方
示例：
在这里插入图片描述
添加该功能后，您需要进入第410行的 MFRC522.h 库并添加

void PICC_DumpDetailsToSerialUid(Uid *uid);

在该库中进行了这两次编辑后，您可以在任意位置调用该函数 .
示例：
在这里插入图片描述
用Arduino调用它： mfrc522.PICC_DumpDetailsToSerialUid(&(mfrc522.uid)); 只仅且只有一个函数用于uid读取
效果
在这里插入图片描述

法二

返回UID的函数 .

/**
 * mfrc522.PICC_IsNewCardPresent() should be checked before 
 * @return the card UID
 */
unsigned long getID(){
  if ( ! mfrc522.PICC_ReadCardSerial()) { //Since a PICC placed get Serial and continue
    return -1;
  }
  unsigned long hex_num;
  hex_num =  mfrc522.uid.uidByte[0] << 24;
  hex_num += mfrc522.uid.uidByte[1] << 16;
  hex_num += mfrc522.uid.uidByte[2] <<  8;
  hex_num += mfrc522.uid.uidByte[3];
  mfrc522.PICC_HaltA(); // Stop reading
  return hex_num;
}

例如这样使用：

if(mfrc522.PICC_IsNewCardPresent()) {
  unsigned long uid = getID();
  if(uid != -1){
    Serial.print("Card detected, UID: "); Serial.println(uid);
  }
}

在这里插入图片描述

Arduino - Raspberry Pi，使用 D-BUS API 的蓝牙连接

Arduino - Raspberry Pi，使用 D-BUS API 的蓝牙连接

如何解决Arduino - Raspberry Pi，使用 D-BUS API 的蓝牙连接

任务是使用基于python脚本的D-BUS API通过蓝牙自动实现Arduino和RaspBerry Pi之间的配对和连接过程。

连接Arduino的蓝牙模块为：Grove - Serial Bluetooth v3.0.

我能够自动化配对过程。配对脚本按顺序执行以下操作：

  1. 它通过创建适配器对象并使用 Startdiscovery 方法查找名为 Slave 的蓝牙模块。（命名在 Arduino 中完成）。
  2. 注册蓝牙代理。
  3. 如果设备尚未配对，则通过Pair方法创建设备对象和配对。

执行上述步骤的代码部分如下：

  1. register_agent()
  2. start_discovery() 
  3. time.sleep(10) 
  4. for i in range(len(address_list)):
  5.     new_dbus_device = get_device(address_list[i])
  6.     dev_path = new_dbus_device.object_path
  7.     device_properties = dbus.Interface(new_dbus_device,"org.freedesktop.DBus.Properties")
  8.     pair_status = device_properties.Get("org.bluez.Device1","Paired")
  9.     if not pair_status:
  10.         new_dbus_device.Pair(reply_handler=pair_reply,error_handler=pair_error,timeout=60000)

以下是 register_agent() 按要求执行的操作：

  1. def register_agent():    
  2.     agent = Agent(bus,path)
  3.     capability = "NoInputNoOutput"
  4.     obj = bus.get_object(BUS_NAME,"/org/bluez");
  5.     manager = dbus.Interface(obj,"org.bluez.AgentManager1")
  6.     manager.Registeragent(path,capability)

但是，当我尝试调用 Bluez 的 device-api 中记录的 Connect 方法时，它总是失败。我创建了一个自定义串行端口配置文件并尝试了 ConnectProfile 方法，但它再次失败。

如果我使用不推荐使用的 rfcomm 工具，则通过蓝牙进行通信，或者如果我使用 python 套接字模块，它也可以工作。 但是我想避免使用 rfcomm，因为它已被弃用.关于使用python socket库，连接仅在rfcomm channel 1有效，其他通道产生Connection Refused错误。

添加MRE，以更好地阐明问题：

  1. import dbus
  2. import dbus.service
  3. import dbus.mainloop.glib
  4. import sys
  5. import time
  6. import subprocess
  8. from bluezutils import *
  9. from bluetooth import *
  10. from gi.repository import GObject,GLib
  11. from dbus.mainloop.glib import DBusGMainLoop
  13. DBusGMainLoop(set_as_default=True) 
  15. path = "/test/agent"
  16. AGENT_INTERFACE = ''org.bluez.Agent1''
  17. BUS_NAME = ''org.bluez''
  18. bus = dbus.SystemBus() 
  20. device_obj = None
  21. dev_path = None
  23. def set_trusted(path2):
  24.     props = dbus.Interface(bus.get_object("org.bluez",path2),"org.freedesktop.DBus.Properties")
  25.     props.Set("org.bluez.Device1","Trusted",True)
  27. class Rejected(dbus.DBusException):
  28.     _dbus_error_name = "org.bluez.Error.Rejected"
  29.     
  30. class Agent(dbus.service.Object):
  31.     exit_on_release = True
  33.     def set_exit_on_release(self,exit_on_release):
  34.         self.exit_on_release = exit_on_release
  36.     @dbus.service.method(AGENT_INTERFACE,in_signature="",out_signature="")
  37.     def Release(self):
  38.         print("Release")
  39.         if self.exit_on_release:
  40.             mainloop.quit()
  42.     @dbus.service.method(AGENT_INTERFACE,in_signature="os",out_signature="")
  43.     def AuthorizeService(self,device,uuid):
  44.         print("AuthorizeService (%s,%s)" % (device,uuid))
  45.         return 
  47.     @dbus.service.method(AGENT_INTERFACE,in_signature="o",out_signature="s")
  48.     def RequestPinCode(self,device):
  49.         set_trusted(device)
  50.         return "0000" 
  52.     @dbus.service.method(AGENT_INTERFACE,out_signature="u")
  53.     def RequestPasskey(self,device): 
  54.         set_trusted(device)
  55.         return dbus.UInt32("0000") 
  57.     @dbus.service.method(AGENT_INTERFACE,in_signature="ou",out_signature="")
  58.     def RequestConfirmation(self,passkey):
  59.         set_trusted(device)
  60.         return 
  61.         
  62.     @dbus.service.method(AGENT_INTERFACE,out_signature="")
  63.     def RequestAuthorization(self,device):
  64.         return 
  66.     @dbus.service.method(AGENT_INTERFACE,out_signature="")
  67.     def Cancel(self):
  68.         print("Cancel")
  70. def pair_reply():
  71.     print("Device paired and trusted")
  72.     set_trusted(dev_path) 
  73.     
  74. def pair_error(error):
  75.     err_name = error.get_dbus_name()
  76.     if err_name == "org.freedesktop.DBus.Error.noreply" and device_obj:
  77.         print("Timed out. Cancelling pairing")
  78.         device_obj.CancelPairing()
  79.     else:
  80.         print("Creating device Failed: %s" % (error))
  81.     mainloop.quit() 
  82.     
  83. def register_agent():    
  84.     agent = Agent(bus,capability)
  85.     
  86. def start_discovery():
  87.     global pi_adapter
  88.     pi_adapter = find_adapter() 
  89.     scan_filter = dict({"DuplicateData": False}) 
  90.     pi_adapter.SetdiscoveryFilter(scan_filter)
  91.     pi_adapter.Startdiscovery()
  92.     
  93. def stop_discovery():
  94.     pi_adapter.Stopdiscovery()
  95.     
  96. def get_device(dev_str):
  97.     # use [Service] and [Object path]:
  98.     device_proxy_object = bus.get_object("org.bluez","/org/bluez/hci0/dev_"+dev_str)
  99.     # use [Interface]:
  100.     device1 = dbus.Interface(device_proxy_object,"org.bluez.Device1")
  101.     return device1
  103. def char_changer(text):
  104.     text = text.replace('':'',r''_'')
  105.     return text
  107. def slave_finder(device_name):
  108.     
  109.     global sublist_normal
  110.     sublist_normal = []
  111.     sublist= []
  112.     address = []
  113.     edited_address = None
  114.     sub = subprocess.run(["hcitool scan"],text = True,shell = True,capture_output=True)
  115.     print(sub.stdout) #string type
  116.     sublist = sub.stdout.split()
  117.     for i in range(len(sublist)):
  118.         if sublist[i] == device_name:
  119.             print(sublist[i-1])
  120.             sublist_normal.append(sublist[i-1])
  121.             edited_address = char_changer(sublist[i-1])
  122.             address.append(edited_address)
  123.     return address
  124.     
  125. def remove_all_paired():
  126.     for i in range(len(sublist_normal)):
  127.         sub = subprocess.run(["bluetoothctl remove " + sublist_normal[i]],capture_output=True)
  128.         time.sleep(1)
  129.     
  130.     
  131. if __name__ == ''__main__'':
  132.     
  133.     
  134.     pair_status = None
  135.     address_list = slave_finder(''Slave'') #Arduino bluetooth module named as "Slave",here we are finding it.
  136.     time.sleep(2)
  137.     remove_all_paired() #rfcomm requires repairing after release
  138.     print(sublist_normal)
  139.     if address_list: 
  140.         register_agent()
  141.         start_discovery() 
  142.         time.sleep(10) 
  143.         for i in range(len(address_list)):
  144.             new_dbus_device = get_device(address_list[i])
  145.             dev_path = new_dbus_device.object_path
  146.             device_properties = dbus.Interface(new_dbus_device,"org.freedesktop.DBus.Properties")
  147.             pair_status = device_properties.Get("org.bluez.Device1","Paired")
  148.             if not pair_status:
  149.                 new_dbus_device.Pair(reply_handler=pair_reply,timeout=60000)
  150.     
  151.     
  152.     mainloop = GLib.MainLoop()
  153.     mainloop.run()

sudo btmon 输出：

  1. Bluetooth monitor ver 5.50
  2. = Note: Linux version 5.4.83-v7l+ (armv7l)                             0.832473
  3. = Note: Bluetooth subsystem version 2.22                               0.832478
  4. = New Index: DC:A6:32:58:FE:13 (Primary,UART,hci0)              [hci0] 0.832481
  5. = Open Index: DC:A6:32:58:FE:13                                 [hci0] 0.832484
  6. = Index Info: DC:A6:32:5.. (Cypress Semiconductor Corporation)  [hci0] 0.832487
  7. @ MGMT Open: bluetoothd (privileged) version 1.14             {0x0001} 0.832490
  8. @ MGMT Open: btmon (privileged) version 1.14                  {0x0002} 0.832540

所以问题是为什么Connect和ConnectProfile方法总是失败，我需要做什么才能在Arduino和RaspBerry Pi之间建立基于D-BUS API的蓝牙通信?

解决方法

我想你已经回答了你自己的问题。 Connect 不起作用的原因是您没有在 Raspberry Pi 上运行串行端口配置文件 (SPP)。如果您运行 btmon，您会看到客户端断开连接，因为没有与 Arduino 提供的配置文件匹配。

Python Socket 连接中使用的端口号需要与 Arduino 蓝牙模块上的端口号匹配。这可能就是只有 1 起作用的原因。

作为参考，我用 Raspberry Pi 和 HC-06 对此进行了测试。我删除了所有扫描代码以尝试获得最小的可运行代码。这是我使用的代码：

  1. import socket
  2. from time import sleep
  3. import dbus
  4. import dbus.service
  5. import dbus.mainloop.glib
  6. from gi.repository import GLib
  8. BUS_NAME = ''org.bluez''
  9. AGENT_IFACE = ''org.bluez.Agent1''
  10. AGNT_MNGR_IFACE = ''org.bluez.AgentManager1''
  11. ADAPTER_IFACE = ''org.bluez.Adapter1''
  12. AGENT_PATH = ''/ukBaz/bluezero/agent''
  13. AGNT_MNGR_PATH = ''/org/bluez''
  14. DEVICE_IFACE = ''org.bluez.Device1''
  15. CAPABILITY = ''KeyboardDisplay''
  16. my_adapter_address = ''11:22:33:44:55:66''
  17. my_device_path = ''/org/bluez/hci0/dev_00_00_12_34_56_78''
  18. dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
  19. bus = dbus.SystemBus()
  22. class Agent(dbus.service.Object):
  24.     @dbus.service.method(AGENT_IFACE,in_signature=''o'',out_signature=''s'')
  25.     def RequestPinCode(self,device):
  26.         print(f''RequestPinCode {device}'')
  27.         return ''0000''
  30. class Device:
  31.     def __init__(self,device_path):
  32.         dev_obj = bus.get_object(BUS_NAME,device_path)
  33.         self.methods = dbus.Interface(dev_obj,DEVICE_IFACE)
  34.         self.props = dbus.Interface(dev_obj,dbus.PROPERTIES_IFACE)
  35.         self._port = 1
  36.         self._client_sock = socket.socket(socket.AF_BLUETOOTH,socket.SOCK_STREAM,socket.BTPROTO_RFCOMM)
  38.     def connect(self):
  39.         # self.methods.Connect()
  40.         self._client_sock.bind((my_adapter_address,self._port))
  41.         self._client_sock.connect((self.address,self._port))
  43.     def disconnect(self):
  44.         self.methods.Disconnect()
  46.     def pair(self):
  47.         self.methods.Pair(reply_handler=self._pair_reply,error_handler=self._pair_error)
  49.     def _pair_reply(self):
  50.         print(f''Device trusted={self.trusted},connected={self.connected}'')
  51.         self.trusted = True
  52.         print(f''Device trusted={self.trusted},connected={self.connected}'')
  53.         while self.connected:
  54.             sleep(0.5)
  55.         self.connect()
  56.         print(''Successfully paired and connected'')
  58.     def _pair_error(self,error):
  59.         err_name = error.get_dbus_name()
  60.         print(f''Creating device failed: {err_name}'')
  62.     @property
  63.     def trusted(self):
  64.         return bool(self.props.Get(DEVICE_IFACE,''Trusted''))
  66.     @trusted.setter
  67.     def trusted(self,value):
  68.         self.props.Set(DEVICE_IFACE,''Trusted'',bool(value))
  70.     @property
  71.     def paired(self):
  72.         return bool(self.props.Get(DEVICE_IFACE,''Paired''))
  74.     @property
  75.     def connected(self):
  76.         return bool(self.props.Get(DEVICE_IFACE,''Connected''))
  78.     @property
  79.     def address(self):
  80.         return str(self.props.Get(DEVICE_IFACE,''Address''))
  83. if __name__ == ''__main__'':
  84.     agent = Agent(bus,AGENT_PATH)
  86.     agnt_mngr = dbus.Interface(bus.get_object(BUS_NAME,AGNT_MNGR_PATH),AGNT_MNGR_IFACE)
  87.     agnt_mngr.RegisterAgent(AGENT_PATH,CAPABILITY)
  89.     device = Device(my_device_path)
  90.     if device.paired:
  91.         device.connect()
  92.     else:
  93.         device.pair()
  96.     mainloop = GLib.MainLoop()
  97.     try:
  98.         mainloop.run()
  99.     except KeyboardInterrupt:
  100.         agnt_mngr.UnregisterAgent(AGENT_PATH)
  101.         mainloop.quit()

Arduino JSON over Serial，Json.Parse 返回意外的 JSON 输入

Arduino JSON over Serial，Json.Parse 返回意外的 JSON 输入

我修好了，谢谢大家给我指明了正确的方向。问题出在我的 Arduino 代码中。我使用的是静态 JSON，它没有给我一个压缩字符串。

我将其切换为动态，如 https://arduinojson.org/ 文档中所述。

我的 Arduino 更改为以下内容。

#include <ArduinoJson.h>

void setup() {
  // put your setup code here,to run once:
  Serial.begin(9600);
}

void loop() {
  myFunction();
  delay(5000);
}

int myFunction(){
    DynamicJsonDocument doc(260);
    
    int temp = 21;
    int humidity = 99;
    
    doc["day"] = "Monday";
    doc["temperature"] = temp;
    doc["humidity"] = humidity;

    serializeJson(doc,Serial);
    Serial.println();
  }

Arduino Serial.Available() 在 255 个字节后为假

Arduino Serial.Available() 在 255 个字节后为假

由于错误发生在特定字节之后，通常意味着某种溢出。您还没有显示完整的代码，响应数组的大小是多少（或 ARRAYSIZE，因为您正在使用 memset 清除它）。很可能您的 response[index] 导致越界访问

今天关于Raspberry Pi 和 Arduino 不与 Python Serial 通信和arduino和raspberry的区别的介绍到此结束，谢谢您的阅读，有关Arduino + RFID 读取 IC 卡 Arduino uno中获得RFID的UID 并通过串口转发RFID卡号、Arduino - Raspberry Pi，使用 D-BUS API 的蓝牙连接、Arduino JSON over Serial，Json.Parse 返回意外的 JSON 输入、Arduino Serial.Available() 在 255 个字节后为假等更多相关知识的信息可以在本站进行查询。

本文标签：

上一篇将路径参数/变量从批处理文件传递到 python，sys.argv[] 仅给出最后一个目录而不是整个字符串

下一篇如何使用 python 在 Blender 2.9 中将材质的基色设置为等于顶点颜色？（blender指定上色）

相关文章