Programacion en Excel VBA para Metodos Numericos

http://tecdigital.tec.ac.cr/revistamatematica/cursos-linea/NUMERICO/excel/index.html
Curso de metodos en excel
http://tecdigital.tec.ac.cr/revistamatematica/cursos-linea/NUMERICO/index.htm

Programación Visual Basic (VBA) para Excel y Análisis Numérico


M.Sc. Walter Mora F., M.Sc. José Luis Espinoza B.
Escuela de Matemática
Instituto Tecnológico de Costa Rica



Arduino TCS3200 GY-31 COLOR SENSOR

http://www.xcluma.com/example-tutorial-tcs3200-gy-31-color-sensor


TCS3200 GY-31 COLOR SENSOR

TCS3200 GY-31 COLOR SENSOR

Write By: TECH-TEAM Published In: ROOT Created Date: 2016-01-01 Hits: 4245 Comment: 0
How to Use TCS3200 GY-31 COLOR SENSOR for Arduino and Example
BUY IT
DESCRIPTION:
  • TCS3200 Color Sensor is a complete color detector, including a TAOS TCS3200 RGB sensor chip and 4 white LEDs. The TCS3200 can detect and measure a nearly limitless range of visible colors. Applications include test strip reading, sorting by color, ambient light sensing and calibration, and color matching, to name just a few.
  • The TCS3200 has an array of photodetectors, each with either a red, green, or blue filter, or no filter (clear). The filters of each color are distributed evenly throughout the array to eliminate location bias among the colors. Internal to the device is an oscillator which produces a square-wave output whose frequency is proportional to the intensity of the chosen color.
  • Single-Supply Operation (2.7V to 5.5V)
  • High-Resolution Conversion of Light Intensity to Frequency
  • Programmable Color and Full-Scale Output Frequency
  • Power Down Feature
  • Communicates Directly to Microcontroller
  • S0~S1: Output frequency scaling selection inputs
  • S2~S3: Photodiode type selection inputs
  • OUT Pin: Output frequency
  • OE Pin: Output frequency enable pin (active low), can be impending when using
  • Support LED lamp light supplement control
  • Size: 28.4×28.4mm
Connection Diagram:


Arduno Sample Code:
// TCS230 color recognition sensor
// Sensor connection pins to Arduino are shown in comments

Color Sensor      Arduino
-----------      --------
 VCC               5V
 GND               GND
 s0                8
 s1                9
 s2                12
 s3                11
 OUT               10
 OE                GND
*/
const int s0 = 8;
const int s1 = 9;
const int s2 = 12;
const int s3 = 11;
const int out = 10;  
// LED pins connected to Arduino
int redLed = 2;
int greenLed = 3;
int blueLed = 4;
// Variables
int red = 0;
int green = 0;
int blue = 0;
   
void setup()  
{
  Serial.begin(9600);
  pinMode(s0, OUTPUT);
  pinMode(s1, OUTPUT);
  pinMode(s2, OUTPUT);
  pinMode(s3, OUTPUT);
  pinMode(out, INPUT);
  pinMode(redLed, OUTPUT);
  pinMode(greenLed, OUTPUT);
  pinMode(blueLed, OUTPUT);
  digitalWrite(s0, HIGH);
  digitalWrite(s1, HIGH);
}
   
void loop()
{
  color();
  Serial.print("R Intensity:");
  Serial.print(red, DEC);
  Serial.print(" G Intensity: ");
  Serial.print(green, DEC);
  Serial.print(" B Intensity : ");
  Serial.print(blue, DEC);
  //Serial.println();  

  if (red < blue && red < green && red < 20)
  {
   Serial.println(" - (Red Color)");
   digitalWrite(redLed, HIGH); // Turn RED LED ON
   digitalWrite(greenLed, LOW);
   digitalWrite(blueLed, LOW);
  }  

  else if (blue < red && blue < green)  
  {
   Serial.println(" - (Blue Color)");
   digitalWrite(redLed, LOW);
   digitalWrite(greenLed, LOW);
   digitalWrite(blueLed, HIGH); // Turn BLUE LED ON
  }  

  else if (green < red && green < blue)
  {
   Serial.println(" - (Green Color)");
   digitalWrite(redLed, LOW);
   digitalWrite(greenLed, HIGH); // Turn GREEN LED ON
   digitalWrite(blueLed, LOW);
  }
  else{
  Serial.println();
  }
  delay(300);  
  digitalWrite(redLed, LOW);
  digitalWrite(greenLed, LOW);
  digitalWrite(blueLed, LOW);
 }
   
void color()
{  
  digitalWrite(s2, LOW);
  digitalWrite(s3, LOW);
  //count OUT, pRed, RED
  red = pulseIn(out, digitalRead(out) == HIGH ? LOW : HIGH);
  digitalWrite(s3, HIGH);
  //count OUT, pBLUE, BLUE
  blue = pulseIn(out, digitalRead(out) == HIGH ? LOW : HIGH);
  digitalWrite(s2, HIGH);
  //count OUT, pGreen, GREEN
  green = pulseIn(out, digitalRead(out) == HIGH ? LOW : HIGH);
}

YouTube Vedio By Dmitriy Ilyn:
Tags: TCS3200 GY-31 COLOR SENSOR

miércoles, 29 de marzo de 2017

¿Qué es la División Sintética? Ejemplo de División Sintética

https://tecdigital.tec.ac.cr/revistamatematica/ContribucionesV3n3002/0divisint/node1.html

¿Qué es la División Sintética?


La División Sintética es un procedimiento abreviado para realizar la división de un polinomio P(x) = anxn + an - 1xn - 1 +...+ a1x + a0 de grado n, esto es an $ \not=$ 0, entre un polinomio lineal x - c. El procedimiento para realizar esta división es muy simple, primero se toman todos los coeficientes del polinomio P(x) y la constante c, con estos se construye una especie de ''casita'' que ayudará en el proceso

                                                           
Lo primero es ''bajar'' el coeficiente an, a este coeficiente también lo denotamos por bn - 1, luego se multiplica por la constante c, el resultado se coloca en la segunda columna y se suma al siguiente coeficiente an - 1, al resultado lo denotamos bn - 2

                                                       
Este último resultado se multiplica nuevamente por c y se le suma al coeficiente an - 2 y el proceso se repite hasta llegar a a0. Los resultados parciales que se obtienen se denotan por bn - 1,  bn - 2,   ... ,  b1,  b0 (se inicia con bn - 1 pues el cociente tiene un grado menos que el dividendo), y el último valor obtenido se denota por r, pues es el residuo de la división, de esta manera lo que se obtiene es

                                            
Así, el cociente de la división de P(x) por x - c es bn - 1xn - 1 + bn - 2xn - 2 + ... + b1x1 + b0 con un residuo r, en donde los coeficientes se detallan como

bn - 1 = an
bn - 2 = cbn - 1 + an - 1
bn - 3 = cbn - 2 + an - 2
$\displaystyle \vdots$
b1 = cb2 + a2
b0 = cb1 + a1
r = cb0 + a0
EJEMPLO 1 (División Sintética)  
Realice la división de P(x) = 3x4 + 2x3 - x2 + 4x + 2 entre x + 2.
Solución

Al realizar el algoritmo de la división sintética con los coeficientes de P(x) y -2 como valor de c se obtiene

                                                                
Así, el cociente de la división de P(x) entre x + 2 es 3x3 - 4x2 + 7x - 10 y se obtiene un residuo r = 22.

lunes, 27 de marzo de 2017

Libro EL UNIVERSO ELEGANTE BRIAN GREENE Editorial Drakontos

Libro https://violetadedios.files.wordpress.com/2011/01/el-universo-elegante-de-brian-greene.pdf

