Hola buenos dias, en primer lugar nos deberias de explicar como recibes los datos en el

arduino me explico si lo estas recibiendo como char como byte como int, etc..
Ahora un ejemplo a modolo de algoritmo es el siguiente:
1. recibes el primer char 1 como ya tu cifra es definica en 3 caracteres tienes que tener ya
calara tu ecuacion. Ese primer car lo debes de llevar a int de la manera siguiente; valor
recibido menos '0'. eso te dara 1 entero 31-30=1.
2. como tu cantidad de caracteres es 3 el primer caracter lo deves de multiplicar por 100.
3 recibes el segundo caracter en tu caso 2 igual lo llevas a entero restando '0' y obtienes 2
entero.
4 como es el segunto caracter lo multiplicas por 10.
5 recibes el tercer y ultimo caracter en tu caso 5 igual lo llevas a entero restando '0' y te
quedara un entero 5 y esta por ser la ultima cifra no debes de multiplicarla por nada.

La ecuacion final quedaria de4 la guiente manera= c1*100+c2*10+c3; donde c1=1, c2=2 y
c3=5
ct=125 ya en entero.

Saludos y espero haverte ayudado haaa otra manera mas logica seria declarar un arreglo
char.
ejemplo:
char valor recibido[2]=0;

luego de eso vas recibiento tus valkores y con un condator vas incrementando el valor
recibido de esa manera cuando ya tengas los 3 valores solo restara pasar el valor recibido a
entero porque tya de manera automatica esta concatenado.
Si no vas a utilizar un caracter de control para saber donde acaba y termina un caracter es
posible que el pic tenga un error de lectura del puerto serie y se coma una cifra por lo que
todas las demas cifras estarán mal. si utilizas el caracter de control solo te fallará 1 cifra y las
demás las volverá a interpretar bien.

El problema de como lo hace astrocar es que el código vale siempre para valores de 3 cifras
en cuanto mandes de 1 o 2 cifras ya te lo interpreta mal.

otra forma de hacerlo es por lineas, si mandas los valores de los motores en lineas y al final
hay un return ( char==13) entonces hay otra forma. al ser las posiciones de los valores fijos
puedes calcularel valor del strng y pasarlo a int.

Tengo el codigo hecho en funciones además para esta ultima forma, mas que lo tengo en otro
ordenador, en cuanto vuelva de vacas lo subo al playground o al foro.

te recomiendo la primer forma que te digo, con el caracter de control despues de enviar un
valor.

Y si envias por puerto serie el 243, primero el 3 luego el 4 y luego el 2 y como ase acaba el
numero envias otro caracter de control por ejemplo el $.
if (caracter esta entre "0" y "9" incluidos)
{
valorcalculado=valorcalculado+(caracter-"0")*multiplicador;
multiplicador=multiplicador*10;
}
de esta forma en una primera vuelta numero =0, recivimos el 3 , valor calculado =3 pero no
lo pasa a numero pues no le ha llegado $
a la segunda vuelta recivimos un 4, lo multiplicamos por 10 y lo sumamos a lo que habia

