0

我正在尝试使用此草图将数据从 python 写入串行

import serial
import smtplib
import time
s=serial.Serial('/dev/tty.usbserial-AH01LLHS',9600)
precx=500
ist=30
i=0
while True:
    s.write('1')
    stringa=s.readline()
    array=stringa.split(',')
    x=int(array[0])
    y=int(array[1])
    z=int(array[2])
    print(x,y,z)
    if(precx!=500):
        diffx=abs(x-precx)
        diffy=abs(y-precy)
        diffz=abs(z-precz)

        if((diffx>ist)|(diffy>ist)|(diffz>ist)):
            print('Ohu god',i)
            i+=1
            #time.sleep(2)
    precx=x
    precy=y
    precz=z

但是当我执行程序时，我在控制台上什么也看不到，并且 Arduino Rx 指示灯熄灭。

这是我的 Arduino 草图（纳米 atmega 328）：

//Add the SPI library so we can communicate with the ADXL345 sensor
#include <SPI.h>

//Assign the Chip Select signal to pin 10.
int CS=10;

//This is a list of some of the registers available on the ADXL345.
//To learn more about these and the rest of the registers on the ADXL345, read the datasheet!
char POWER_CTL = 0x2D;  //Power Control Register
char DATA_FORMAT = 0x31;
char DATAX0 = 0x32; //X-Axis Data 0
char DATAX1 = 0x33; //X-Axis Data 1
char DATAY0 = 0x34; //Y-Axis Data 0
char DATAY1 = 0x35; //Y-Axis Data 1
char DATAZ0 = 0x36; //Z-Axis Data 0
char DATAZ1 = 0x37; //Z-Axis Data 1
//This buffer will hold values read from the ADXL345 registers.
char values[10];
//These variables will be used to hold the x,y and z axis accelerometer values.
int x,y,z;
boolean snd;
void setup(){ 
  //Initiate an SPI communication instance.
  SPI.begin();
  //Configure the SPI connection for the ADXL345.
  SPI.setDataMode(SPI_MODE3);
  //Create a serial connection to display the data on the terminal.
  Serial.begin(9600);

  //Set up the Chip Select pin to be an output from the Arduino.
  pinMode(CS, OUTPUT);
  //Before communication starts, the Chip Select pin needs to be set high.
  digitalWrite(CS, HIGH);

  //Put the ADXL345 into +/- 4G range by writing the value 0x01 to the DATA_FORMAT register.
  writeRegister(DATA_FORMAT, 0x01);
  //Put the ADXL345 into Measurement Mode by writing 0x08 to the POWER_CTL register.
  writeRegister(POWER_CTL, 0x08);  //Measurement mode  
}

void loop(){
  //snd=true;
  //Reading 6 bytes of data starting at register DATAX0 will retrieve the x,y and z acceleration values from the ADXL345.
  //The results of the read operation will get stored to the values[] buffer.
  readRegister(DATAX0, 6, values);

  //The ADXL345 gives 10-bit acceleration values, but they are stored as bytes (8-bits). To get the full value, two bytes must be combined for each axis.
  //The X value is stored in values[0] and values[1].
  x = ((int)values[1]<<8)|(int)values[0];
  //The Y value is stored in values[2] and values[3].
  y = ((int)values[3]<<8)|(int)values[2];
  //The Z value is stored in values[4] and values[5].
  z = ((int)values[5]<<8)|(int)values[4];
 if (Serial.available() > 0) {
   if(Serial.read()=='1'){
     snd=true;
   }
   else{
     snd=false;
   }
 }
 if(snd){
  //Print the results to the terminal.
  Serial.print(x, DEC);
  Serial.print(',');
  Serial.print(y, DEC);
  Serial.print(',');
  Serial.print(z, DEC);
  Serial.println("");
  delay(10); 
 }

}

//This function will write a value to a register on the ADXL345.
//Parameters:
//  char registerAddress - The register to write a value to
//  char value - The value to be written to the specified register.
void writeRegister(char registerAddress, char value){
  //Set Chip Select pin low to signal the beginning of an SPI packet.
  digitalWrite(CS, LOW);
  //Transfer the register address over SPI.
  SPI.transfer(registerAddress);
  //Transfer the desired register value over SPI.
  SPI.transfer(value);
  //Set the Chip Select pin high to signal the end of an SPI packet.
  digitalWrite(CS, HIGH);
}

//This function will read a certain number of registers starting from a specified address and store their values in a buffer.
//Parameters:
//  char registerAddress - The register addresse to start the read sequence from.
//  int numBytes - The number of registers that should be read.
//  char * values - A pointer to a buffer where the results of the operation should be stored.
void readRegister(char registerAddress, int numBytes, char * values){
  //Since we're performing a read operation, the most significant bit of the register address should be set.
  char address = 0x80 | registerAddress;
  //If we're doing a multi-byte read, bit 6 needs to be set as well.
  if(numBytes > 1)address = address | 0x40;

  //Set the Chip select pin low to start an SPI packet.
  digitalWrite(CS, LOW);
  //Transfer the starting register address that needs to be read.
  SPI.transfer(address);
  //Continue to read registers until we've read the number specified, storing the results to the input buffer.
  for(int i=0; i<numBytes; i++){
    values[i] = SPI.transfer(0x00);
  }
  //Set the Chips Select pin high to end the SPI packet.
  digitalWrite(CS, HIGH);
}

提前致谢。

4

1 回答 1

0

您绝对应该检查评论中的建议：

  • 使程序更简单，以便它始终发送没有“流控制”的值（使用您发送的“1”字节），
  • 使用串行监视器检查输出。

首先，您应该检查是否在帮助s.flush()之前和之后添加了一个s.write('1')。然后你可能也想添加flush()你的 arduino 代码。

对我来说，在你的“流量控制”算法的初始化中，它看起来真的是一个令人担忧的问题。在纸上看起来不错，但在现实生活中，它可能不会。很多时候，Arduino 在开始填满主机串行端口的缓冲区时会发送大量垃圾。反之亦然。因此，您可能会得到一个完全没用的，而不是1在 arduino 方面。!@#$@#%@#%!@#$

因此，在任何一方，在进入循环之前，您都应该添加一个 init 协议。arduino 发送READY，主机发送READY，你把所有东西都冲洗掉，直到你READY两边都得到。看起来像：

void setup() {
    Serial.begin(9600);
    Serial.println('READY');
    Serial.flush();
    char ch1 = 0, ch2 = 0;
    char incomingByte = 0;
    while (ch1 != 'O' && ch2 != 'K') {
        ch1 = Serial.read();
        if (ch1 == 'O' && ch2 == 'K')
            break;
        ch2 = Serial.read();
    }
}

在python方面：

with serial.Serial('/dev/tty.usbserial-AH01LLHS',9600) as s:
    s.flush()
    ready = ""
    while ready != "READY":
        ready = s.readline()
        s.flush()
    while True:
        # ... you stuff

当然，这只是你可以做什么的一个想法。你可以让它更复杂，或者更简单。但是在进行这样的流量控制之前，您确实需要创建一个交汇点。

于 2013-06-14T16:42:40.373 回答