EL UNIVERSO ELEGANTE BRIAN GREENE
Brian Greene explica en este libro cómo las grandes teorías de la
relatividad y de la mecánica cuántica, que transformaron nuestra interpretación de la naturaleza durante el siglo XX, nos han conducido al mayor problema de la física de hoy en día: la búsqueda de una ley que unifique a todas las demás, una ley que Einstein persiguió en vano durante treinta años y a la que se denomina ‘teoría de supercuerdas’. Esta teoría vendría a unificar esos dos grandes pilares de la física actual, el cuántico y el gravitacional, al suponer que todo lo que sucede en el universo surge de las vibraciones de una única entidad: microscópicos lazos de energía que se encuentran en el auténtico núcleo de la materia y que habitan en espacios de dimensiones superiores a las cuatro del espacio-tiempo einsteiniano.
Con maestría y claridad, Greene nos ofrece en El universo elegante la aportación más brillante que se ha escrito hasta ahora para hacer accesible al gran público este último misterio de la naturaleza que nos explicaría, finalmente, todo. Como ha dicho Michio Kaku, ‘Greene ha hecho un trabajo soberbio al presentarnos cuestiones complejas de una forma no sólo amena, sino intrigante. Recomiendo la lectura de este libro a cualquiera que alguna vez se haya preguntado, como hizo Einstein, si Dios creó el universo jugando a los dados’. Brian Greene es en la actualidad profesor de física y de matemática en la Universidad de Columbia. Ampliamente reconocido por su serie de descubrimientos sobre la teoría de supercuerdas, ha colaborado como investigador en más de una veintena de países. Su último libro es El tejido del cosmos (Crítica 2006).

viernes, 24 de marzo de 2017

Reemplzar matlab con python numpy scipy y matplotlib

The Python Alternative to Matlab


Python in combination with Numpy, Scipy and Matplotlib can be used as a replacement for MATLAB.
http://www.python-course.eu/numpy.php 


Python in combination with Numpy, Scipy and Matplotlib can be used as a replacement for MATLAB. The combination of NumPy, SciPy and Matplotlib is a free (meaning both "free" as in "free beer" and "free" as in "freedom") alternative to MATLAB. Even though MATLAB has a huge number of additional toolboxes available, NumPy has the advantage that Python is a more modern and complete programming language and - as we have said already before - is open source. SciPy adds even more MATLAB-like functionalities to Python. Python is rounded out in the direction of MATLAB with the module Matplotlib, which provides MATLAB-like plotting functionality


pip install numpy
pip install matplotlib
pip install cython

https://sourceforge.net/projects/scipy/

Upgrade pip
pip install --upgrade pip


Descarga cygwin e instalarlo
https://cygwin.com/install.html


descargar scipy-master.zip
https://github.com/scipy/scipy

Descomprimir y ejecutar comando
C:\Users\cuenta\AppData\Local\Programs\Python\Python36-32\Lib\site-packages\scipy-master>python setup.py install

Como instalar numpy en python , numpy install python

Ejecutar el comando:


>pip  install numpy

Collecting numpy
  Downloading numpy-1.12.1-cp36-none-win32.whl (6.7MB)
    100% |################################| 6.7MB 107kB/s
Installing collected packages: numpy
Successfully installed numpy-1.12.1
You are using pip version 8.1.2, however version 9.0.1 is available.
You should consider upgrading via the 'python -m pip install --upgrade pip' command.


Como instalar la libreria pyserial, o libreria serial en python

Como instalar la libreria pyserial, o serial en python

1. Descargar la Libreria de GITHUB
https://github.com/pyserial/pyserial

pyserial-master.zip


2. Descomprimir la carpeta zip en

c:\Python27\Lib\site-packages\pyserial-2.6

o en

C:\Users\cuenta\AppData\Local\Programs\Python\Python36-32\Lib\site-packages\pyserial

o el directorio que haga susveces
...\python\Lib\site-packages\pyserial

3. Abrir una ventana de comandos (cmd) y ubicarse en la carpeta

...\python\Lib\site-packages\pyserial

o en

C:\Users\cuenta\AppData\Local\Programs\Python\Python36-32\Lib\site-packages\pyserial


4. Instalar el paquete con comandos

> python setup.py install


5. Listo, ya quedo instalada la libreria

Carpeta de python en Windows

Carpeta de python en Windows

C:\Users\cuenta\AppData\Local\Programs\Python\Python36-32


Cuando necesite puede Aplicar los comandos:
>>> import sys
>>> sys.executable
'C:\\Users\\cuenta\\AppData\\Local\\Programs\\Python\\Python36-32\\python.exe'

Serial con python para conectar con Arduino de forma sencilla y simple


Código más simple para conectar:
import serial
arduino = serial.Serial('com3', baudrate=57600, timeout=1.0)
while True:
    line = arduino.readline()
    print(line)



Código para enviar y recibir datos desde Arduino a Python por el serial:

import serial
import msvcrt # to detect keys pressed
import time # to execute time functions ( gives the ability to use delay-like commands )

print("Connecting to Arduino....") # print(something
arduino = serial.Serial('com3', baudrate=57600, timeout=1.0)
time.sleep(2)# wait for 2 seconds
print("Connected Successfully!")

while True:
    line = arduino.readline()
    print(line)
    if msvcrt.kbhit(): # if a key is pressed
        keypress = ord(msvcrt.getch()) # store the ASCII value of the character into our variable keypress
        if keypress == 119: #if 'w' is pressed (ASCII value of 'w' is 119)
            print('up') #simply print('up' in command prompt
            arduino.write('w'.encode('ascii')) #send 'w' to Arduino
        if keypress == 115: #if 's' is pressed (ASCII value of 's' is 115)
            print('down') #simply print('down' in command prompt
            arduino.write('s'.encode('ascii')) #send 's' to Arduino
        if keypress == 97: #if 'a' is pressed (ASCII value of 'a' is 97)
            print('left') #simply print('left' in command prompt
            arduino.write('a'.encode('ascii')) #send 'a' to Arduino
        if keypress == 100: #if 'd' is pressed (ASCII value of 'd' is 100)
            print('right') #simply print('right' in command prompt
            arduino.write('d'.encode('ascii'))  #send 'd' to Arduino
        if keypress == 101: #if 'e' is pressed (ASCII value of 'e' is 101)
            print('stop') #simply print('stop' in command prompt
            arduino.write('e'.encode('ascii')) #send 'e' to Arduino


Ojo con la decodificación a ascii con bytes para enviar al Arduino:
date_string = str(datetime.datetime.now())
dates_bytes = date_string.encode('ascii')
ser.write(date_bytes)
 
http://stackoverflow.com/questions/34653568/error-writing-to-serial-device-in-python 

Captura de Teclas Teclado desde python:
http://www.robotshop.com/letsmakerobots/a-guide-to-building-python-apps-for-controlling-your-robot


Referencia que puede servir:
http://pybonacci.org/2014/01/19/leer-datos-de-arduino-desde-python/

Tutoriales de tkinter tk python gui interfaz grafica paso a paso

Tutoriales de tkinter tk python gui interfaz grafica paso a paso

Lo mejor es primero instalar ANACONDA
https://www.continuum.io/downloads



Interface & Application Programming
http://fab.cba.mit.edu/classes/863.14/people/morgen_sullivan/week_12.html

http://fab.cba.mit.edu/classes/863.14/people/sarah_zhang/week%2012.html

Guia paso a paso desde la Instalacion
http://www.robotshop.com/letsmakerobots/a-guide-to-building-python-apps-for-controlling-your-robot

Primera Ventana
http://www.pythondiario.com/2016/03/capitulo-1-creamos-una-ventana.html

Paso a paso GUI Programming with Python
http://www.devdungeon.com/content/gui-programming-python

