Mostrando entradas con la etiqueta COMUNICACIÓN. Mostrar todas las entradas
Mostrando entradas con la etiqueta COMUNICACIÓN. Mostrar todas las entradas

Tutorial - Comunicación serial (Onceava parte - Envío y recepción de datos) / Stream - pull mode

Para el siguiente experimento simularemos un sistema Stream y Pull. Cuando usamos el modo Stream los datos de un potenciómetro y PWM se leerán en tiempo real, mientras podemos ingresar el valor de un PWM nuevo para ser enviado al Arduino. En caso del modo Pull, el dato del potenciómetro puede ser pedido cuando desee el usuario, y de la misma manera que con el PWM.

Los únicos pines que pueden usar la función de salida PWM en el caso del Arduino UNO de manera nativa son:
# 11
# 10
# 9
# 6
# 5
# 3

La conexión es la siguiente:
# PIN D11 : Arduino UNO => Resistencia => LED : Ánodo
# PIN A0 : Arduino UNO => Potenciómetro : Pin central
# 5V : Arduino UNO => Potenciómetro : Extremo
# GND : Arduino UNO => LED: Cátodo => Potenciómetro : Extremo


El programa usado para el Arduino es el que se muestra:
/* PROGRAMA DE PRUEBA DE COMUNICACION SERIAL
   CONEXION:
             Arduino (D11) : Anodo del led (pin positivo)
             Arduino (GND) : Catodo del led (pin negativo), extremo del potenciometro
             Arduino (A0)  : Pin central del potenciometro
             Arduino (5V)  : Extremo del potenciometro
     
   El siguiente programa nos ayuda a enviar una trama ingresada por puerto serial para ser leida por el Arduino y 
   ser convertida en el valor del PWM de 0 a 100% (0 - 255 bits) y lee a la vez el potenciometro que va
   al pin A0 de Arduino y lo convierte de 0 a 5V. Con dos modos: Stream y pull mode

   NOTA: Los pienes que poseen salida PWM son 3, 5, 6, 9, 10 y 11
     
   Autor: Renato Hurtado
   http://beetlecraft.blogspot.pe/
    
   El siguiente programa es de uso publico, cualquier modificacion o mal uso del mismo que pudiera ocasionar el mal 
   funcionamiento de la plataforma de uso de la misma no es responsabilidad del autor
*/

const int led = 11; // Variable asignada al pin led
int data, mod = 0, pwm = 0; // Variable de almacenamiento del dato por puerto serial, pwm y seleccion de modo
int det = 0; // Determinante para desentascamiento

void setup() {
  pinMode(led, OUTPUT); // Configuracion del pin led como salida
  Serial.begin(9600);   // Comunicacion serial a 9600 bps
}

void loop() {
  if(Serial.available()) {     // Lectura del puerto mientras sigue abierto
    if (Serial.peek() == 'S'){ // Detecta la letra S para ingresar al modo Stream
      mod = 1; // Flag de seleccion de modo
      delay(10);
    }
    else if(Serial.peek() == 'P'){ // Detecta la letra P para ingresar al modo Pull
      mod = 2; // Flag de seleccion de modo
      delay(10);
    }
    while (Serial.available() > 0){Serial.read();} // Rutina de limpieza del buffer del puerto serial
  }

  modos(); // Ingreso a la funcion de modos
}

void modos(){ // Funcion de modos Stream y Pull
  switch (mod){
    case 1:             // Caso 1: Modo Stream
      while (mod == 1){ // Mantiene en el modo Stream
        lectura_pot();  // Funcion de lectura de potenciometro
        envio_pwm();    // Funcion de lectura y envio de PWM
        delay(100);
        
        if (Serial.peek() == 'P'){ // Deteccion de cambio a modo Pull
          mod = 2; // Flag de seleccion de modo
          delay(10);
        }
        
        desentascamiento(); // Algoritmo de desentascamiento
      }
    break;
    
    case 2:              // Caso 2: Modo Pull
       while (mod == 2){ // Mantiene en el modo Pull
         envio_pwm();    // Funcion de lectura y envio de PWM
         
         if (Serial.peek() == 'l'){ // Deteccion para funcion de lectura de potenciometro 
           lectura_pot(); // Funcion de lectura de potenciometro
           break;         // Salto para evitar bucle infinito
         }
         if (Serial.peek() == 'S'){ // Deteccion de cambio a modo Stream
           mod = 1; // Flag de seleccion de modo
           delay(10);
         }
                 
         desentascamiento(); // Algoritmo de desentascamiento
       }
    break;
  }
}

void lectura_pot(){
  int pot = analogRead(A0); // Lectura del potenciometro
  Serial.println(pot);      // Envio del dato por puerto serial
}

void envio_pwm(){
  if (Serial.peek() == 'p'){         // Deteccion de la letra p para ingresar valor de PWM
    data = Serial.parseInt();        // Extraccion del integer del dato leido
    pwm = map(data, 0, 100, 0, 255); // Cambio de formato del dato de 0 - 100%, a 0 - 255
      
    analogWrite(led, pwm); // Salida PWM en el led de 0 a 255
  }
}

void desentascamiento(){ // Algoritmo de desentascamiento
  if (Serial.available() > 0){det++;} // Deteccion de caracteres en el buffer
    else {det = 0;}   // Reseteo del contador de deteccion
    while (det > 1) { // Limpieza del buffer por entascamiento
      Serial.read();  
      if (Serial.available() == 0){det = 0;} // Reseteo del contador de deteccion
    }  
}
El programa en Processing es el siguiente:
/* PROGRAMA DE PRUEBA DE COMUNICACION SERIAL
     
   El siguiente programa nos ayuda a enviar el valor pwm de 0 a 100% a un Arduino y recibimos en 
   contraparte el valor de un potenciometro usando dos modos, uno Stream y otro Pull.
   
   Autor: Renato Hurtado
   http://beetlecraft.blogspot.pe/
    
   El siguiente programa es de uso publico, cualquier modificacion o mal uso del mismo que pudiera 
   ocasionar el mal funcionamiento de la plataforma de uso de la misma no es responsabilidad del autor
*/

import controlP5.*; // Importacion de la libreria controlP5
ControlP5 cp5;      // Creacion del objeto cp5 para el ControlP5

String[] cabeceraBSP = {"Stream", "Pull"}; // Cabecera de los botones

String pwm = "0", data, val_mod = "0"; // Dato de almacenamiento del cuadro de texto, envio y auxiliar
float val; // Variables de lectura

PFont fuente; // Creacion del objeto fuente

import processing.serial.*; // Inicio de la comunicación serial
Serial puerto;              // Crea el puerto serial

