We Keep Coding

Arduino Serial Communication list doesn't get fully sent through python

I have an issue with sending serial data through python. Let me explain it this way. I have a motor code on arduino which receives data from serial and moves through the received data.
However, whenever I send data in this case 8 lists, it doesn't read the 8th list.
By playing with time.sleep in python code I could see some differences(I could see 4 lists being sent,then I increased time.sleep to 8 and now it sends 7 lists.)
I know playing with time.sleep isn't a solution though. I have also tried emptying input and output buffers and I am out of ideas on what to do next. Here are the codes.
The Python Codes:
The incoming byte will be the data sent as you can see with a for loop, I am sending the lists. The first three values inside each list is to control functions. 1,0,0 means that it will only work the motor function which I have shared in the arduino part. The 3rd and 4th variables here are for controlling the motor, meaning 1st motor will turn 2000 steps and the other will turn for a 1000 steps.
import time
import serial
def close():
arduino=serial.Serial("COM4",9600)
time.sleep(7)
incomingByte=[[1,0,0,2000,1000,1000],[1,0,0,200,100,1000],[1,0,0,250,650,1000],[1,0,0,1000,1000,1000],[1,0,0,2000,1000,1000],[1,0,0,200,100,1000],[1,0,0,250,650,1000],[1,0,0,1000,1000,1000]
length= len(incomingByte)
for i in range(uzunluk):
arduino.write(str.encode(str(incomingByte[i])))
arduino.reset_input_buffer()
arduino.reset_output_buffer()
time.sleep(7)
arduino.close()
close()
The Arduino Code:
void setup() {
pinMode(stepPin1, OUTPUT);
pinMode(dirPin1, OUTPUT);
pinMode(stepPin2, OUTPUT);
pinMode(dirPin2, OUTPUT);
pinMode(enable,OUTPUT);
pinMode(endstop1, INPUT);
pinMode(endstop2, INPUT);
Serial.begin(9600);
void motor(){
for (i=0; i < incomingdata[3]; i++) {
digitalWrite(stepPin1,HIGH);
delay(2);
digitalWrite(stepPin1,LOW);
delay(2);
}
for (i=0; i < incomingdata[4]; i++) {
digitalWrite(stepPin2,HIGH);
delay(2);
digitalWrite(stepPin2,LOW);
delay(2);
}
act_motor=0;
delay(incomingdata[5]);
Serial.flush();
}
void loop() {
if(Serial.available()){
for (a=0; a < 6; a++) {
incomingdata[a] = Serial.parseInt();
}
identifier=(incomingdata[2]);
act_enable=(incomingdata[1]);
act_motor=(incomingdata[0]);
}
if (identifier) homee();
if (act_enable) Enable();
if (act_motor) motor();
}
To simply explain the arduino code; according to the serial data the 3rd and 4th data from each array will be step numbers of how much the stepper motors will move. The 5th data on the list will be the delay for each of the motors kept waiting.
I hope I explained this clearly. I would be glad if anyone could help.
P.S: I am sorry If I have violated any rules. I will be sure to correct my mistakes.

Did you check that the numbers and the order are correct on the Arduino side?
You should always be careful with functions like parseInt that just start somewhere and do some magic.
I recommend to separate your messages using something like \r\n. Then use the normal read() until that sequence is found and until then throw everything away.
Then use parseInt (if you have to) for six times. Then repeat and start looking for the \r\n using read() again.

Python and Arduino Serial Communication: send and receive

What I want to do is actually query Arduino to get data. When I send a command from Python to Arduino, Arduino will send back some data depending on what the query keyword is. I am able to do this but with a very low speed, I wish to have a more efficient way to do this, for example, query at least 100 times per second. Any idea? Thanks!
The code I use:
Arduino:
int temp=1;
char s[2];
int speedIn=0;
void setup() {
Serial.begin(115200);
}
void loop() {
if(Serial.available()>0){
Serial.readBytes(s,1);
speedIn=int(s[0]);
if(speedIn==49){
Serial.println(">Data1Send<");
speedIn=0;
}
else if(speedIn==50){
Serial.print(">");
Serial.print(temp);
Serial.println("<");
speedIn=0;
}
else{
Serial.println(">Wrong Data<");
speedIn=0;
}
}
if(temp<300){
temp=temp+1;
}
//delay(100);
}
Python:
import serial
import time
if __name__=="__main__":
sc = serial.Serial('/dev/tty.usbmodem1421',timeout=None,baudrate=115200)
sc.flush()
while True:
#s=raw_input()
s=str(50)
if len(s) >0:
if s.isdigit():
sc.write(chr(int(s)))
time.sleep(1.0)
if sc.inWaiting()>0:
print(sc.read(sc.inWaiting()))
If I change the time delay in Python from 1.0sec to 0.1sec, it will not work any more (no data can be received and just in waiting state).

It looks like your python code does this:
Send a command
Sleep for some time (presumably to give the arduino time to reply)
Read the reply
If no reply, repeat from step 1
You mentioned that it doesn't work if the sleep period is too short. I wonder if the following could be happening. Imagine there were no sleep period. The python code will immediately check for a reply, which may not exist because the arduino hasn't had time to respond. In that case, it will immediately try to send another command. This could keep happening repeatedly--the python code could essentially flood the line with requests that the arduino can't keep up with. You prevent this from happening using the sleep period, but the sleep period probably takes longer than the arduino actually needs, which would reduce your data rate.
If that's the case, it might work to do this in the python code instead:
Send a command
Wait for the arduino to reply (but not using sleep). Ideally, use a read command that blocks until input is received. A less preferable alternative is to busywait--enter a loop that does nothing but check whether a reply has been received and terminates when input is available.
Read the reply
Repeat from step 1

sending serial commands to arduino

I've been trying to find a way to send serial commands from my PC (Windows 7) to an Arduino Uno R3. I've been working on this simple program, where you're supposed to send a simple "1" through the USB cable, in order to turn on the onboard LED. My Arduino code should be working (what I know of, but I'll make sure to upload it).
I've been trying to send this command using Python and pySerial, but I can't seem to get pySerial to work. Also I've tried using CMD, but it seems like CMD freezes when i type in my command (ECHO 1 > COM3 BAUD:9600).
I'm the adminstrator of my PC.
This is my arduino coding
int var = 0;
int LEDPin = 13;
int val = 0;
void setup() {
Serial.begin(9600);
pinMode(LEDPin, OUTPUT);
}
void loop() {
if (Serial.available()>0){
val = Serial.read();
}
if (val == 1){
digitalWrite(LEDPin, HIGH);
}
digitalRead(LEDPin);
if (LEDPin==HIGH){
var ++;
delay (1000);
if(var==10){
digitalWrite(LEDPin,LOW);
var = 0;
val = 0;
}
}
}
And the short Python program I've got :)
import serial
ser = serial.Serial('COM3', 9600, timeout=0)
while 1:
var = 1
ser.write(var)
delay(12000)
With Kind Regards
Michael Vedel.

just to be sure - is Arduino really connected to COM3?
In order to check serial connection manually you can use for example Putty. With help of it you can connect to the needed serial port and send command manually. And in order to check whether Arduino received it, you can add Serial.println(val); just after val = Serial.read();, with this Arduino should sends back to serial whatever characters it receives.

Does the code work when you type a '1' into the Serial Monitor in the Arduino IDE? If so, check the COM port. On my PC (also Windows 7), COM3 is never the Arduino port, as it is used internally for something else.
By the way everything after the digitalRead() statement will do nothing, since you're comparing LEDpin (which is declared as 13) to HIGH (which is defined as 1). I think you mean to see if the digitalRead output is HIGH, but I'm not sure that will work, either, since the pin is declared as an OUTPUT. You'd be much better off putting that logic in the (val == 1) section.

just save this code as .bat and make sure that you are using com 6.
This code lets you enter and sends your commands to serial port at 9600bpm
mode com6:9600,N,8,1
#echo off
:start
cls
Set /p commands="enter command:"
echo|set /p= %commands% >com6
goto start
Now you have to read serial using this in Arduino
Serial.read();

I think the root problem is in the Python code in the call to write. The argument has to be bytes (or something compatible). You're passing an integer value. You need to explicitly convert that value to a bytes object. I'm not a Python expert, but I think one way to do that is to replace:
var = 1
with
var = b'\x01'
Oh, and you might need to call flush as well.
BTW, your experiment with ECHO doesn't do what you intended. It sends the character value for '1', which is 49. Since 49 != 1, your Arduino code won't respond to it.
I find the easiest way to test serial commands is to use the Arduino Serial Monitor, which will have all the right defaults as long as you match the baud rate. This will enable you to ensure the Arduino code is right before debugging the Python code. (Then again, it may be difficult to send control characters with the Serial Monitor, so consider using printable text in your protocol. For example 'A' for on and 'B' for off. Printable text can be easy to work with among all these tools (Python, C, Serial Monitor, ECHO, etc.).)

do this it works better for me, just change the com4 for the port you have connected to
#echo off
:start
cls
set /p commands="enter command:"
mode com4 baud=115200 parity=n data=8 stop=1 to=on xon=off odsr=off octs=off dtr=off rts=off idsr=off && echo %commands% > com4
cls
goto start

I think Arduino is stable and easy enough to handle the data from serial, the cause of that as I used same library with Pyserial in python 3 was that event of reading the serial get fired once which is way faster than Arduino board and to solve that you should use a thread method that runs in the background and make it always try to read the incoming data from serial.
I've made this function that recieved the opened serial :
def read_from_port(ser):
while True:
try:
reading = ser.read().decode()
handle_data(reading)
except EXCEPTION:
print("error while decoding" + str(EXCEPTION))
after I have got the serial from the list and assigned it with the desired baud rate and send it to the Thread :
serial_me = serial.Serial(serial_port1, 115200, timeout=3)
try:
thread_x = threading.Thread(target=read_from_port, args= (serial_me,))
thread_x.daemon = True
thread_x.start()
except EXCEPTION:
print('couldn\'t start thread')
print(Exception)

Random character at the beginning of serial.readline() in python and arduino

I get random characters when I perform a serial.readline(), sometimes it is other umbers and sometimes it is whole messages. The output should be "1,2" or "2,2"
Here are a couple of screenshots of the output of serial.readline().
I have tried to put a delay at before serial.readline() but it did not make a difference.
There is usually a strange character at the beginning:
I have also received strange messages:
There is a problem later on in the program that causes the program to hand because sometimes I just receive a blank line.
Is there a way to get consistent output from serial?
Here is the arduino code:
void setup() {
// initialize the LED pin as an output:
pinMode(ledPin, OUTPUT);
// initialize the pushbutton pin as an input:
pinMode(buttonPin, INPUT);
Serial.begin(9600);
}
void loop(){
// read the state of the pushbutton value:
buttonState = digitalRead(buttonPin);
// check if the pushbutton is pressed.
// if it is, the buttonState is HIGH:
if (buttonState == HIGH) {
// turn LED on:
digitalWrite(ledPin, HIGH);
Serial.println("1,2");
}
else {
// turn LED off:
digitalWrite(ledPin, LOW);
Serial.println("2,2");
}
}
And here is the python code:
ser = serial.Serial('/dev/ttyUSB0', 9600)
line=ser.readline()
coord= line.strip()
print coord
EDIT:
I tried putting ser.flushInput() after the ser.open() and I get the same output.

Have you flushed the serial buffer
ser.flushInput()

I've been having the same issue when interfacing between pyserial and Arduino. This may be an old post, but in case someone else is having the same trouble, I remedied my problem by inserting:
ser.flushInput()
...right before my ser.readline() call.

How to Read serial data from an Arduino in Linux
Nothing fancy here. I’m getting the current port configuration, setting the input/output speed to 9600 baud, setting the data expectations to be 8 bits per word, with no parity bit and no stop bit, setting canonical mode, and then committing those changes back to the serial port.
If I am not mistaken you have to change the mentioned settings when connecting through serial port.
You do not mention it, but I guess you are using the pySerial library. Regardless you can use it with the correct settings to connect through serial. The constructor of the API allows all the parameters which are noted below:
Pyserial Library
I have not tested this approach as I have had a similar problem in C not Python.

What happens if you break it down to something simpler?
On the Arduino:
void setup()
{
Serial.begin(9600);
}
int i = 0;
void loop()
{
delay(1000);
Serial.print("Hello World ");
Serial.println(i);
i++;
}
And in the Python REPL...
import serial
ser = serial.Serial('/dev/ttyUSB0', 9600)
while(1):
ser.readline()
The first behavior you should observe is that when you initiate the serial connection, the Arduino reboots. This takes a few seconds.
The second behavior you should observe is that (if you're typing this in the REPL slowly) when the while(1) loop begins, you get all of the serial data that had accumulated since you initiated the serial connection. It takes me a few seconds to type all that out, so when I hit Enter after ser.readline() I see:
'Hello World 1\r\n'
'Hello World 2\r\n'
'Hello World 3\r\n'
I only mention this to make sure you're familiar with two things that burned me a bit the last time I messed with serial communication to an Arduino: it needs time to reboot after connecting, and the serial data buffers. readline() will only give you one line in the buffer - not everything that's in the buffer.
Is it possible you're trying to sent/receive data before it's done rebooting? What about button bounce - could a dozen high/low state detections be messing something up?

Problem with Arduino and pySerial

I got a problem. I recently bought an Arduino Uno board. I tried to make something funny like controlling an input from my computer. I used Python with pySerial and the program is the following:
arduino = serial.Serial(portaCOM, 9600, timeout = 1)
... in loop ->
arduino.write(value)
def sliderUpdate(self, event):
pos = self.slider.GetValue()
arduino.write(pos)
time.sleep(.1)
print arduino.readline()
try:
arduino = serial.Serial(portaCOM, 9600, timeout = 1)
except:
print "Errore di connessione alla porta seriale"
The write value should send the value to my board though USB.
The program loaded on board is:
const int ledPin = 11;
byte brightness;
void setup(){
Serial.begin(9600);
pinMode(ledPin, OUTPUT);
}
void loop(){
while(Serial.available()){
brightness = Serial.read();
Serial.print(brightness);
analogWrite(ledPin, brightness); //LED doesn't refresh the brightness
delay(10);
}
}
My LED is working properly. I tried with the Fade example provided by Arduino and it's working..
I checked if the program is sending properly the data. Yes, it is. It returns the same thing I sent before.
It should retrieve the value sent and set analaogWriter(pin, VALUE), but something is wrong or not working.
How can I fix this problem?
Solution
The Arduino code
const int ledPin = 11;
byte valoreLed;
void setup(){
Serial.begin(9600);
pinMode(ledPin, OUTPUT);
}
void loop(){
while(Serial.available()){
valoreLed = Serial.read();
analogWrite(ledPin, valoreLed);
delay(20);
}
}
Python script code:
pos = self.slider.GetValue()
arduino.write(chr(pos))
Thank you to everybody!! :)

First of all, make sure your LED is properly connected. Anode (longer pin) to PWM 11 port and cathode (shorter pin) to ground, also you may need to add a resistor between cathode and ground depending on LED.
Make sure you're writing to the right port from python (that FTDI cable is associated with in your OS).
If you're not using FTDI cable with USB connector, make sure that all of the pins are connected to the right inputs.
What is the value of value in your example? Try arduino.write(chr(0xFF)), does LED stay lit?

I suspect that arduino.readline() waits for a newline, and you Arduino code never sends a newline. Hence the Python code blocks indefinitely after sending the first value.

I see in your comments that the LED works with the first character, but you don't see a change with the different characters. Definitely make sure you're sending ASCII characters that are significantly different from the previous characters, e.g. send an ASCII 0 followed by an ASCII 255.
Edit:
Since you say the FadeLED example works, can you just take that example and add serial port functionality to it? For example, only fade after a serial character is received. This will at least get you confident that the serial port and leds can coexist in code you write. Also, I assume you're using the FadeLED example from here. If so, make sure you've set the correct pin number, as the reference code uses pin 9, but your sample code uses pin 11.
Another Edit:
You say you receive the characters back properly from the Arduino, but you're using the pySerial ReadLine function, which should block until it sees a newline, and I don't see anything in the Arduino code that would generate a newline that wasn't sent to it first. To eliminate the number of variables in the question, try using HyperTerminal or a similar COM port program to send bytes to the Arduino, rather than your Python program. For example, you can send space characters (ASCII 32) and '}' characters (ASCII 125), which should be different enough to create a visible difference in the LED.

I would begin by establishing which side of the serial port harbours the problem.
First of all, can you drive the LED using a hard-coded loop on the Arduino. Does the LED change its brightness as expected?
Once that's out of the way, can you make the Arduino do something visibly correct when sending stuff manually from a terminal app (e.g. the one built into the Arduino IDE). This may require changes to the Arduino code.
Once that's working, I would then focus on the Python code, making sure you're talking to the right COM port etc.

"the write value should send the value to my board through USB"
If this is not a typo, then you can not use PySerial to access USB ports. There is pyUSB instead, and probably others.