Python Tkinter guias de botones y controles
http://www.python-course.eu/python_tkinter.php

Python GUI with Tkinter - 1 - Introduction
https://www.youtube.com/watch?v=RJB1Ek2Ko_Y

Python GUI Programming (Tkinter)
https://www.tutorialspoint.com/python/python_gui_programming.htm

Python Tutoriales videos
https://www.youtube.com/playlist?list=PLQVvvaa0QuDe8XSftW-RAxdo6OmaeL85M

Color Picker–Python
https://ledshield.wordpress.com/home/

Installing pyserial on Windows 7 with Python3.2
https://pythonfun.wordpress.com/2012/04/04/installing-pyserial-on-windows-7-with-python3-2/



Tkinter with Serial
http://robotic-controls.com/learn/python-guis/tkinter-serial

Comunicación por puerto serie con pySerial
El código mínimo
http://pybonacci.org/2014/01/19/leer-datos-de-arduino-desde-python/


Clock Demo
Updating Tkinter applications at an interval - Clock demo
http://programmingadvent.blogspot.com.co/






jueves, 23 de marzo de 2017

Python como saber el folder o carpeta de instalación

Aplicar los comandos:
>>> import sys
>>> sys.executable
'C:\\Users\\cuenta\\AppData\\Local\\Programs\\Python\\Python36-32\\python.exe'

Python Control LED with Serial Communication RS232


UPDATE : 7/14/2014 : 1) Controlling a robot via a Python GUI added 2) Video demonstrating GUI control added.
UPDATE: 7/5/2014 : Lighting up specific colours in an RGB LED via a Python GUI added.
UPDATE: 7/4/2014 : Short info on PyGame vs msvcrt library added.
Hello everyone,
Welcome to this guide that will teach you how to build an app using Python. This tutorial will cover everything from the installation of Python to configuring the Python Environment and doing some "Hello World" stuff in Python to blinking LEDs using a simple app. At the end of this tutorial, you will easily be able to control your robot using easy-to-create Python GUIs, keyboard strokes, and many other interfaces. This tutorial focuses on Python + Arduino communication and control, on Windows. 
So, what is Python? Correct, it's a killer snake found in Africa and other areas. 
Python!
But, in technical terms, Python is a killer programming language. This short blurb on their website sums it all up:

Python is powerful... and fast;
plays well with others;
runs everywhere;
is friendly & easy to learn;
is Open.


Let's get started...
Things that you will/might need  :
1) An Arduino along with a serial cable
2) A computer connected to the Internet (for downloading, Python, Libraries, etc.)
3) LEDs or a robot or any sensor module for additional testing.
4) Bluetooth Modules, RF Modules, etc. if you want to control your robot wirelessly.
5) Motors and Motor drivers, chassis, batteries (in general, a robot)

CONTENTS:
 1) DOWNLOADING AND INSTALLING PYTHON
·         Downloading the Python Files
·         Installing Python on Windows
·         Configuring Environment Variables
·         Sample Python Programming
      2)  PROGRAMMING AND DEVELOPING PYTHON APPS
·         PySerial and Tkinter
·         Downloading and Installing the PySerial Library
·         Tutorials – Serial Communication
 Ø  Blinking an LED (Automatic)
Ø  Turning an LED On or Off via a simple Python GUI 
Ø  Lighting up specific colours in an RGB LED via another simple Python GUI
·         Tutorials – Serial + Wireless Communication using RF Modules (Controlling a Robot)
Ø  Control using keyboard strokes via the msvcrt library (works only on windows) 
Ø  Control through mouse clicks via the Tkinter GUI library

1) DOWNLOADING AND INSTALLING PYTHON
  • Downloading Python Files
Obviously, to program in Python, you'll need to download it first. Head over to the download page in the Official Python Website.
You'll find a cluster of releases out there and you might be confused in selecting the correct version. If you are a Windows user, select a windows release. If you're on Linux, Mac OS X, etc. select the appropriate releases for them. Configuring the environment might be slightly different on those platforms. But Python is Python. The code won't be any different, and so, although I'm moving ahead in this tutorial in Windows, you might find some of co-incidences even if you are on a different platform. However, certain libraries might work on Windows while they might not be supported on MacOS or Linux.
Ok, I found out a release for my OS. But should I go with Python 2 or 3?
There are a couple of different versions of Python, 2.x and 3.x. The latest releases for these versions are 2.7.7 and 3.4.1 respectively. So which one should you use? Well, the 3.x version is definitely a newer version with more enhancements, but 2.x is more like a classic. 2.x has existed for a long time around and you'll find more support, communities, and libraries for it. (Not that you will be singled out when using 3.x) There are also minor differences in library inclusions.To import a GUI library called Tkinter (more on that soon), you'll need to type it Tkinter if you are on Python 2 and tkinter if you are on Python 3. I will be using Python 2.7.6 in this tutorial.
But my knowledge on this debate is limited. Visit this page if you want to deeply understand the differences between these versions. If you're using Python 3.x, the code used in the examples of this tutorial might give you errors. So in that case, be prepared to put on your thinking cap!


  • Installing Python on Windows
Let's install Python on Windows and configure everything to jump right into Python App Development. If you have already installed and configured Python, head over to the programming and development section.
Once you have downloaded the Windows Installer, double-click on it to begin the installation process for Python. You can check either of the options as per your desire. After that, click Next.

Select a location where you want the Python files to reside by. The default location is in C:\Python27\ and it's a nice idea to stick to the default location. Click Next

Here, you can see the various features that you can select while installing Python. You can leave it as it is and click on Next.

However, on the previous window, you can also click on the "Advanced" button and tick-mark the check-box shown above if you want to view bytecodes for your python files. (Python files have an extension .py)

Then, just wait a bit for the installation process to finish. Shouldn't take a long time.

And that's how you install Python on Windows. Really Simple.


  • Configuring the Python Environment
But just installing Python won't do. You need to configure the environment variables to be able to properly execute Python commands from a Windows Shell (Command Prompt).
Sorry that I am on Windows 8. But the idea is : to configure the environment variables you need to go to the advanced settings option. Open up File Explorer.

Right Click on My Computer and go to Properties.

Click on Advanced Settings

At the bottom, you should see "Environment Variables". Click on it.

Under System Variables, locate the "Path" variable. Click on it once and select edit.

Add " ;C:\Python27\" or the location where you installed Python to what you already have present there in the Variable Value. Remember to use the"  ; " at the beginning and " \ ' at the end. Click OK. And then click on Apply. You have then successfully configured the Python Environment. 
You need to configure the Environment Variables to specify the installation location of the Python Files. Otherwise the command prompt will give you an error " xxxx is not recognized as an internal or external command, operable program or batch file" while executing Python related commands. This is not limited to just Python. You might need to do the same while installing Java and other environments.


  • Sample Python Programming
Press the Windows Key + R that pops up the Run Window. Type "cmd" and press Enter. That should open up the command prompt.

To check whether Python has been properly installed and configured, type python and press Enter and you should get something similar to what is seen above.


  •   Doing Some Hello World! 
You should be able to start programming using Python after that. Give it a go. Try typing print "Hello World!"
It's not that you always need to open up command prompt and program in Python from there. You can do that with Python's in-built IDE i.e. Idle. But using notepad++ is much more easy, and cool! So, if you don't have notepad++ installed yet, download it right away. Python is an interpreted language i.e. it's converted into machine code one line at a time ( unlike Arduino C which we compile at the end). Command prompt plays the role of a command line interpreter for Python. 
A couple of things in Python might bug you (if you are new to Python), and so, I will mention a few important things:
1. Use Notepad++ for coding in Python. It's much easier than IDLE.
 2. Make sure to save your files with an extension .py