void setup() {
  size(340, 260); // Porte de la pantalla ancho, alto
  background(0);  // Color de fondo

  String ArduinoPuerto = Serial.list()[0];        // Encuentra el primer puerto serial para iniciar la comunicacion
  puerto = new Serial(this, ArduinoPuerto, 9600); // Inicio de la comunicacion con el primer puerto encontrado
  
  fuente = createFont("arial", 15); // Tamano de la fuente y tipo
  
  cp5 = new ControlP5(this); // Inicializacion de la funcion cp5
  
  int x = 20, espaciamiento = 100; // Variables de almacenamiento de coordenada y espaciamiento
  
  // Construccion de los botones Stream y Pull
  for(String nombre: cabeceraBSP){
    cp5.addBang(nombre)    // Nombre del boton
       .setPosition(x, 20) // Ubicacion del boton en la ubicacion x, y
       .setSize(80, 40)    // Tamano del boton ancho, alto
       .setFont(fuente);   // Fuente del texto
    x += espaciamiento;    // Espaciamiento para el siguiente campo de texto 
  }
  
  // Construccion del envio del valor PWM, campo de texto y boton
  cp5.addTextfield("PWM")  // Nombre del cuadro de texto
     .setPosition(20, 100) // Ubicacion del boton en la ubicacion x, y
     .setSize(200, 40)     // Tamano del boton ancho, alto
     .setFont(fuente)      // Fuente del texto
     .setAutoClear(false); // No se limpia el campo de texto con "Enter"
 
  cp5.addBang("Enviar")     // Nombre del boton
     .setPosition(240, 100) // Ubicacion del boton en la ubicacion x, y
     .setSize(80, 40)       // Tamano del boton ancho, alto
     .setFont(fuente);      // Fuente del texto  
  
  // Construccion del boton recepcion en caso de Pull mode   
  cp5.addBang("Recibir")    // Nombre del boton
     .setPosition(240, 180) // Ubicacion del boton en la ubicacion x, y
     .setSize(80, 40)       // Tamano del boton ancho, alto
     .setFont(fuente);      // Fuente del texto  
}
 
void draw () {
  lectura();             // Funcion de lectura del potenciometro
  campo_texto_lectura(); // Campo de texto de lectura del potenciometro
}

void lectura(){
  String mensaje = puerto.readStringUntil('\n'); // Lee la cadena hasta encontrar un enter
 
  if (mensaje != null) {
    mensaje = trim(mensaje);       // Se quita los espacios en blanco:
    val = float(mensaje);          // Convierte en flotante el String leido
    val = map(val, 0, 1023, 0, 5); // Convierte el dato en la altura de salida
    val = 1000 * val;              // Conversion de voltios a milivoltios
    val_mod = nf(val, 4, 2);       // Limita los digitos a la derecha, izquierda
    println("Voltaje: " + val_mod + " mV"); // Muestra el dato en el puerto serial
  }
}

void campo_texto_lectura(){
  // Creacion de la etiqueta
  textFont(fuente);         // Fuente de la letra
  fill(255, 255, 255);      // Valor de rojo, verde y azul de la letra
  text("VOLTAJE", 20, 240); // Texto, coordenada en x, coordenada en y
  
  // Muestra del dato por pantalla
  fill(255, 255, 255);    // Valor de rojo, verde y azul del cajetin
  rect(20, 180, 200, 40); // Creacion del cajetin para dato coordenada x, y, ancho, alto
  textFont(fuente);       // Fuente de la letra
  fill(0, 102, 153);      // Valor de rojo, verde y azul de la letra
  text(val_mod + " mV", 30, 210); // Texto de presentacion del dato, coordenada en x, coordenada en y  
}

void Stream() { puerto.write('S'); } // Envio de la letra "S" al apretar el boton "Stream"
void Pull()   { puerto.write('P'); } // Envio de la letra "P" al apretar el boton "Pull"
void Recibir(){ puerto.write('l'); } // Envio de la letra "l" al apretar el boton "Recibir" 

void Enviar() {
  // Lectura del valor obtenido del campo de texto
  pwm = cp5.get(Textfield.class, "PWM").getText();
  
  data = 'p' + pwm;   // Armado de la data de envio
  puerto.write(data); // Escritura del valor del PWM (envio de data al Arduino)

  // Mensaje de confirmacion de envio del PWM
  println("PWM enviado: " + pwm); println("Dato enviado: " + data);
    
  // Borra el cuadro de texto despues de apretar el boton
  cp5.get(Textfield.class, "PWM").clear(); 
}
Los resultados son los siguientes:









Autor: 

Tutorial - Comunicación serial: Parte 2 (Envío y recepción de datos) / Stream y Pull mode

Para el siguiente experimento simularemos un sistema Stream y Pull. Cuando usamos el modo Stream los datos de un potenciómetro y PWM se leerán en tiempo real, mientras podemos ingresar el valor de un PWM nuevo para ser enviado al Arduino. En caso del modo Pull, el dato del potenciómetro puede ser pedido cuando desee el usuario, y de la misma manera que con el PWM.

Los únicos pines que pueden usar la función de salida PWM en el caso del Arduino UNO de manera nativa son:
# 11
# 10
# 9
# 6
# 5
# 3

La conexión es la siguiente:
# PIN D11 : Arduino UNO => Resistencia => LED : Ánodo
# PIN A0 : Arduino UNO => Potenciómetro : Pin central
# 5V : Arduino UNO => Potenciómetro : Extremo
# GND : Arduino UNO => LED: Cátodo => Potenciómetro : Extremo


El programa usado para el Arduino es el que se muestra:
/* PROGRAMA DE PRUEBA DE COMUNICACION SERIAL
   CONEXION:
             Arduino (D11) : Anodo del led (pin positivo)
             Arduino (GND) : Catodo del led (pin negativo), extremo del potenciometro
             Arduino (A0)  : Pin central del potenciometro
             Arduino (5V)  : Extremo del potenciometro
     
   El siguiente programa nos ayuda a enviar una trama ingresada por puerto serial para ser leida por el Arduino y 
   ser convertida en el valor del PWM de 0 a 100% (0 - 255 bits) y lee a la vez el potenciometro que va
   al pin A0 de Arduino y lo convierte de 0 a 5V. Con dos modos: Stream y pull mode

   NOTA: Los pienes que poseen salida PWM son 3, 5, 6, 9, 10 y 11
     
   Autor: Renato Hurtado
   http://beetlecraft.blogspot.pe/
    
   El siguiente programa es de uso publico, cualquier modificacion o mal uso del mismo que pudiera ocasionar el mal 
   funcionamiento de la plataforma de uso de la misma no es responsabilidad del autor
*/

const int led = 11; // Variable asignada al pin led
int data, mod = 0, pwm = 0; // Variable de almacenamiento del dato por puerto serial, pwm y seleccion de modo
int det = 0; // Determinante para desentascamiento

void setup() {
  pinMode(led, OUTPUT); // Configuracion del pin led como salida
  Serial.begin(9600);   // Comunicacion serial a 9600 bps

  // Mensaje inicial 
  Serial.println("MODOS:");
  Serial.println("Stream mode: Ingresar 'S' ");
  Serial.println("             PWM: Ingresar 'pxxx' (xxx: valor de 0 a 100) ");
  Serial.println("Pull mode: Ingresar 'P' ");
  Serial.println("           Lectura potenciometro: Ingresar 'l' ");
  Serial.println("           PWM: Ingresar 'pxxx' (xxx: valor de 0 a 100) ");
}

void loop() {
  if(Serial.available()){  // Lectura del puerto mientras sigue abierto
    if (Serial.peek() == 'S'){ // Detecta la letra S para ingresar al modo Stream
      mod = 1; // Flag de seleccion de modo
      Serial.println("Stream mode..."); // Mensaje inicial
      delay(1000);
    }
    else if(Serial.peek() == 'P'){ // Detecta la letra P para ingresar al modo Pull
      mod = 2; // Flag de seleccion de modo
      Serial.println("Pull mode..."); // Mensaje inicial
      delay(1000);
    }
    while (Serial.available() > 0){Serial.read();} // Rutina de limpieza del buffer del puerto serial
  }

  modos(); // Ingreso a la funcion de modos
}