read(). el qual representa el carácter ASCII del valor "81" 8 } Recibir datos del PC Ahora vamos a invertir el proceso. quiere decir. podemos hacerlo con el programa anterior o también con este: 1 void setup() 2 { 3 Serial. Enviar el valor 81 en formato decimal.begin(9600). El programa básico para recibir datos es el siguiente: 1 void setup() 2 { 3 Serial.begin(9600). //Lee cada carácter uno por uno y se almacena en 10 una variable 11 12 Serial.write(81). //Imprimimos en la consola el carácter recibido } 13 } 14 Y aquí se complica un poco la cosa. //Imprime "Q". //Imprime "81" 8 } Y para enviar el valor 81 como un byte se tiene que usar la función write() 1 void setup() 2 { 3 Serial.begin(9600). 43 + 2 *100 =243 luego recive un $.DEC). los caracteres recibidos serán números correspondientes al código ASCII (El Arduino ve Símbolos de del tabla ASCII y los traduce a Decimal). 4 } 5 6 void loop() { 7 Serial.println(dato).antes 3 + 4*10 =43 a la tercera vuelta recivimos un 2 se multiplicara por 100 y se suma a lo que habia antes. vamos a enviar datos del PC al Arduino. el buffer del puerto serie recibe los datos byte por byte y en formato decimal. esto hara que numero sea = a valor calculado y que se reseteen los valores de valor calculado y el multiplicador.available()>0) //Comprobamos si en el buffer hay datos 8 { 9 int dato=Serial. 4 } 5 6 void loop() { 7 if(Serial. ¿Por qué? Pues porqué como hemos explicado antes.println(81. . 4 } 5 6 void loop() { 7 Serial.

¿Cómo lo podemos hacer? Ya que cuando el Arduino reciba el valor 51. 4 } 5 6 void loop() { 7 if(Serial. después la “R”. y este queremos que a este valor 51 le sumemos un valor 2 para que nos salga un valor 53. primero la “A”. Por ejemplo: si queremos enviar el valor 51 desde el PC al Arduino. Otra forma similar de hacerlo sin cambiar el println() es en vez de usar el tipo de variable int para leer los datos del buffer. Creamos un array tipo char para que almacene los datos en forma de cadena de caracteres (String). hasta la “O”.available()>0) //Comprobamos si en el buffer hay datos 8 { 9 char dato=Serial.Por ejemplo: Enviamos desde el PC la palabra “ARDUINO”.read().read(). y los captura como carácter decimal correspondiente a la tabla del código ASCII. Así visualizamos los mismos caracteres que hemos escrito inicialmente en el PC.println(dato). Quiere decir que el Arduino ve los siguientes valores: 65 82 68 85 73 78 79 Que corresponden a A R D U I N 0 Para solucionar esto podemos usar la función write() en vez de println(). //Lee cada carácter uno por uno y se almacena en 10 una variable 11 12 Serial.begin(9600). El buffer lee uno por uno los caracteres recibidos. lo va a interpretar como un 53(5) y 49(1).begin(9600). //Imprimimos en la consola el carácter recibido } 13 } 14 Lo que hace la función write() con los valores recibidos (65 82 68 85 73 78 79) es enviarlos al Monitor Serial con su carácter correspondiente de la tabla del código ASCII.…. De esta manera. Porque write() envía uno o varios bytes en forma de datos binarios. Lo que haremos es convertir esta cadena de caracteres a un número entero usando la función atoi(). en el Monitor Serial imprimirá “ARDUINO”. 4 } 5 6 void loop() { 7 if(Serial. //Lee cada carácter uno por uno y se almacena 10 en una variable 11 12 Serial. Usaremos un código muy sencillo.write(dato). cuando enviamos desde el PC la palabra “ARDUINO”. que no es una función . usaremos el tipo de variable char que es un tipo de dato que ocupa un byte de memoria y almacena un valor de carácter (almacena el símbolo de la tabla ASCII). 1 void setup() 2 { 3 Serial. 1 void setup() 2 { 3 Serial.available()>0) //Comprobamos si en el buffer hay datos 8 { 9 int dato=Serial. //Imprimimos en la consola el carácter recibido } 13 } 14 Pero y si queremos usar datos recibidos dentro del programa.

//Lee un carácter del string "cadena" 19 de la "posicion". //Poner un pequeño delay para mejorar la recepción de datos cadena[posicion]=Serial.println(valor+2).de Arduino sino de C++.//Imprimimos el valor sumandole un valor +2 posicion=0. luego lee el siguiente carácter con "posicion++" 20 posicion++. También usaremos la función memset() (también procedente de C++) para limpiar el array después de cada lectura. Le asignamos un tope de caracteres.available()) //Nos dice si hay datos dentro del buffer 13 { memset(cadena.//memset borra el contenido del array 14 "cadena" desde la posición 0 hasta el final sizeof 15 16 while(Serial.read(). 21 } 22 23 valor=atoi(cadena). //Variable para cambiar la posición de los caracteres del array 8 int valor. //Creamos un array que almacenará los caracteres que escribiremos 7 en la consola del PC.begin(9600). 1 void setup() 2 { 3 Serial.//Convertimos la cadena de caracteres en enteros 24 Serial. en este caso 30 byte posicion=0.//Ponemos la posicion a 0 25 } 26 27 } 28 .sizeof(cadena)). 0. 4 } 5 6 char cadena[30]. //Variable del valor entero 9 10 void loop() 11 { 12 if(Serial. pero que está incluido automáticamente en todos los sketches.available()>0) //Mientras haya datos en el buffer ejecuta la función 17 { 18 delay(5).

4 El while (1) hará que el Arduino espere hasta que el carácter 'n' sea recibido. 3 if (incomingByte == '\n') break.48) + integerValue).available (). } 19 Serial. and shift left 1 decimal place 18 integerValue = ((incomingByte ... 7 8 void loop() { 9 if (Serial. we're done receiving 13 14 if (incomingByte == -1) continue. . // shift left 1 decimal place 17 // convert ASCII to integer. // if no characters are in the buffer read() returns -1 15 16 integerValue *= 10.read () devolverá -1 si no hay caracteres disponibles. Arduino: Envío y recepción de enteros multidígitos 1 2 void setup() { 3 Serial. 4 } 5 6 unsigned int integerValue=0. El segundo es el hecho importante de que Serial. // exit the while(1).read(). Esto evita que el programa tenga que comprobar constantemente Serial. pero vamos a desglosarlas.println(integerValue). add. // throw away previous integerValue while(1) { // force into a loop until 'n' is received 11 incomingByte = Serial. // Do something with the value 20 21 Why does this work? Aquí hay 4 líneas de código que hacen que esto funcione. // Max value is 65535 char incomingByte.available() > 0) { // something came across serial 10 integerValue = 0. establecido por el Monitor Serial. Las matemáticas pueden ser divertidas y pueden hacer que el siguiente par de líneas parezcan mágicas. 12 if (incomingByte == '\n') break. El primer bloque son: 1 while(1) { 2 //.begin(9600). if (incomingByte == -1) continue. Esto es "Newline".

Genial. se añaden al final de la lista (datos más recientes).  El búfer tiene una longitud finita (se establece).1 integerValue *= 10. Buffer: Si no entiende cómo funciona un búfer. Si no es inteligente acerca de ello.255). 2 integerValue = ((incomingByte . Piense en un búfer como una lista.. y todas las entradas se mueven hacia arriba. En su computadora estos datos se almacenan en algo llamado un búfer. ¿qué sucede cuando el sensor intenta enviar nuevos datos al buffer? Los datos más antiguos (arriba de la lista) se descartan para siempre. hasta que usted decida leerlo. el valor de integerValue se desplaza a la izquierda y se agrega el nuevo dígito. comienza en la parte superior de la lista (datos más antiguos). Una vez que el buffer está totalmente lleno.  A medida que vienen los nuevos valores de datos. Supongamos que un sensor transmite datos a su programa con más frecuencia que su programa lo lee. todos los dígitos cambian a la izquierda una vez. la variable 'incomingByte' tiene un valor ASCII en ella. restando 48 de la incomingByte.) Por lo tanto. El terminador puede ser cualquier cosa que envié o reciba de acuerdo un "retorno de carro" (\ r) es una opción común. [Nota: Esta es la razón por la que está limitado a "65535". Inicialmente está vacío: El sensor le escribe un valor (10) El sensor le escribe otro valor (6). Este es el valor máximo que puede tener un int sin signo.] Conceptos básicos Serial Message: Usted envía o recibe datos literalmente a través de este cable en un solo pin como una serie de bytes (1 byte = 8 bits o 0 . Y los datos en la segunda posición de la lista se mueven hasta la posición superior. es fácil perder datos o utilizar datos antiguos. (Ver este gráfico ASCII para más información. ¿eh? ¿Por qué la resta? Porque . . obtenemos el valor entero de ese carácter ASCII.48) + integerValue) Cuando un número decimal (base 10) se multiplica por 10. Ejemplo: [0] [12] [27] [42] [112] Terminators: Para indicar el final de una serie de bytes que constituyen un mensaje. Así que cada vez que se ingresa un dígito. para dejar espacio en la parte inferior de la lista de datos nuevos. Una vez que lea un byte de datos. Esto significa que hay un límite a cuánto tiempo puede llegar la lista. ya no está en el búfer.. etc. Tenga en cuenta que los datos más antiguos están en la primera posición y los nuevos datos llenan el buffer desde la parte inferior.  Si usted es inteligente sobre el uso del búfer.  Si su programa lee un valor del búfer. Creamos un buffer de longitud 5. nunca entenderá la serie comunicación. puede asegurarse de que nunca se pierda ningún dato. El carácter "0" tiene un valor ASCII de 48.

251]). X = 10. en la entrada superior. Tenga en cuenta que aunque lo que envíe sea binario. 117. Ahora tiene que averiguar dos cosas de la Interfaz de Comando Serial (SCI) que viene con su dispositivo: 1. Escritura de comandos ASCI . Aquí hay otro escenario. la documentación podría enumerarlo como números entre 0 y 255 o números hexadecimales. Tenga en cuenta que una vez que leemos el valor ya no está en el búfer! También tenga en cuenta que leemos el elemento superior que fue el más antiguo de los datos. 12. Escritura en el puerto serie Antes de poder escribir en su puerto serie. para dejar espacio para el nuevo valor (4). es probablemente la primera opción. ¿Se enviarán datos binarios (bytes) o texto (ascii)? 2. (10) se descartan para siempre y todas las entradas cambian 1 punto. debe abrirlo: Fopen (serGPS). [0. ¿Qué le enviarán? Si sus mensajes SCIs parecen una lista de números (ej: [4] [253] [1] [1])). El buffer está lleno: Ahora el sensor le escribe un valor (4) Los datos más antiguos.Ahora leemos un valor de ella en la variable X. Escribir datos binarios Utilice el comando fwrite para enviar cuatro bytes de datos binarios fwrite (serGPS.

'MOVE %d. % Sólo algunos datos de ejemplo fprintf(serGPS. int val. %-. } } . pen(SerPIC). '%d'. 98) No se envía como un número. PAUSE %d'. '%s'. data). done = false.003 = 00000011 in binary.available()){ ch = Serial. so first two LEDs of PIC will light. /* */ else /* Not a digit */ done = true. '003'). bool done. data=15. %--open the serial port to the PIC fprintf(SerPIC.0x30. pauseTime = 2.read(). fprintf(SerPIC. (ex. while(!done){ if(Serial.Enviar una cadena de tres dígitos al PIC sin terminador ('%s') %-. [moveNum.moveNum = 98. pauseTime] ) . % note Es importante entender que un número. int ch. val = 0. Es en realidad el código asci para los caracteres '9' y '8'. /* Read a character */ if((ch >= 0x30) && (ch <= 0x39)) /* Digit */ val = val * 10 + ch .