3. Python does not use parentheses '{' , '}'. Instead you use tabs. Let me show you an example while defining functions :
4. As you can see in the example above, functions are defined in Python using the 'def' keyword. Similarly, you can make use of other control flow statements but with a few minor changes.
  • If statements : 'if', 'elif' (instead of elseif), else
  • 'for' and 'while' statements and many more.
5. In C, or as you may have programmed in Arduino, statements terminate with the ';' symbol. Python doesn't use the semi colon symbol to terminate a statement. An enter key is enough. For eg :
In Python: Port = serial.Serial(12, 9600)
In Arduino: Serial.begin(9600);
6. You don't need to specify the variable type in Python. For eg :
num = 1
name = LMR
 You do not need to specify that num is an integer and name is a string! Unlike in Arduino C where that would have been  
int num = 1;
char name = LMR;
I won't dive into the depths of Python programming; that's beyond the scope of this tutorial, and my ability. However, you don't need to be an expert to build a simple app. At the same time, it's a great idea to Google for some Python related tutorials to learn more about the language. If you are familiar with some C or Arduino, this tutorial will be breezer, trust me.

2) PROGRAMMING AND DEVELOPING AN APP
Now that you have installed Python along with configuring the environment variables, we are all set to code. 
We will be developing a couple of Apps to control various devices, robots, etc. via a variety of interfaces. We will mainly be using two major Python Libraries in this tutorial. According to Wikipedia, "A library (in computing terms) is a collection of implementations of behaviors. Once you "include" these libraries in you code, you don't need to always make system calls inside the code. Here are the libraries that we will be using
  • PySerial and Tkinter
I'll sum up this in short.  PySerial is a communication library whereas Tkinter is a GUI library,  for Python. (There are other GUI libraries as well)
The major concept that lies in using Python apps to control an Arduino based project is communication between Python and the computer's serial port. 
  • Downloading and Installing the PySerial Library
Head over to this page for detailed PySerial documentation and this page to download the package.
On the download page, you might see a package named pyserial-2.7.tar.gz (md5).  Download it.
After Downloading the package, extract it with an extracting software such as 7zip.

After extracting it, you should get a folder named "pyserial2.7.tar".  

Double click it, and inside a folder named dist, you'll find another .tar file. Extract it once more.

You'll find another folder called 'pyserial2.7'

Double click the 'pyserial2.7' folder until you see a folder named serial. Copy it into the Python Lib folder.
That should be it. You have successfully installed the PySerial Library and now can start blinking LEDs via Python through serial communication over the Arduino.


  • Tutorials – Serial Communication 

  1.   Blinking an LED (Automatic)
I guess you are familiar with the plain simple Arduino code to blink an LED. To blink an onboard LED, the code using delays is :
    digitalWrite(13, HIGH);
    delay(1000);
    digitalWrite(13, LOW);
    delay(1000);
To blink an LED via Python, the idea is to send a character to the Arduino via serial so that the Arduino can perform the above routine. A talk with Python to do this would go something like this :
Hey Python, send a character 'b' to serial port 3 (i.e. to an Arduino connected to serial port 3).
And then the talk to Arduino would go something like this:
Hey Arduino, got the 'b' yet? Good. Now blink!
It's as simple as that. Let's do this using some Python code now.
It's not that we are using Python to program the blinking routine of the LED, that is done by Arduino itself. We are just using Python to send some sort of indication to the Arduino so that it knows it's time to perform.
First thing we need to do is importing the Serial library so that Python has the ability to communicate with the available serial ports. It's just like using #include<stdio.h> in C or #include<LiquidCrystal.h> in Arduino.
import serial # import the serial library
Next up, we need to open up the serial port to which the Arduino is connected to. Have a look at the what COM port your Arduino is using. The syntax is : port (or any other name) = serial.Serial("COMx", baudRate, timeOut(optional))  
arduinoSerialPort = serial.Serial("COM13", 9600)
arduinoSerialPort = serial.Serial(12, 9600)
Either is the same.
I'll try to make this program as simple as possible as it's our first python program. Now, it's time to send a character to Arduino over serial. For eg : 'b'
arduinoSerialPort.write('b')
And that's it. Let's sum things up.
import serial #import the serial library
arduinoSerialPort = serial.Serial(12, 9600)
arduinoSerialPort.write('b')
Using three lines of Python code, you can send a character to Arduino over serial communication! Type this code in Notepad++ and save the file in your Desktop as ledBlink.py (as you know, Python files have an extension .py)
Let's move on to the Arduino part.
First, let's define the onboard ledPin that's located at digital pin 13.
int ledPin = 13;

Then, let's setup Serial Communication to receive the incoming data from the Python program. The baud-rate here should match the baud-rate we had defined in the Python code.
void setup(){
  Serial.begin(9600);
}
Arduino reads incoming data in ASCII form. The character 'b' we have sent via Python is read as '98' by the Arduino. Next up, we need to read the incoming serial and if it equals '98', the Arduino will execute the blink routine.
void loop(){
 if (Serial.read() == '98'){
digitalWrite(led, HIGH);
delay(1000);
digitalWrite(led, LOW);
delay(1000);
  }
}
Let's sum up the entire Arduino program : 
int led = 13;
void setup(){
  Serial.begin(9600);
}
void loop(){
  if (Serial.available() == '98'){
    digitalWrite(led, HIGH);
    delay(1000);
    digitalWrite(led, LOW);
    delay(1000);
  }
}
Compile this program in the Arduino IDE, select the specific board you are using and also make sure that you check the correct serial port. Upload the program to your Arduino Board.
Running the Python program
You should see a file with the name ledBlink with a python logo in your Desktop (if you had saved it there earlier). If you double click it, it should open and you should also see the onboard LED blink a couple of times randomly. Voila!
Unless you made any errors in the code, or missed a few steps while installing and configuring Python, the program should work. If you are getting an error, do have a look above at each step closely. If you're still getting an error, you might google it and get the solution ( I found solutions to lots of errors at stackoverflow ). You can let me know in the comments as well.
But you might have noticed that the program opened the command prompt just for a short time, and terminated automatically. Why did this happen? It's because the program was simply done and dusted. There were no loops or other tasks left to be executed. We had told it to send the character 'b' over to the Arduino. It did it's job and went home.


 2) Turning an LED On or Off via a simple Python GUI
The previous example showed you how to code a Python program that does absolutely nothing but automatically send data to the Arduino and shut off. What if you could control the LED at the push of a button? That's cooler and that's what we are going to do right now.
To make the LED blink at the click of a mouse-button, we will need to build some sort of Graphical User Interface (GUI) using Python. The Tkinter GUI Library for Python makes this a piece of cake.  I'll show you how to build a simple GUI that let's you give total command over your LED : should it be ON or OFF ? (Psst! How about using an external LED this time?)
Unlike the PySerial module, Tkinter comes built-in with the Python files. You do not need to make any other addition to the Lib folder. To build a GUI App to control and LED, we need to import libraries first:
import serial # Import Serial Library ( you need this because you need to send data when buttons are clicked)
from Tkinter import * # import Tkinter Library (importing this way doesn't require calling the library every time)
Then, you need to create a window for you GUI:
appWindow = Tk() # creates the application window (you can use any name)
appWindow.wm_title("LED Control") # displays title at the top left
# insert app widgets here (radiobuttons, checkboxes, buttons, etc.)
appWindow.mainloop()# begins main loop
Save the program as firstGUI.py. If you run it, you should be able to see the following window :
Now, we need to insert two "radio-buttons" into our GUI so that we have the option of turning the LED either ON, or OFF. We have two groups of radio-buttons in this example : LED on and LED off. Each group needs to be associated with a single variable because only one can be checked at a time. Checking specific buttons changes the variable to a pre-defined value set in our code: 
var = IntVar() # define var as an integer variable
onButton = Radiobutton(appWindow, text="LED ON", variable = var, value = 1, command=ledOn)
onButton.pack( anchor = W ) # this part adjusts the radiobuttons to the parent window
offButton = Radiobutton(appWindow, text="LED OFF", variable = var, value = 2, command=ledOff)
offButton.pack( anchor = W ) # this part adjusts the radiobuttons to the parent window
As you can see, the syntax to insert Radiobuttons is buttonName = Radiobutton(window, text, command...). The command option executes a task (function) when a button is clicked. We will create two separate functions, namely on and off to send different characters to the Arduino, when each Radiobutton is clicked. You already know how to send data to the Arduino via Python as we had learned in the previous LED blink example:
def on():
 arduinoSerialPort.write('a1')