void modos(){ // Funcion de modos Stream y Pull
  switch (mod){
    case 1:             // Caso 1: Modo Stream
      while (mod == 1){ // Mantiene en el modo Stream
        envio_pwm();    // Funcion de lectura y envio de PWM
        lectura_pot();  // Funcion de lectura de potenciometro
        delay(500);

        // Lectura del valor de PWM y muestra en monitor serial
        Serial.print("PWM: "); Serial.println(pwm);

        if (Serial.peek() == 'P'){ // Deteccion de cambio a modo Pull
          mod = 2; // Flag de seleccion de modo
          Serial.println("Pull mode..."); // Mensaje inicial
          delay(1000);
        }

        desentascamiento(); // Algoritmo de desentascamiento
      }
    break;
    
    case 2:              // Caso 2: Modo Pull
       while (mod == 2){ // Mantiene en el modo Pull
         envio_pwm();    // Funcion de lectura y envio de PWM
         
         if (Serial.peek() == 'l'){ // Deteccion para funcion de lectura de potenciometro 
           lectura_pot(); // Funcion de lectura de potenciometro
           break;         // Salto para evitar bucle infinito
         }
         if (Serial.peek() == 'S'){ // Deteccion de cambio a modo Stream
           mod = 1; // Flag de seleccion de modo
           Serial.println("Stream mode..."); // Mensaje inicial
           delay(1000);
         }

         desentascamiento(); // Algoritmo de desentascamiento
       }
    break;
  }
}

void lectura_pot(){
  int pot = analogRead(A0);             // Lecutra del potenciometro
  float pot_mod = pot * (5.0 / 1023.0); // Conversion de 0 - 1023 bits a 0 - 5V en decimales
  
  // Muestra del potenciometro por pantalla
  Serial.print("Voltaje: "); 
  Serial.println(pot_mod); 
}

void envio_pwm(){
  if (Serial.peek() == 'p'){         // Deteccion de la letra p para ingresar valor de PWM
    data = Serial.parseInt();        // Extraccion del integer del dato leido
    pwm = map(data, 0, 100, 0, 255); // Cambio de formato del dato de 0 - 100%, a 0 - 255
  
    // Muestra del dato en pantalla
    Serial.print("Porcentaje: "); Serial.print(data); Serial.println(" %");
    Serial.print("PWM: "); Serial.println(pwm);
    
    analogWrite(led, pwm); // Salida PWM en el led de 0 a 255
  }
}

void desentascamiento(){ // Algoritmo de desentascamiento
  if (Serial.available() > 0){det++;} // Deteccion de caracteres en el buffer
    else {det = 0;}   // Reseteo del contador de deteccion
    while (det > 1) { // Limpieza del buffer por entascamiento
      Serial.read();  
      if (Serial.available() == 0){det = 0;} // Reseteo del contador de deteccion
    }  
}
Los resultados son los siguientes:












Autor: 

Tutorial - Comunicación serial: Parte 1 (Envío y recepción de datos) / Streaming

Para el siguiente experimento, enviaremos un dato que varía entre 0 a 100 que corresponde de 0 a 100%, que es análogo de los 0 a 255 bits que maneja la salida PWM a través de la función "AnalogWrite()", y que se distingue en la intensidad de luz del led, siendo 0% un led apagado y 100% un led totalmente prendido.

Los únicos pines que pueden usar la función de salida PWM en el caso del Arduino UNO de manera nativa son:
# 11
# 10
# 9
# 6
# 5
# 3

A la vez, se leerá en paralelo el valor del voltaje del potenciómetro con formato decimal que se mostrará en pantalla a través del Monitor Serial de Arduino.

La conexión es la siguiente:
# PIN D11 : Arduino UNO => Resistencia => LED : Ánodo
# PIN A0 : Arduino UNO => Potenciómetro : Pin central
# 5V : Arduino UNO => Potenciómetro : Extremo
# GND : Arduino UNO => LED: Cátodo => Potenciómetro : Extremo


El programa usado para el Arduino es el que se muestra:
/* PROGRAMA DE PRUEBA DE COMUNICACION SERIAL
   CONEXION:
             Arduino (D11) : Anodo del led (pin positivo)
             Arduino (GND) : Catodo del led (pin negativo), extremo del potenciometro
             Arduino (A0)  : Pin central del potenciometro
             Arduino (5V)  : Extremo del potenciometro
     
   El siguiente programa nos ayuda a enviar una trama ingresada por puerto serial para ser leida por el Arduino y 
   ser convertida en el valor del PWM de 0 a 100% (0 - 255 bits) y lee a la vez el potenciometro que va
   al pin A0 de Arduino y lo convierte de 0 a 5V

   NOTA: Los pienes que poseen salida PWM son 3, 5, 6, 9, 10 y 11
     
   Autor: Renato Hurtado
   http://beetlecraft.blogspot.pe/
    
   El siguiente programa es de uso publico, cualquier modificacion o mal uso del mismo que pudiera ocasionar el mal 
   funcionamiento de la plataforma de uso de la misma no es responsabilidad del autor
*/

const int led = 11; // Variable asignada al pin led
int data;           // Variable de almacenamiento del dato por puerto serial

void setup() {
  pinMode(led, OUTPUT); // Configuracion del pin led como salida
  Serial.begin(9600);   // Comunicacion serial a 9600 bps
  Serial.println("Ingresar un valor de 0 a 100"); // Mensaje inicial 
  delay(1000);
}

void loop() {
  int pot = analogRead(A0);             // Lecutra del potenciometro
  float pot_mod = pot * (5.0 / 1023.0); // Conversion de 0 - 1023 bits a 0 - 5V en decimales

  // Muestra del potenciometro por pantalla
  Serial.print("Voltaje: "); 
  Serial.println(pot_mod); 
  delay(1000);
  
  if(Serial.available() > 0){ // Lectura del puerto mientras sigue abierto
    data = Serial.parseInt();            // Extraccion del integer del dato leido
    int pwm = map(data, 0, 100, 0, 255); // Cambio de formato del dato de 0 - 100%, a 0 - 255

    // Muestra del dato en pantalla
    Serial.print("Porcentaje: "); Serial.print(data); Serial.println(" %");
    Serial.print("PWM: "); Serial.println(pwm);
    
    analogWrite(led, pwm); // Salida PWM en el led de 0 a 255
    
    while (Serial.available() > 0){Serial.read();} // Rutina de limpieza del buffer del puerto serial
  }
}
Los resultados son los siguientes:




Autor: 

Tutorial - Comunicación serial (Décima parte - Envío de datos multivariable y multifunción con botón único)

Para el siguiente experimento, enviaremos un dato que varía entre 0 a 100 que corresponde de 0 a 100%, que es análogo de los 0 a 255 bits que maneja la salida PWM a través de la función "AnalogWrite()", y que se distingue en la intensidad de luz del led, siendo 0% un led apagado y 100% un led totalmente prendido.