def off():
 arduinoSerialPort.write('a0')
arduinoSerialPort = serial.Serial(12, 9600)
Let's sum up the code:
import serial
from Tkinter import *

def ledOn(): # this is how you define functions in Python. ledOn() is executed if onButton is pressed
 arduinoSerialPort.write('a1') # sends 'a1' to the Arduino 
def ledOff(): # this is how you define functions in Python. ledOff() is executed if offButton is pressed
 arduinoSerialPort.write('a0') # sends 'a0' to the Arduino 

arduinoSerialPort = serial.Serial(12, 9600)
appWindow = Tk() #creates the application window
appWindow.wm_title("LED Control") #displays title at the top left

var = IntVar()

onButton = Radiobutton(appWindow, text="LED ON", variable = var, value = 1, command=ledOn)
onButton.pack( anchor = W )
offButton = Radiobutton(appWindow, text="LED OFF", variable = var, value = 2, command=ledOff)
offButton.pack( anchor = W )

appWindow.mainloop() # main loop. From here, the GUI starts updating and responding to user inputs.
Save the program, and you should see something like this: (Make sure to have your Arduino connected. We are communicating serially, so you might get an error if it's disconnected)
Let's move on to the Arduino code:
So, when we click on "LED ON" in our Python GUI, Arduino receives "a1". If the other button is clicked, Arduino gets "a0". A rough idea for our Arduino code would be:
If incoming data = "a1", LED status = HIGH or 1 and if incoming data = "a0", LED status = LOW or 0
First let's define few things, and initialize serial communication.
int led = 13; // give a name to our LED
int ledStatus; // status of the LED. It's either HIGH or LOW (0 or 1)

void setup() {                
  pinMode(led, OUTPUT);  // initialize the digital pin as an output.
Serial.begin(9600);  // begin serial communication at 9600 baud rate
}
In the main loop, first we check to see if there is any incoming data. If there is, we use the function serial.parseInt() to return any integer and reject any character present in the data. Finally, we store the integer into the ledStatus variable.
void loop() {
  if(Serial.available() > 0) {
    ledStatus = Serial.parseInt();
    digitalWrite(led, ledStatus);
  }
}
Let's sum up the entire code ( Just merging the above two)
int led = 13; // give a name to our LED
int ledStatus; // status of the LED. It's either HIGH or LOW (0 or 1)

void setup() {                
  pinMode(led, OUTPUT);  // initialize the digital pin as an output.
Serial.begin(9600);  // begin serial communication at 9600 baud
}

// main loop begins
void loop() {
  if(Serial.available() > 0) { // see if there is incoming data
    ledStatus = Serial.parseInt(); // parse the data and store the first integer, if available, into our variable. 
    digitalWrite(led, ledStatus); // Turn ON or Turn OFF the LED as per user input
  }
}
That's just about it. Upload the code into your Arduino and commence your rule over that puny LED!


3) Lighting up specific colours in an RGB LED via a Python GUI
By now, you must have understood how the communication process works in between Python and Arduino. You have learnt to blink an LED randomly and have also tamed it to turn on or off, at the presence of your command. Let's make things a tad more interesting now by building a Python GUI to light up colours in an RGB LED. The communication process remains the same, but our interface will move to a higher level. Let's begin.
Let's start from the Python GUI and later move towards Arduino.
As always, we start by importing libraries, setting up serial communications and defining a couple of functions that light up specific colours in an RGB LED.
import serial # import the serial library
import time # import the time library
from Tkinter import * #import Tkinter GUI library 

def red():
 arduino.write('r')

def green():
 arduino.write('g')
 

def blue():
 arduino.write('b')
 

def yellow():
 arduino.write('w')
 

def purple():
 arduino.write('s')
 

def aqua():
 arduino.write('a')

print 'Connecting...'
arduino = serial.Serial(12, 9600)
time.sleep(3)
print 'Connection established successfully'
Now, we shall move towards designing the Python GUI that will have a couple of colourful buttons on it. Remember the following code we used to create a simply GUI window?
appWindow = Tk() # creates the application window (you can use any name)
appWindow.wm_title("LED Control") # displays title at the top left
# insert app widgets here (radiobuttons, checkboxes, buttons, etc.)
appWindow.mainloop()# begins main loop

Let's make a couple of additions to this plain code. To make the GUI more interactive by filling it with buttons, creating frames, we use various "widgets" (like the radio-button we used above)
Let's begin by adding a frame which is an important organizational component of any Python GUI. Let's create the main frame first:
mainFrame = Frame(appWindow, bg="#037481") #define the main frame of the GUI
mainFrame.grid() #grid the frame into the App Window
Then let's create a frame inside the main frame that will hold the buttons:
btnFrame = Frame(mainFrame, bg="#037481") #define the frame within the main frame that holds buttons
btnFrame.grid(row=1, column=0) #grid the frame into the main frame
Finally let's add a couple of buttons inside the btnFrame
redLEDBtn = Button(btnFrame, text="RED", command=red, bg="red") #create a button inside the btnFrame with the given features
redLEDBtn.grid(row=0, column=1) #grid the button in a specific row and column within the btnFrame

greenLEDBtn = Button(btnFrame, text="GREEN", command=green, bg="green") #create a button inside the btnFrame with the given features
greenLEDBtn.grid(row=0, column=2) #grid the button in a specific row and column within the btnFrame

blueLEDBtn = Button(btnFrame, text="BLUE", command=blue, bg="blue") #create a button inside the btnFrame with the given features
blueLEDBtn.grid(row=0, column=3) #grid the button in a specific row and column within the btnFrame

yellowLEDBtn = Button(btnFrame, text="YELLOW", command=yellow, bg="yellow") #create a button inside the btnFrame with the given features
yellowLEDBtn.grid(row=1, column=1) #grid the button in a specific row and column within the btnFrame

purpleLEDBtn = Button(btnFrame, text="PURPLE", command=purple, bg="purple") #create a button inside the btnFrame with the given features
purpleLEDBtn.grid(row=1, column=2) #grid the button in a specific row and column within the btnFrame

aquaLEDBtn = Button(btnFrame, text="AQUA", command=aqua, bg="#028482") #create a button inside the btnFrame with the given features
aquaLEDBtn.grid(row=1, column=3) #grid the button in a specific row and column within the btnFrame
 Just like the radiobuttons executed a function to which the command option was directed to, the buttons in this GUI also do the same. When the redLEDBtn is pressed, the function red() is executed as we have specified so using the command option while creating the button.
Let's sum up the code now, shall we?
import serial # import the serial library
import time # import the time library
from Tkinter import * #import Tkinter GUI library 



def red():
 arduino.write('r')

def green():
 arduino.write('g')
 

def blue():
 arduino.write('b')
 

def yellow():
 arduino.write('w')
 

def purple():
 arduino.write('s')
 

def aqua():
 arduino.write('a')

print 'Connecting...'
arduino = serial.Serial(12, 9600)
time.sleep(3)
print 'Connection established successfully'