Los únicos pines que pueden usar la función de salida PWM en el caso del Arduino UNO de manera nativa son:
# 11
# 10
# 9
# 6
# 5
# 3

Esta data mencionada, será enviada usando una GUI elaborada en Processing usando la librería ControlP5, el dato será ingresado en cuato campos de texto y el envío es por medio de un botón único por cada dos campos. Con esto, simularemos lo que haríamos en caso de querer enviar datos a dos procesos diferentes que actúan en paralelo.

La conexión es la siguiente:
# PIN D11 : Arduino UNO => Resistencia => LED 1 : Ánodo
# PIN D10 : Arduino UNO => Resistencia => LED 2 : Ánodo
# PIN D9 : Arduino UNO => Resistencia => LED 3 : Ánodo
# PIN D6 : Arduino UNO => Resistencia => LED 4 : Ánodo
# GND : Arduino UNO => LED 1, 2, 3 y 4: Cátodo


El programa usado para el Arduino es el que se muestra:
/* PROGRAMA DE PRUEBA DE COMUNICACION SERIAL
   CONEXION:
             GRUPO 1
             Arduino (D11) : Catodo del led 1 
             Arduino (D10) : Catodo del led 2
             Arduino (GND): Anodo del led 1, 2

             GRUPO 2
             Arduino (D9) : Catodo del led 3 
             Arduino (D6) : Catodo del led 4
             Arduino (GND): Anodo del led 3, 4
             
   El siguiente programa nos ayuda a enviar una trama ingresada por puerto serial para ser leida por el 
   Arduino y ser convertida en el valor del PWM de 0 a 100% (0 - 255 bits)

   Formato del dato: Aporcentaje_1,porcentaje_2 como AXXX,YYY
                     Bporcentaje_3,porcentaje_4 como BXXX,YYY

   NOTA: Los pienes que poseen salida PWM son 3, 5, 6, 9, 10 y 11

   Autor: Renato Hurtado
   http://beetlecraft.blogspot.pe/
    
   El siguiente programa es de uso publico, cualquier modificacion o mal uso del mismo que pudiera 
   ocasionar el mal funcionamiento de la plataforma de uso de la misma no es responsabilidad del autor
*/

const int led_1 = 11, led_2 = 10, led_3 = 10, led_4 = 9; // Variable asignada al pin led 1, 2, 3 y 4
String data; // Variable asignada al dato obtenido

void setup() {
  pinMode(led_1, OUTPUT); // Configuracion del pin led 1 como salida
  pinMode(led_2, OUTPUT); // Configuracion del pin led 2 como salida
  pinMode(led_3, OUTPUT); // Configuracion del pin led 3 como salida
  pinMode(led_4, OUTPUT); // Configuracion del pin led 4 como salida
  Serial.begin(9600);     // Comunicacion serial a 9600 bps

  // Mensaje inicial
  Serial.println("Ingresar el dato como:");
  Serial.println("Aporcentaje_1,porcentaje_2 o Bporcentaje_3,porcentaje_4");
  Serial.println("Formato: AXXX,YYY");
  Serial.println("Ejemplo: A10,100 (10% y 100%)");
}

void loop() {
  if(Serial.available() > 0){ // Lectura del puerto mientras sigue abierto
    funcion_A(); funcion_B(); // Funcion A y B
    //while (Serial.available() > 0){Serial.read();} // Rutina de limpieza del buffer del puerto serial
  }
}

void funcion_A(){
  if (Serial.peek() == 'A'){ // Discriminacion de la funcion A
    data = Serial.readStringUntil('\n');                   // Lectura del dato hasta el line feed 
    Serial.print("Dato original: "); Serial.println(data); // Muestra del dato original
    data.remove(0,1);                                      // Remueve la letra A
       
    int n, pwm_1, pwm_2; // Variables de almacenamiento de pwm y para algoritmo de lectura
     
    for (int i = 0; i <= data.length(); i++){ // Lectura total del tamano del dato
      if (data.substring(i, i+1) == ","){     // Lectura del dato hasta encontrar el caracter ","
        pwm_1 = data.substring(0, i).toInt(); // Conversion del dato obtenido del porcentaje del pwm 1
        n = i + 1;                            // Posicion de la letra final leida + 1
      }
    }

    // Lectura total del tamano del dato desde el ultimo punto
    for (int i = n; i <= data.length(); i++){ pwm_2 = data.substring(n, i).toInt(); }

    // Muestra del dato del porcentaje de PWM 1 y 2
    Serial.print("Procentaje 1: "); Serial.print(pwm_1); Serial.println(" %");
    Serial.print("Procentaje 2: "); Serial.print(pwm_2); Serial.println(" %");
     
    pwm_1 = map(pwm_1, 0, 100, 0, 255); // Cambio de formato del dato de 0 - 100%, a 0 - 255
    pwm_2 = map(pwm_2, 0, 100, 0, 255); // Cambio de formato del dato de 0 - 100%, a 0 - 255

    // Muestra del dato en pantalla
    Serial.print("PWM 1: "); Serial.println(pwm_1);
    Serial.print("PWM 2: "); Serial.println(pwm_2);

    // Salida PWM en el led de 0 a 255
    analogWrite(led_1, pwm_1); analogWrite(led_2, pwm_2);
  }
}

void funcion_B(){
  if (Serial.peek() == 'B'){ // Discriminacion de la funcion B
    data = Serial.readStringUntil('\n');                   // Lectura del dato hasta el line feed 
    Serial.print("Dato original: "); Serial.println(data); // Muestra del dato original
    data.remove(0,1);                                      // Remueve la letra B
           
    int n, pwm_1, pwm_2; // Variables de almacenamiento de pwm y para algoritmo de lectura
     
    for (int i = 0; i <= data.length(); i++){ // Lectura total del tamano del dato
      if (data.substring(i, i+1) == ","){     // Lectura del dato hasta encontrar el caracter ","
        pwm_1 = data.substring(0, i).toInt(); // Conversion del dato obtenido del porcentaje del pwm 1
        n = i + 1;                            // Posicion de la letra final leida + 1
      }
    }

    // Lectura total del tamano del dato desde el ultimo punto
    for (int i = n; i <= data.length(); i++){ pwm_2 = data.substring(n, i).toInt(); }

    // Muestra del dato del porcentaje de PWM 1 y 2
    Serial.print("Procentaje 3: "); Serial.print(pwm_1); Serial.println(" %");
    Serial.print("Procentaje 4: "); Serial.print(pwm_2); Serial.println(" %");
     
    pwm_1 = map(pwm_1, 0, 100, 0, 255); // Cambio de formato del dato de 0 - 100%, a 0 - 255
    pwm_2 = map(pwm_2, 0, 100, 0, 255); // Cambio de formato del dato de 0 - 100%, a 0 - 255

    // Muestra del dato en pantalla
    Serial.print("PWM 3: "); Serial.println(pwm_1);
    Serial.print("PWM 4: "); Serial.println(pwm_2);

    // Salida PWM en el led de 0 a 255
    analogWrite(led_3, pwm_1); analogWrite(led_4, pwm_2);
  }
}
El programa en Processing es el siguiente:
/* PROGRAMA DE PRUEBA DE COMUNICACION SERIAL
     
   El siguiente programa nos ayuda a enviar el valor pwm de 0 a 100% a un Arduino y
   recibimos en contraparte la confirmacion del valor del PWM de 0 a 255 y el porcentaje

   Autor: Renato Hurtado
   http://beetlecraft.blogspot.pe/
    
   El siguiente programa es de uso publico, cualquier modificacion o mal uso del mismo que pudiera 
   ocasionar el mal funcionamiento de la plataforma de uso de la misma no es responsabilidad del autor
*/

import controlP5.*; // Importacion de la libreria controlP5
ControlP5 cp5;      // Creacion del objeto cp5 para el ControlP5

String[] cabeceraCT = {"PWM 1", "PWM 2", "PWM 3", "PWM 4"}; // Cabecera del campo de texto
String[] cabeceraB = {"Enviar1", "Enviar2"}; // Cabecera de los botones

// Dato de almacenamiento del cuadro de texto y envio
String pwm_1 = "0", pwm_2 = "0", pwm_3 = "0", pwm_4 = "0", data_1, data_2;
short LF = 10; // ASCII linefeed

import processing.serial.*; //Inicio de la comunicación serial
Serial puerto;              // Crea el puerto serial

void setup() {
  size(340, 340); // Porte de la pantalla ancho, alto

  String ArduinoPuerto = Serial.list()[0];        // Encuentra el primer puerto serial para iniciar la comunicacion
  puerto = new Serial(this, ArduinoPuerto, 9600); // Inicio de la comunicacion con el primer puerto encontrado
  
  PFont fuente = createFont( "arial", 15); // Tamano de la fuente y tipo
  
  cp5 = new ControlP5(this); // Inicializacion de la funcion cp5
  
  int y = 20, espaciamiento = 80; // Variables de almacenamiento de coordenada "y" y espaciamiento
  
  for(String nombre: cabeceraCT){
    cp5.addTextfield(nombre)   // Nombre del cuadro de texto
       .setPosition(20, y)     // Ubicacion del boton en la ubicacion x, y
       .setSize(200, 40)       // Tamano del boton ancho, alto
       .setFont(fuente)        // Fuente del texto
       .setAutoClear(false);   // No se limpia el campo de texto con "Enter"
    y += espaciamiento;        // Espaciamiento para el siguiente campo de texto       
  }
  
  y = 100; // reseteo de la ubicacion en y
  
  for(String nombre: cabeceraB){
    cp5.addBang(nombre)     // Nombre del boton
       .setPosition(240, y) // Ubicacion del boton en la ubicacion x, y
       .setSize(80, 40)     // Tamano del boton ancho, alto
       .setFont(fuente);    // Fuente del texto
    y += 2*espaciamiento;   // Espaciamiento para el siguiente campo de texto 
  }
}
 
void draw () {
  String mensaje = puerto.readStringUntil(LF); // Lee todo el mensaje hasta encontrar el linefeed
   
  if (mensaje != null) { // Si el dato no es null
    print(mensaje);      // Muestra en pantalla del mensaje original de Arduino
  }
  
  background(0); // Color de fondo
}
 
void Enviar1() {
  // Lectura del valor obtenido del campo de texto
  pwm_1 = cp5.get(Textfield.class, "PWM 1").getText();
  pwm_2 = cp5.get(Textfield.class, "PWM 2").getText();
  
  // Mensaje de confirmacion de envio del PWM
  println("PWM 1 enviado: " + pwm_1); println("PWM 2 enviado: " + pwm_2);
  data_1 = 'A' + pwm_1 + ',' + pwm_2; // Armado de la data de envio
  puerto.write(data_1); // Escritura del valor del PWM (envio de data al Arduino)
    
  // Borra el cuadro de texto despues de apretar el boton
  cp5.get(Textfield.class, "PWM 1").clear();
  cp5.get(Textfield.class, "PWM 2").clear(); 
}

void Enviar2() {
  // Lectura del valor obtenido del campo de texto
  pwm_3 = cp5.get(Textfield.class, "PWM 3").getText();
  pwm_4 = cp5.get(Textfield.class, "PWM 4").getText();
  
  // Mensaje de confirmacion de envio del PWM
  println("PWM 3 enviado: " + pwm_3); println("PWM 4 enviado: " + pwm_4);
  data_2 = 'B' + pwm_3 + ',' + pwm_4; // Armado de la data de envio
  puerto.write(data_2); // Escritura del valor del PWM (envio de data al Arduino)
    
  // Borra el cuadro de texto despues de apretar el boton
  cp5.get(Textfield.class, "PWM 3").clear();
  cp5.get(Textfield.class, "PWM 4").clear(); 
}
Los resultados son los siguientes:




Autor: 

Tutorial - Comunicación serial (Novena parte - Envío de datos multivariable con botón único)

Para el siguiente experimento, enviaremos un dato que varía entre 0 a 100 que corresponde de 0 a 100%, que es análogo de los 0 a 255 bits que maneja la salida PWM a través de la función "AnalogWrite()", y que se distingue en la intensidad de luz del led, siendo 0% un led apagado y 100% un led totalmente prendido.

Los únicos pines que pueden usar la función de salida PWM en el caso del Arduino UNO de manera nativa son:
# 11
# 10
# 9
# 6
# 5
# 3

Esta data mencionada, será enviada usando una GUI elaborada en Processing usando la librería ControlP5, el dato será ingresado en dos campos de texto y el envío es por medio de un botón único.

La conexión es la siguiente:
# PIN D11 : Arduino UNO => Resistencia => LED 1 : Ánodo
# PIN D10 : Arduino UNO => Resistencia => LED 2 : Ánodo
# GND : Arduino UNO => LED 1 y 2: Cátodo


El programa usado para el Arduino es el que se muestra:
/* PROGRAMA DE PRUEBA DE COMUNICACION SERIAL
   CONEXION:
             Arduino (D11) : Catodo del led 1 
             Arduino (D10) : Catodo del led 2
             Arduino (GND): Anodo del led 1, 2
     
   El siguiente programa nos ayuda a enviar una trama ingresada por puerto serial para ser leida por el 
   Arduino y ser convertida en el valor del PWM de 0 a 100% (0 - 255 bits)

   Formato del dato: porcentaje_1,porcentaje_2 como XXX,YYY

   NOTA: Los pienes que poseen salida PWM son 3, 5, 6, 9, 10 y 11

   Autor: Renato Hurtado
   http://beetlecraft.blogspot.pe/
    
   El siguiente programa es de uso publico, cualquier modificacion o mal uso del mismo que pudiera 
   ocasionar el mal funcionamiento de la plataforma de uso de la misma no es responsabilidad del autor
*/

const int led_1 = 11, led_2 = 10; // Variable asignada al pin led 1 y 2
String data;                      // Variable asignada al dato obtenido

void setup() {
  pinMode(led_1, OUTPUT); // Configuracion del pin led 1 como salida
  pinMode(led_2, OUTPUT); // Configuracion del pin led 2 como salida
  Serial.begin(9600);     // Comunicacion serial a 9600 bps

  // Mensaje inicial
  Serial.println("Ingresar el dato como: porcentaje_1,porcentaje_2");
  Serial.println("Formato: XXX,YYY");
  Serial.println("Ejemplo: 10,100 (10% y 100%)");
}