appWindow = Tk() # creates the application window (you can use any name)
appWindow.wm_title("RGB LED Control") # displays title at the top left
appWindow.config(bg ="#037481")

mainFrame = Frame(appWindow, bg="#037481") #define the main frame of the GUI
mainFrame.grid() #grid the frame into the App Window

btnFrame = Frame(mainFrame, bg="#037481") #define the frame within the main frame that holds buttons
btnFrame.grid() #grid the frame into the main frame

redLEDBtn = Button(btnFrame, text="RED", command=red, bg="red") #create a button inside the btnFrame with the given features
redLEDBtn.grid(row=0, column=1) #grid the button in a specific row and column within the btnFrame

greenLEDBtn = Button(btnFrame, text="GREEN", command=green, bg="green") #create a button inside the btnFrame with the given features
greenLEDBtn.grid(row=0, column=2) #grid the button in a specific row and column within the btnFrame

blueLEDBtn = Button(btnFrame, text="BLUE", command=blue, bg="blue") #create a button inside the btnFrame with the given features
blueLEDBtn.grid(row=0, column=3) #grid the button in a specific row and column within the btnFrame

yellowLEDBtn = Button(btnFrame, text="YELLOW", command=yellow, bg="yellow") #create a button inside the btnFrame with the given features
yellowLEDBtn.grid(row=1, column=1) #grid the button in a specific row and column within the btnFrame

purpleLEDBtn = Button(btnFrame, text="PURPLE", command=purple, bg="purple") #create a button inside the btnFrame with the given features
purpleLEDBtn.grid(row=1, column=2) #grid the button in a specific row and column within the btnFrame

aquaLEDBtn = Button(btnFrame, text="AQUA", command=aqua, bg="#028482") #create a button inside the btnFrame with the given features
aquaLEDBtn.grid(row=1, column=3) #grid the button in a specific row and column within the btnFrame

appWindow.mainloop()# begins main loop
That's it. Save the program with any name. (RGB.py) and open it up. If you have followed everything, you should get the following result:

The Arduino part should be fairly simple: receiving characters and lighting up corresponding colors. It's not mandatory to have an RGB LED. You can experiment this with almost anything. The Arduino code will be added later along with a demo video depicting GUI control. For now, here's an RGB LED Demo.
This was a demo of a simple GUI app using Tkinter and Python. I'll leave the rest up to you. Experiment with various widgets to see what results are produced! Scroll further below to see more on controlling a robot through a Python GUI.


  • Tutorials – Serial + Wireless Communication using RF Modules (Controlling a Robot)
Now that you are familiar with building apps and communicating with Arduino, using Python, let's spice up things a bit. Let's start controlling a robot wirlessly via a computer. In this tutorial, we will be using RF Modules for wireless communication. (You can use a bluetooth module as well). We will need two Arduinos : Arduino A at the transmitter end and Arduino B at the receiver end. We will learn to control the robot using 1) keyboard strokes 2) button-clicks via a Python GUI
1) Control using keyboard strokes via the msvcrt library (works only on windows) :
      Before moving into the depths of the msvcblablabla library, let's see what processes undergo when a robot is being controlled wirelessly using a keyboard through a Python App via RF modules. To learn more about using RF Modules and Arduino, visit Robodude's Instructable. You can also find information on the Virtual Wire Library there.
Like PySerial and Tkinter, msvcrt is a Python library that detect keyboard characters when they are pressed. It also comes along with the Python files like Tkinter. On knowing the pressed character, we can send data to the Arduino to perform a task, in this case, to control a robot. For eg: on pressing 'w', the robot moves forward and on pressing 'd', the robot turns right. For some reason which I do not know, Google told me that this library worked only on Windows.
UPDATE: Looks like the PyGame Library also supports key presses, and it's also available on major platforms. You might want to experiment with that too.
Why not do this directly from Arduino? Why use Python? because while sending data from the Arduino IDE through the Serial Monitor, we cannot do so in real time. We need press a character and unless we hit enter, we cannot send the character to the Arduino. Using Python and the msvcrt library, we can send characters in real-time. Data is sent to the Arduino as soon as a specific key is pressed.
So let's begin. First, as always, we need to import libraries that will be required in our Python code. In this case, the keyboard library i.e. msvcrt, the serial library, and the time library.
import serial # for serial communication
import msvcrt # to detect keys pressed
import time # to execute time functions ( gives the ability to use delay-like commands )
Next, let's establish serial port connections:
print "Connecting to Arduino...." # print something 
arduinoSerialPort = serial.Serial("COM13", 9600) 
time.sleep(2)# wait for 2 seconds
print "Connected Successfully!" 
Then, let's begin the Python main loop. This is similar to the void loop() used in Arduino:
while 1:
Now, let's make use of the msvcrt library to detect keystrokes and send a specific character to the Arduino when a specific key is pressed.
 if msvcrt.kbhit(): # if a key is pressed
  keypress = ord(msvcrt.getch()) # store the ASCII value of the character into our variable keypress
  if keypress == 119: #if 'w' is pressed (ASCII value of 'w' is 119)
   print 'up' #simply print 'up' in command prompt
   arduino.write('w') #send 'w' to Arduino
  if keypress == 115: #if 's' is pressed (ASCII value of 's' is 115)
   print 'down' #simply print 'down' in command prompt
   arduino.write('s') #send 's' to Arduino
  if keypress == 97: #if 'a' is pressed (ASCII value of 'a' is 97)
   print 'left' #simply print 'left' in command prompt
   arduino.write('a') #send 'a' to Arduino
  if keypress == 100: #if 'd' is pressed (ASCII value of 'd' is 100)
   print 'right'#simply print 'right' in command prompt
   arduino.write('d')  #send 'd' to Arduino
  if keypress == 101: #if 'e' is pressed (ASCII value of 'e' is 101)
   print 'stop' #simply print 'stop' in command prompt
   arduino.write('e') #send 'e' to Arduino
There. That's all for the Python code. But let's just sum things up in place.
import serial
import msvcrt 
import time

print "Connecting to Arduino..."  # print something 
arduino = serial.Serial(12, 9600)
time.sleep(2)
print "Connected Successfully!"

while 1:
 if msvcrt.kbhit(): # if a key is pressed
  keypress = ord(msvcrt.getch()) # store the ASCII value of the character into our variable keypress
  if keypress == 119: #if 'w' is pressed (ASCII value of 'w' is 119)
   print 'up' #simply print 'up' in command prompt
   arduino.write('w') #send 'w' to Arduino
  if keypress == 115: #if 's' is pressed (ASCII value of 's' is 115)
   print 'down' #simply print 'down' in command prompt
   arduino.write('s') #send 's' to Arduino
  if keypress == 97: #if 'a' is pressed (ASCII value of 'a' is 97)
   print 'left' #simply print 'left' in command prompt
   arduino.write('a') #send 'a' to Arduino
  if keypress == 100: #if 'd' is pressed (ASCII value of 'd' is 100)
   print 'right'#simply print 'right' in command prompt
   arduino.write('d')  #send 'd' to Arduino
  if keypress == 101: #if 'e' is pressed (ASCII value of 'e' is 101)
   print 'stop' #simply print 'stop' in command prompt
   arduino.write('e') #send 'e' to Arduino
Save the file as keyControl.py or something. Open up the program and you should see the following window:
The directional texts (up, left, down, right) don't come up initially. You see them because I had pressed corresponding keys.
After we have sent specific characters to Arduino via serial port, RF communication begins. RF Modules come in a pair : a TX (data tramsitter) pair and an RX (data receiver) pair. We will need to write a separate Arduino Code for the TX-pair and a separate Arduino code for the RX-pair. The RF Modules I am using have a frequency of 433 MHz and I am using the Virtual Wire Library to make data transfer easier.
Arduino Code for TX-pair (connected to Arduino A):
TX
First, let's include the VirtualWire Library:
 #include <VirtualWire.h>
And then, let's initialize Serial Communication to receive the incoming characters from the Python App:
void setup(){
  Serial.begin(9600);
  vw_setup(2000);  // Bits per sec
  vw_set_tx_pin(3); //Transmitter Data Pin to Digital Pin 3
}//close setup

Let's begin the main loop and start checking the incoming characters via Serial and transmitting the outgoing characters via RF:
void loop()
{
  if (Serial.available() > 0) // if there is incoming data
  {
    int sendByte = Serial.read();//Starts reading data from the serial monitor once condition is met
   switch (sendByte){
    
     case 'w':  // if w is pressed
      {

        char *msg2 = "w";
        digitalWrite(13, true); // Flash a light to show transmitting
        vw_send((uint8_t *)msg2, strlen(msg2));//send byte to the receiver
        vw_wait_tx(); // Wait until the whole message is gone
        digitalWrite(13, false);
        break;

      }
Similarly, we can write the code for the rest of the characters in the same way. Let's sum up the entire TX code.
#include <VirtualWire.h>

void setup(){
  Serial.begin(9600);
  vw_setup(2000);  // Bits per sec
  vw_set_tx_pin(3); //Transmitter Data Pin to Digital Pin 3
}//close setup

void loop()
{
  if (Serial.available() > 0) // if there is incoming data
  {
    int sendByte = Serial.read();//Starts reading data from the serial monitor once condition is met
   switch (sendByte){
    
     case 'w':  // if w is pressed
      {

        char *msg2 = "w";
        digitalWrite(13, true); // Flash a light to show transmitting
        vw_send((uint8_t *)msg2, strlen(msg2));//send byte to the receiver
        vw_wait_tx(); // Wait until the whole message is gone
        digitalWrite(13, false);
        break;

      }
    case 's':  // if s is pressed
      {
        char *msg2 = "s";
        digitalWrite(13, true); // Flash a light to show transmitting
        vw_send((uint8_t *)msg2, strlen(msg2));//send byte to the receiver
        vw_wait_tx(); // Wait until the whole message is gone
        digitalWrite(13, false);  
        break;
      }

    case 'a': // if a is pressed
      {
        char *msg2 = "a"; 
        digitalWrite(13, true); // Flash a light to show transmitting
        vw_send((uint8_t *)msg2, strlen(msg2));//send byte to the receiver
        vw_wait_tx(); // Wait until the whole message is gone
        digitalWrite(13, false);  
        break;
      }

    case 'd': // if d is pressed
      {  
        char *msg2 = "d"; 
        digitalWrite(13, true); // Flash a light to show transmitting
        vw_send((uint8_t *)msg2, strlen(msg2));//send byte to the receiver
        vw_wait_tx(); // Wait until the whole message is gone
        digitalWrite(13, false);    
        break;
      }     
    case 'e': // if e is pressed
      {
        char *msg2 = "e"; 
        digitalWrite(13, true); // Flash a light to show transmitting
        vw_send((uint8_t *)msg2, strlen(msg2));//send byte to the receiver
        vw_wait_tx(); // Wait until the whole message is gone
        digitalWrite(13, false);   
        break;
      }
    default://if any other value is entered
      {
 Serial.println("wrong entry");//print wrong entry in the serial monitor
      }
    }// close switch-case
  }//close if 
}//close loop

Arduino Code for RX-pair (connected to Arduino B):
RX
Now, let's discuss the code for the RX-part. We start by including the Virtual Wire Library again :
#include <VirtualWire.h>
To move your robot around , you need motors. To control the speed and direction of the motors, you need a motor driver. I am using an L293D motor driver. Refer to the datasheet of the motor driver you are using to know the respective pin definitions. Time to define the pin connections:
#define rightMotor1 5 // INPUT A1 to digital pin 5
#define rightMotor2 6 // INPUT A2 to digital pin 6
#define leftMotor1 3  // INPUT B1 to digital pin 3
#define leftMotor2 11 // INPUT B2 to digital pin 11

Let's initialize the serial communication and configure the Arduino pin modes.
void setup() {
    vw_setup(2000);  // Bits per sec
    vw_set_rx_pin(2);//Receiver at Digital Pin 2
    vw_rx_start();// Start the receiver PLL running
  pinMode(rightMotor1, OUTPUT);
  pinMode(rightMotor2, OUTPUT);
  pinMode(leftMotor1, OUTPUT);
  pinMode(leftMotor2, OUTPUT);
}

Now, we begin to receive incoming characters via the RX-pair. Let's enter into the main loop:
void loop() {
   
 uint8_t buf[VW_MAX_MESSAGE_LEN];
    uint8_t buflen = VW_MAX_MESSAGE_LEN;
    

    if (vw_get_message(buf, &buflen)) // if RX-pair receives a character
    {
 int i;

        digitalWrite(13, true); // Flash a light to show received good message
 
 for (i = 0; i < buflen; i++)
 {
     Serial.print(buf[i]);
        if(buf[i] == 'w')
        {
          forward();//go forward when w is pressed
        }
        if(buf[i] == 's')
      {
        backward();//go backward when s is pressed
      }
        if(buf[i] == 'e')
      {
        stop();//stop/brake when e is pressed
      }
        if(buf[i] == 'a')
      {
        left();//go left when a is presed
      }
        if(buf[i] == 'd')
        {
          right();//go right when d is pressed
        }   
 }//close for loop
 }
}
 But who is going to define the movement routines?
void forward(){
analogWrite( rightMotor1, 150);
analogWrite(rightMotor2, 0);
analogWrite(leftMotor1, 150);
analogWrite(leftMotor2,0);
}

void left(){
analogWrite( rightMotor1, 150);
analogWrite(rightMotor2, 0);
analogWrite(leftMotor1, 0);
analogWrite(leftMotor2,100);
}

void stop(){
  analogWrite( rightMotor1, 0);
analogWrite(rightMotor2, 0);
analogWrite(leftMotor1, 0);
analogWrite(leftMotor2,0);
}
And in a similar way, you can complete the rest. Let us sum up the entire code for the RX-part:
#include <VirtualWire.h>
 
#define rightMotor1 5 
#define rightMotor2 6
#define leftMotor1 3
#define leftMotor2 11

void setup() {
    vw_setup(2000);  // Bits per sec
    vw_set_rx_pin(2);//Receiver at Digital Pin 2
    vw_rx_start();// Start the receiver PLL running
  pinMode(rightMotor1, OUTPUT);
  pinMode(rightMotor2, OUTPUT);
  pinMode(leftMotor1, OUTPUT);
  pinMode(leftMotor2, OUTPUT);
}   

void loop() {   
 uint8_t buf[VW_MAX_MESSAGE_LEN];
    uint8_t buflen = VW_MAX_MESSAGE_LEN;
    if (vw_get_message(buf, &buflen)) // Non-blocking
    {
 int i;

        digitalWrite(13, true); // Flash a light to show received good message
 
 for (i = 0; i < buflen; i++)
 {
     Serial.print(buf[i]);
        if(buf[i] == 'w')
        {
          forward();//go forward when w is pressed
        }
        if(buf[i] == 's')
      {
        backward();//go backward when s is pressed
      }
        if(buf[i] == 'e')
      {
        stop();//stop/brake when e is pressed
      }
        if(buf[i] == 'a')
      {
        left();//go left when a is presed
      }
        if(buf[i] == 'd')
        {
          right();//go right when d is pressed
        }   
 }//close for loop
 }
}

void forward(){
analogWrite( rightMotor1, 150);
analogWrite(rightMotor2, 0);
analogWrite(leftMotor1, 150);
analogWrite(leftMotor2,0);
}

void backward(){
analogWrite( rightMotor1, 0);
analogWrite(rightMotor2, 150);
analogWrite(leftMotor1, 0);
analogWrite(leftMotor2,150);
}

void right(){
analogWrite( rightMotor1, 0);
analogWrite(rightMotor2, 100);
analogWrite(leftMotor1, 150);
analogWrite(leftMotor2,0);
}

void left(){
analogWrite( rightMotor1, 150);
analogWrite(rightMotor2, 0);
analogWrite(leftMotor1, 0);
analogWrite(leftMotor2,100);
}

void stop(){ 
  analogWrite( rightMotor1, 0);
analogWrite(rightMotor2, 0);
analogWrite(leftMotor1, 0);
analogWrite(leftMotor2,0);
}

And that's it! You have just learned to control your robot in real-time through a computer keyboard via RF modules using the powerful and versatile programming language we all know, Python.

  • Tutorials - Control through mouse clicks via the Tkinter GUI library
The idea in controlling your robot via a Python GUI is very similar to that of controlling it via keyboard strokes. In the previous tutorial, there wasn't a GUI (Graphical User Interface). We simply sent character over to the robot through the command prompt. In this tutorial, we will do that through a GUI. The communication process between the two Arduinos remains the same. We'll just need to tweak our Python code to build a GUI (as we did in the RGB LED tutorial).
By now, you kind of have an idea about building a GUI. It's pretty similar to the RGB LED GUI but this one makes use of more well defined widgets
The first part of the code must be buzzing in your mind by now:
import serial # import the serial library
import time # import the time library
import msvcrt #import keyboard library
from Tkinter import * #import Tkinter GUI library 
 

def Up():
 arduino.write('w')
 
def Down():
 arduino.write('s')
 

def Left():
 arduino.write('a')
 

def Right():
 arduino.write('d')
 

def Stop():
 arduino.write('e')


print 'Connecting...'
arduino = serial.Serial(12, 9150)
time.sleep(3)
print 'Connection established successfully'
Now, we'll create a GUI window, with well-designed frames and well-positioned buttons. To do that, we make use of more options such as cell padding, highlightthickness, etc.
#Control Frame and its contents
controlFrame = Frame(appWindow, width=150, height = 150, bg="#037481", highlightthickness=2, highlightbackground="#111") #defines the control frame
controlFrame.grid() #positions the control frame with the corresponding parameters

btnFrame = Frame(controlFrame, width=150, height = 150, bg="#037481")# defines the button frame with these characteristics
btnFrame.grid() #positions the button frame inside which control buttons will reside
upBtn = Button(btnFrame, text="UP", command=Up, bg="green") #defines the UP button
upBtn.grid(row=2, column=2, padx=5, pady=5) #positions the UP button within the button frame

downBtn = Button(btnFrame, text="DOWN", command=Down, bg="yellow") #defines the DOWN button
downBtn.grid(row=4, column=2, padx=5, pady=5) #positions the UP button within the button frame

leftBtn = Button(btnFrame, text="LEFT", command=Left, bg="orange") #defines the LEFT button
leftBtn.grid(row=3, column=0, padx=5, pady=5) #positions the LEFT button within the button frame

rightBtn = Button(btnFrame, text="RIGHT", command=Right, bg="blue") #defines the RIGHT button
rightBtn.grid(row=3, column=3, padx=5, pady=5) #positions the RIGHT button within the button frame

stopBtn = Button(btnFrame, text="STOP", command=Stop, bg="red") #defines the STOP button
stopBtn.grid(row=3, column=2, padx=5, pady=5) #positions the STOP button within the button frame

appWindow.mainloop()# begins main loop
Once you merge the two slices of code above, save the file as  GUI.py or something. You should get the following window:
GUI Control A
You can also use the widget "label" to add some text of your own, such as your name, or application options and instructions, etc. For eg:
name = Label(btnFrame, width=12, height=1, text="GUI CONTROL", font="bold", justify=CENTER, bg="#037481")
name.grid(row=0, column=2)
Using two lines of code, you can add text into your GUI:
GUI CONTROL B
Summing up the entire code , just to get things clearer:
import serial # import the serial library
import time # import the time library
import msvcrt #import keyboard library
from Tkinter import * #import Tkinter GUI library 
 

def Up():
 arduino.write('w')
 
def Down():
 arduino.write('s')
 

def Left():
 arduino.write('a')
 

def Right():
 arduino.write('d')
 

def Stop():
 arduino.write('e')


print 'Connecting...'
arduino = serial.Serial(12, 9150)
time.sleep(3)
print 'Connection established successfully'

appWindow = Tk() # creates the application window (you can use any name)
appWindow.wm_title("GUI CONTROL") #Makes the title that will appear in the top left
appWindow.config(bg = "#828481")


#Control Frame and its contents
controlFrame = Frame(appWindow, width=150, height = 150, bg="#037481", highlightthickness=2, highlightbackground="#111") #defines the control frame
controlFrame.grid() #positions the control frame with the corresponding parameters

btnFrame = Frame(controlFrame, width=150, height = 150, bg="#037481")# defines the button frame with these characteristics
btnFrame.grid() #positions the button frame inside which control buttons will reside

about = "GUI CONTROL"
name = Label(btnFrame, width=12, height=1, text=about, font="bold", justify=CENTER, bg="#037481")
name.grid(row=0, column=2)

upBtn = Button(btnFrame, text="UP", command=Up, bg="green") #defines the UP button
upBtn.grid(row=2, column=2, padx=5, pady=5) #positions the UP button within the button frame

downBtn = Button(btnFrame, text="DOWN", command=Down, bg="yellow") #defines the DOWN button
downBtn.grid(row=4, column=2, padx=5, pady=5) #positions the UP button within the button frame

leftBtn = Button(btnFrame, text="LEFT", command=Left, bg="orange") #defines the LEFT button
leftBtn.grid(row=3, column=0, padx=5, pady=5) #positions the LEFT button within the button frame

rightBtn = Button(btnFrame, text="RIGHT", command=Right, bg="blue") #defines the RIGHT button
rightBtn.grid(row=3, column=3, padx=5, pady=5) #positions the RIGHT button within the button frame

stopBtn = Button(btnFrame, text="STOP", command=Stop, bg="red") #defines the STOP button
stopBtn.grid(row=3, column=2, padx=5, pady=5) #positions the STOP button within the button frame

appWindow.mainloop()# begins main loop
The Arduino communication remains the same, as I mentioned earlier. Please refer to the earlier tutorial of Control using keyboard strokes via the msvcrt library for that portion. Once everything is settled, you can control a robot via a Python GUI like this.


FUTURE UPDATES:
There are a couple of more updates to come so watch out! I am learning a couple of things using Python GTK and Glade to build GUIs and will update once I get some working results. Using GLADE + pyGTK is going to be even more interesting opening up wider possibilities while designing a GUI, such as easier creation of GUIs and cross-platform compatibility.


There might have been some errors in this tutorial as I myself just started playing around with Python not very long ago. And so, I would be grateful if you point them out just in case you pass by them. This tutorial is also not in the best of organized forms at the moment and I plan to work on that part as well Thanks for passing by and going through this tutorial. Feedback is much appreciated.
See you in the ShotBox, LMRians (try the new SB popout, it's cool!)
-Ashim
References : 
Python Official Website
Robotic Controls (Very awesome site. Learnt most things about Python GUI development right here)
Robodude's Instructable (Robodude's tutorial made it straightforward to intgerate RF Modules) You can also manually download the Virtual Wire Library here.
StackOverFlow (for tackling various errors encountered. Updates on a few soon, hopefully)
Google (Always your best friend on the internet)