void loop() {
  if(Serial.available() > 0){ // Lectura del puerto mientras sigue abierto
     data = Serial.readStringUntil('\n');                   // Lectura del dato hasta el line feed 
     Serial.print("Dato original: "); Serial.println(data); // Muestra del dato original
     
     int n, pwm_1, pwm_2; // Variables de almacenamiento de pwm y para algoritmo de lectura
     
     for (int i = 0; i <= data.length(); i++){ // Lectura total del tamano del dato
       if (data.substring(i, i+1) == ","){     // Lectura del dato hasta encontrar el caracter ","
         pwm_1 = data.substring(0, i).toInt(); // Conversion del dato obtenido del porcentaje del pwm 1
         n = i + 1;                            // Posicion de la letra final leida + 1
       }
     }

     // Lectura total del tamano del dato desde el ultimo punto
     for (int i = n; i <= data.length(); i++){ pwm_2 = data.substring(n, i).toInt(); }

     // Muestra del dato del porcentaje de PWM 1 y 2
     Serial.print("Procentaje 1: "); Serial.print(pwm_1); Serial.println(" %");
     Serial.print("Procentaje 2: "); Serial.print(pwm_2); Serial.println(" %");
     
     pwm_1 = map(pwm_1, 0, 100, 0, 255); // Cambio de formato del dato de 0 - 100%, a 0 - 255
     pwm_2 = map(pwm_2, 0, 100, 0, 255); // Cambio de formato del dato de 0 - 100%, a 0 - 255

     // Muestra del dato en pantalla
     Serial.print("PWM 1: "); Serial.println(pwm_1);
     Serial.print("PWM 2: "); Serial.println(pwm_2);
    
     analogWrite(led_1, pwm_1); // Salida PWM en el led de 0 a 255
     analogWrite(led_2, pwm_2); // Salida PWM en el led de 0 a 255
  }
}
El programa en Processing es el siguiente:
/* PROGRAMA DE PRUEBA DE COMUNICACION SERIAL
     
   El siguiente programa nos ayuda a enviar el valor pwm de 0 a 100% a un Arduino y
   recibimos en contraparte la confirmacion del valor del PWM de 0 a 255 y el porcentaje

   Autor: Renato Hurtado
   http://beetlecraft.blogspot.pe/
    
   El siguiente programa es de uso publico, cualquier modificacion o mal uso del mismo que pudiera 
   ocasionar el mal funcionamiento de la plataforma de uso de la misma no es responsabilidad del autor
*/

import controlP5.*; // Importacion de la libreria controlP5
ControlP5 cp5;      // Creacion del objeto cp5 para el ControlP5

String[] cabeceraCT = {"PWM 1", "PWM 2"}; // Cabecera del campo de texto
String pwm_1 = "0", pwm_2 = "0", data; // Dato de almacenamiento del cuadro de texto y envio
short LF = 10; // ASCII linefeed

import processing.serial.*; //Inicio de la comunicación serial
Serial puerto;              // Crea el puerto serial

void setup() {
  size(340, 200); // Porte de la pantalla ancho, alto

  String ArduinoPuerto = Serial.list()[0];        // Encuentra el primer puerto serial para iniciar la comunicacion
  puerto = new Serial(this, ArduinoPuerto, 9600); // Inicio de la comunicacion con el primer puerto encontrado
  
  PFont fuente = createFont( "arial", 15); // Tamano de la fuente y tipo
  
  cp5 = new ControlP5(this); // Inicializacion de la funcion cp5
  
  int y = 20, espaciamiento = 80; // Variables de almacenamiento de coordenada "y" y espaciamiento
  
  for(String nombre: cabeceraCT){
    cp5.addTextfield(nombre)   // Nombre del cuadro de texto
       .setPosition(20, y)     // Ubicacion del boton en la ubicacion x, y
       .setSize(200, 40)       // Tamano del boton ancho, alto
       .setFont(fuente)        // Fuente del texto
       .setAutoClear(false);   // No se limpia el campo de texto con "Enter"
    y += espaciamiento;        // Espaciamiento para el siguiente campo de texto       
  }
  
  y = 20; // reseteo de la ubicacion en y
  
  cp5.addBang("Enviar")     // Nombre del boton
     .setPosition(240, 100) // Ubicacion del boton en la ubicacion x, y
     .setSize(80, 40)       // Tamano del boton ancho, alto
     .setFont(fuente);      // Fuente del texto
}
 
void draw () {
  String mensaje = puerto.readStringUntil(LF); // Lee todo el mensaje hasta encontrar el linefeed
   
  if (mensaje != null) { // Si el dato no es null
    print(mensaje);      // Muestra en pantalla del mensaje original de Arduino
  }
  
  background(0); // Color de fondo
}
 
void Enviar() {
  // Lectura del valor obtenido del campo de texto
  pwm_1 = cp5.get(Textfield.class, "PWM 1").getText();
  pwm_2 = cp5.get(Textfield.class, "PWM 2").getText();
  
  // Mensaje de confirmacion de envio del PWM
  println("PWM 1 enviado: " + pwm_1); println("PWM 2 enviado: " + pwm_2);
  data = pwm_1 + ',' + pwm_2; // Armado de la data de envio
  puerto.write(data);         // Escritura del valor del PWM (envio de data al Arduino)
    
  // Borra el cuadro de texto despues de apretar el boton
  cp5.get(Textfield.class, "PWM 1").clear();
  cp5.get(Textfield.class, "PWM 2").clear(); 
}
Los resultados son los siguientes:



Autor: 

Tutorial - Comunicación serial (Octava parte - Envío de datos con botón)

Para el siguiente experimento, enviaremos un dato que varía entre 0 a 100 que corresponde de 0 a 100%, que es análogo de los 0 a 255 bits que maneja la salida PWM a través de la función "AnalogWrite()", y que se distingue en la intensidad de luz del led, siendo 0% un led apagado y 100% un led totalmente prendido.

Los únicos pines que pueden usar la función de salida PWM en el caso del Arduino UNO de manera nativa son:
# 11
# 10
# 9
# 6
# 5
# 3

Esta data mencionada, será enviada usando una GUI elaborada en Processing usando la librería ControlP5, el dato será ingresado en un campo de texto y el envío es por medio de un botón.

La conexión es la siguiente:
# PIN D11 : Arduino UNO => Resistencia => LED : Ánodo
# GND : Arduino UNO => LED : Cátodo


El programa en Arduino es el siguiente:
/* PROGRAMA DE PRUEBA DE COMUNICACION SERIAL
   CONEXION:
             Arduino (D11) : Anodo del led (pin positivo)
             Arduino (GND): Catodo del led (pin negativo)
     
   El siguiente programa nos ayuda a enviar una trama ingresada por puerto serial para ser leida por el Arduino y 
   ser convertida en el valor del PWM de 0 a 100% (0 - 255 bits)

   NOTA: Los pienes que poseen salida PWM son 3, 5, 6, 9, 10 y 11
     
   Autor: Renato Hurtado
   http://beetlecraft.blogspot.pe/
    
   El siguiente programa es de uso publico, cualquier modificacion o mal uso del mismo que pudiera ocasionar el mal 
   funcionamiento de la plataforma de uso de la misma no es responsabilidad del autor
*/

const int led = 11; // Variable asignada al pin led
int data;           // Variable de almacenamiento del dato por puerto serial

void setup() {
  pinMode(led, OUTPUT); // Configuracion del pin led como salida
  Serial.begin(9600);   // Comunicacion serial a 9600 bps
  Serial.println("Ingresar un valor de 0 a 100"); // Mensaje inicial 
}

void loop() {
  if(Serial.available() > 0){ // Lectura del puerto mientras sigue abierto
    data = Serial.parseInt();            // Extraccion del integer del dato leido
    int pwm = map(data, 0, 100, 0, 255); // Cambio de formato del dato de 0 - 100%, a 0 - 255

    // Muestra del dato en pantalla
    Serial.print("Porcentaje: "); Serial.print(data); Serial.println(" %");
    Serial.print("PWM: "); Serial.println(pwm);
    
    analogWrite(led, pwm); // Salida PWM en el led de 0 a 255
  }
}
El programa en Processing es el siguiente:
/* PROGRAMA DE PRUEBA DE COMUNICACION SERIAL
     
   El siguiente programa nos ayuda a enviar el valor pwm de 0 a 100% a un Arduino y
   recibimos en contraparte la confirmacion del valor del PWM de 0 a 255 y el porcentaje

   Autor: Renato Hurtado
   http://beetlecraft.blogspot.pe/
    
   El siguiente programa es de uso publico, cualquier modificacion o mal uso del mismo que pudiera 
   ocasionar el mal funcionamiento de la plataforma de uso de la misma no es responsabilidad del autor
*/

import controlP5.*; // Importacion de la libreria controlP5
ControlP5 cp5;      // Creacion del objeto cp5 para el ControlP5
 
String pwm; // Dato de almacenamiento del cuadro de texto
short LF = 10; // ASCII linefeed

import processing.serial.*; //Inicio de la comunicación serial
Serial puerto;              // Crea el puerto serial

void setup() {
  size(340, 100); // Porte de la pantalla ancho, alto

  String ArduinoPuerto = Serial.list()[0];        // Encuentra el primer puerto serial para iniciar la comunicacion
  puerto = new Serial(this, ArduinoPuerto, 9600); // Inicio de la comunicacion con el primer puerto encontrado
  
  PFont fuente = createFont( "arial", 15); // Tamano de la fuente y tipo
  
  cp5 = new ControlP5(this); // Inicializacion de la funcion cp5
  cp5.addTextfield("PWM de 0 a 100") // Nombre del cuadro de texto
     .setPosition(20, 20)    // Ubicacion del boton en la ubicacion x, y
     .setSize(200, 40)       // Tamano del boton ancho, alto
     .setFont(fuente)        // Fuente del texto
     .setAutoClear(false);   // No se limpia el campo de texto con "Enter"      
   
  cp5.addBang("Enviar")    // Nombre del boton
     .setPosition(240, 20) // Ubicacion del boton en la ubicacion x, y
     .setSize(80, 40)      // Tamano del boton ancho, alto
     .setFont(fuente);     // Fuente del texto
}
 
void draw () {
  String mensaje = puerto.readStringUntil(LF); // Lee todo el mensaje hasta encontrar el linefeed
   
  if (mensaje != null) { // Si el dato no es null
    print(mensaje); // Muestra en pantalla del mensaje original de Arduino
  }
  background(0); // Color de fondo
}
 
void Enviar() {
  // Lectura del valor obtenido del campo de texto
  pwm = cp5.get(Textfield.class, "PWM de 0 a 100").getText();
  
  println("PWM enviado: " + pwm); // Muestra del dato por monitor serial
  puerto.write(pwm); // Escritura del valor del PWM
  
  // Borra el cuadro de texto despues de apretar el boton
  cp5.get(Textfield.class, "PWM de 0 a 100").clear(); 
}
Los resultados son los siguientes:





Autor: 

Tutorial - Comunicación serial: Parte 7 (Envío de datos) / datos tipo float

En esta ocasión enviaremos un dato tipo float ingresado por el Monitor Serial de Arduino a la plataforma, para que esta nos reenvíe el dato con punto decimal sin pérdida de datos con un porte máximo de 20 caracteres.

El programa usado es el siguiente:
/* PROGRAMA DE PRUEBA DE COMUNICACION SERIAL
     
   El siguiente programa nos ayuda a enviar datos del tipo flotante a un Arduino y que se retorne el
   mismo dato enviado con un porte de hasta 20 caracteres

   Formato del dato: xxx.xxx

   Autor: Carolina G.
   http://beetlecraft.blogspot.pe/
    
   El siguiente programa es de uso publico, cualquier modificacion o mal uso del mismo que pudiera 
   ocasionar el mal funcionamiento de la plataforma de uso de la misma no es responsabilidad del autor
*/

void setup(){ Serial.begin(9600); }

void loop(){
  float dato; // Variable de almacenamiento de dato transformado
  
  // Mensaje en puerto serial
  Serial.print("Dato: ");
  dato = dato_salida();   // Lectura del dato arreglado
  Serial.println(dato);
}

float dato_salida(){       // Dato de salida
  float dato_flotante = 0; // Constructor de dato enviado 
  char vector[20];         // Variable de almacenamiento de dato leido por serial   
  int flag = 0;            // Flag de entrada de bucle while
  
  while (flag == 0){ // Bucle mientras el flag sea menor que 1
       
    if (Serial.available()) { // Lectura del puerto serial abierto
      delay(100);
      int i = 0; // Variable auxiliar de construccion de vector
      
      while (Serial.available() > 0){ // Lectura mientras tenga valores el buffer
        char inByte = Serial.read();  // Variable de almacenamiento de entrada de datos
        vector[i] = inByte;           // Vector de almacenamiento para construccion de dato
        i += 1;                       // i = i + 1
        flag = 1;               
      }
      
      dato_flotante = atof(vector);      // Conversion del vector de char a float
      memset(vector, 0, sizeof(vector)); // Limpia los datos ingresados al vector
    }
  } 
  
  return dato_flotante; // Retorna el valor arreglado 
}
El resultado es el siguiente:



Autor: 

Tutorial - Comunicación serial: Séptima parte (Envío de datos)

Para el siguiente experimento, enviaremos un dato que varía entre 0 a 100 que corresponde de 0 a 100%, que es análogo de los 0 a 255 bits que maneja la salida PWM a través de la función "AnalogWrite()", y que se distingue en la intensidad de luz del led, siendo 0% un led apagado y 100% un led totalmente prendido.

Los únicos pines que pueden usar la función de salida PWM en el caso del Arduino UNO de manera nativa son:
# 11
# 10
# 9
# 6
# 5
# 3

La conexión es la siguiente:
# PIN D11 : Arduino UNO => Resistencia => LED 1: Ánodo
# PIN D10 : Arduino UNO => Resistencia => LED 2: Ánodo
# GND : Arduino UNO => LED 1 y 2: Cátodo


El programa en Arduino es el siguiente:
/* PROGRAMA DE PRUEBA DE COMUNICACION SERIAL
   CONEXION:
             Arduino (D11) : Catodo del led 1 
             Arduino (D10) : Catodo del led 2
             Arduino (GND): Anodo del led 1, 2
     
   El siguiente programa nos ayuda a enviar una trama ingresada por puerto serial para ser leida por el 
   Arduino y ser convertida en el valor del PWM de 0 a 100% (0 - 255 bits)

   Formato del dato: porcentaje_1,porcentaje_2 como XXX,YYY

   NOTA: Los pienes que poseen salida PWM son 3, 5, 6, 9, 10 y 11

   Autor: Renato Hurtado
   http://beetlecraft.blogspot.pe/
    
   El siguiente programa es de uso publico, cualquier modificacion o mal uso del mismo que pudiera 
   ocasionar el mal funcionamiento de la plataforma de uso de la misma no es responsabilidad del autor
*/

const int led_1 = 11, led_2 = 10; // Variable asignada al pin led 1 y 2
String data;                      // Variable asignada al dato obtenido

void setup() {
  pinMode(led_1, OUTPUT); // Configuracion del pin led 1 como salida
  pinMode(led_2, OUTPUT); // Configuracion del pin led 2 como salida
  Serial.begin(9600);     // Comunicacion serial a 9600 bps

  // Mensaje inicial
  Serial.println("Ingresar el dato como: porcentaje_1,porcentaje_2");
  Serial.println("Formato: XXX,YYY");
  Serial.println("Ejemplo: 10,100 (10% y 100%)");
}

void loop() {
  if(Serial.available() > 0){ // Lectura del puerto mientras sigue abierto
     data = Serial.readStringUntil('\n');                   // Lectura del dato hasta el line feed 
     Serial.print("Dato original: "); Serial.println(data); // Muestra del dato original
     
     int n, pwm_1, pwm_2; // Variables de almacenamiento de pwm y para algoritmo de lectura
     
     for (int i = 0; i <= data.length(); i++){ // Lectura total del tamano del dato
       if (data.substring(i, i+1) == ","){     // Lectura del dato hasta encontrar el caracter ","
         pwm_1 = data.substring(0, i).toInt(); // Conversion del dato obtenido del porcentaje del pwm 1
         n = i + 1;                            // Posicion de la letra final leida + 1
       }
     }

     // Lectura total del tamano del dato desde el ultimo punto
     for (int i = n; i <= data.length(); i++){ pwm_2 = data.substring(n, i).toInt(); }

     // Muestra del dato del porcentaje de PWM 1 y 2
     Serial.print("Procentaje 1: "); Serial.print(pwm_1); Serial.println(" %");
     Serial.print("Procentaje 2: "); Serial.print(pwm_2); Serial.println(" %");
     
     pwm_1 = map(pwm_1, 0, 100, 0, 255); // Cambio de formato del dato de 0 - 100%, a 0 - 255
     pwm_2 = map(pwm_2, 0, 100, 0, 255); // Cambio de formato del dato de 0 - 100%, a 0 - 255

     // Muestra del dato en pantalla
     Serial.print("PWM 1: "); Serial.println(pwm_1);
     Serial.print("PWM 2: "); Serial.println(pwm_2);
    
     analogWrite(led_1, pwm_1); // Salida PWM en el led de 0 a 255
     analogWrite(led_2, pwm_2); // Salida PWM en el led de 0 a 255
  }
}
El programa en Processing que vamos a probar es un sketch en el cual creamos dos campos de texto con un nombre dado "PWM 1 y 2", y detectamos el momento en el que se da un "enter". El valor ingresado se verá en el visualizador serial que posee Processing en la parte inferior de la pantalla del IDE y se enviará al Arduino para ser convertido en la señal PWM.

El programa en Processing es el siguiente:
/* 
   PROGRAMA DE PRUEBA DE COMUNICACION SERIAL
   
   El siguiente programa nos ayuda a escribir un dato en un campo de texto correspondiente al PWM que
   va de 0 a 100 %, este va asignado al pin 11 y 10 del Arduino 
   
   Autor: Renato H.
   http://beetlecraft.blogspot.pe/
  
   El siguiente programa es de uso publico, cualquier modificacion o mal uso del mismo que pudiera 
   ocasionar el mal funcionamiento de la plataforma de uso de la misma no es responsabilidad del autor
*/

import controlP5.*; // Importacion del la libreria ControlP5
ControlP5 cp5;      // Creacion del objeto cp5

String[] cabeceraCT = {"PWM 1", "PWM 2"}; // Cabecera del campo de texto
String pwm_1 = "0", pwm_2 = "0", data; // Variable de almacenamiento del PWM
short LF = 10; // ASCII linefeed
int flag = 0;  // Flag discriminador

import processing.serial.*; //Inicio de la comunicación serial
Serial puerto;              // Crea el puerto serial

void setup() {
  size(200,200); // Tamano del canvas ancho, alto

  String ArduinoPuerto = Serial.list()[0];        // Encuentra el primer puerto serial para iniciar la comunicacion
  puerto = new Serial(this, ArduinoPuerto, 9600); // Inicio de la comunicacion con el primer puerto encontrado
  
  PFont fuente = createFont("arial",20); // Tamano de la fuente

  cp5 = new ControlP5(this); // Inicializacion de la funcion cp5

  int y = 20, espaciamiento = 80; // Variables de almacenamiento de coordenada "y" y espaciamiento
  
  for(String nombre: cabeceraCT){    // Orden de campo de texto y cabecera
    cp5.addTextfield(nombre)         // Crea un campo de texto 
       .setPosition(20,y)            // Ubicacion del texto en coordenadas x, y
       .setSize(100,40)              // Tamano del campo de texto ancho, alto
       .setFont(fuente)              // Fuente del texto           
       .setColor(color(255,255,255)) // Color de la fuente r, g, b
       ;
    y += espaciamiento; // Espaciamiento para el siguiente campo de texto
  }
  textFont(fuente);
}

void draw() { 
  String mensaje = puerto.readStringUntil(LF); // Lee todo el mensaje hasta encontrar el linefeed
   
  if (mensaje != null) { // Si el dato no es null
    print(mensaje);      // Muestra en pantalla del mensaje original de Arduino
  }
  
  background(0); // Rellena el espacio de trabajo de color negro
} 

void controlEvent(ControlEvent evento) { // Control de evento de entrada de texto
  if(evento.getController().getName().equals("PWM 1") && flag == 0) { // Revisa si se ha ingresado un texto y apretado "enter"
    
    // Muestra nombre de la cabecera del campo de texto y el texto escrito 
    println("Texto introducido: '" + evento.getName()+"': " + evento.getStringValue());
    
    // Lectura del valor del PWM ingresado y muestra de PWM por monitor serial
    pwm_1 = evento.getController().getStringValue(); 
    
    flag = 1; // Flag de inicio de la siguiente funcion
  }

  if(evento.getController().getName().equals("PWM 2") && flag == 1) { // Revisa si se ha ingresado un texto y apretado "enter"
    
    // Muestra nombre de la cabecera del campo de texto y el texto escrito 
    println("Texto introducido: '" + evento.getName()+"': " + evento.getStringValue());
    
    // Lectura del valor del PWM ingresado y muestra de PWM por monitor serial
    pwm_2 = evento.getController().getStringValue();
    
    // Mensaje de confirmacion de envio del PWM
    println("PWM 1 enviado: " + pwm_1); println("PWM 2 enviado: " + pwm_2);
    data = pwm_1 + ',' + pwm_2; // Armado de la data de envio
    puerto.write(data);         // Escritura del valor del PWM (envio de data al Arduino)
    
    flag = 0; // Flag de inicio de la siguiente funcion
  }   
}
El resultado es el siguiente:




Autor: