El hilo de ARDUINO: Dudas, código, ejemplos, etc

[MiguelX5]

Cierto que todo es cuestión de tiempo, pero en arduino estás poniendo cosas en producción en una semana, mientras que con la rasp hay que pensar en meses , jeje

salu2

Si te interesa algo de lo que pongo te puedo pasar el enlace a los tutos, la mayoría con copia-pega los terminas en una tarde.

Lo mejor es mezclar ambos entornos.

Salu2!

 

[MiguelX5]

Alguno controláis de Blynk y sus pins virtuales?

Tengo un problema de código ya que al parecer dentro de los while no se pueden leer pines virtuales lo que implica que la condición nunca termina.

Muchas gracias.

Un saludo

 

[McClane]

Casi lo tengo!! Me falta un pequeño ajuste que logro dar con ello.

Me he puesto a darme cabezazos delante del ordenador con el ARDUINO y he pensado en hacerme un semáforo con algunos LED que tengo por aquí, pero no un semáforo de solo coches con el rojo, verde y amarillo, sino también con el de peatones Sin embargo, me ha sabido a poco porque no es más que una extensión del programa del LED integrado (digitalWrite y delay nada más), por lo que me he complicado metiendo... el botón de peatones.

El funcionamiento del botón de los semáforos es el siguiente. Cuando pulsas el botón, inmediatamente pasa a amarillo y luego a rojo. Sin embargo, si acaba de ponerse en verde, al pulsar el botón no cambiará a amarillo, ya que tiene que pasar un tiempo. Lo tengo casi todo. Cuando reseteo la placa y le pulso al botón, éste hace el funcionamiento correcto. Si soy un ansias, hasta que no pasan los diez segundos que le he puesto, no cambiará a amarillo. Si pasan cinco segundos y le pulso, hasta dentro de cinco segundos no pasa a amarillo. Una vez que pasa a amarillo, hace todo el programa correcto, volviendo al verde, pero es aquí donde viene el problema: la segunda vez ya no respeta los 10s de tiempo y cambia a amarillo inmediatamente.

Creo tener el problema pero no tengo la solución. El comando millis() cuenta milisegundos desde que se inicia la placa, y no desde que se le llama, por lo que en el siguiente ciclo, pasa directamente a amarillo porque ya tiene el tiempo acumulado desde que arranca, pero no encuentro un comando para resetear el tiempo y las pruebas que he hecho no han funcionado. He probado a restar el tiempo a sí mismo, pero creo que luego vuelve a tomar su valor. He creado también una variable secundaria para guardar el tiempo y restarlo pero no hay manera: solo funciona bien la primera vez.

A ver si damos con ello, y así habré sacado adelante el proyecto más ambicioso de ARDUINO: un p*to semáforo.

int coche_verde(11);
int coche_rojo(12);
int coche_ambar(13);
int peaton_verde(7);
int peaton_rojo(6);
int pulsador(2);
unsigned int boton; //variable de número de pulsaciones
unsigned int tiempo2; //variable secundaria de tiempo

void setup()
{
pinMode(peaton_rojo, OUTPUT);
pinMode(peaton_verde, OUTPUT);
pinMode(coche_verde, OUTPUT);
pinMode(coche_rojo, OUTPUT);
pinMode(coche_ambar, OUTPUT);
pinMode(pulsador, INPUT_PULLUP);
Serial.begin(9600); //únicamente utilizado como diagnóstico, no sirve para nada

}

void loop()

//Inicio, cuenta tiempo y prepara el semáforo para estar en verde

{
 
  empezar:
  unsigned long tiempo=millis();
  digitalWrite(peaton_rojo, HIGH);
  digitalWrite(coche_rojo, LOW);
  digitalWrite(coche_verde, HIGH);

//Botón
 
  tiempo-tiempo2;
  if (tiempo<10000) {
    goto empezar;
    
    }else{
      boton = digitalRead(pulsador);
    
      if (boton == HIGH){
      boton++;
    
      }else{
        goto empezar;
        }
    
        if (boton=0){
        goto empezar;
        } 
  }

//Cambio a rojo

  continuar:
  Serial.println(boton); //únicamente utilizado como diagnóstico, no vale
  digitalWrite(coche_verde, LOW);
  digitalWrite(coche_ambar, HIGH);
  delay(2000);
  digitalWrite(coche_ambar, LOW);
  digitalWrite(coche_rojo, HIGH);

//Peatones

  digitalWrite(peaton_rojo, LOW);
  digitalWrite(peaton_verde, HIGH);
  delay(6000);
  digitalWrite(peaton_verde, LOW);
  delay(500);
  digitalWrite(peaton_verde, HIGH);
  delay(500);
  digitalWrite(peaton_verde, LOW);
  delay(500);
  digitalWrite(peaton_verde, HIGH);
  delay(500);
  digitalWrite(peaton_verde, LOW);
  digitalWrite(peaton_rojo, HIGH);
  delay(2000);
  tiempo2=tiempo; //guarda el tiempo actual en la segunda variable
  boton=0; //almacena cero pulsaciones en el botón
 

}

Estoy seguro de que es una chorrada, pero solamente si se pudiese resetear el comando millis() sería lo único que me faltaría. ¿Me echáis una mano?

 

[katraska]

Cosas que veo @McClane

etiquetas y goto's, en C están prohibidos. Se pueden evitar con while, for, if, etc. Complican mucho la lectura del código y puedes tener resultados poco predecibles

El primer bucle lo resuelves con:

while (tiempo-tiempo2 < 1000){
<lo que sea>
}

Además, en ese bucle estás asignando el mismo valor a las salidas digitales miles de veces.... y declarando también miles de veces la variable tiempo.

Usas la variable tiempo2 sin haberla inicializado. Es decir, al comenzar el programa no sabes qué valor tiene. Sólo has reservado un espacio en memoria, pero igual no está a cero (suele estarlo al reiniciar, pero nunca se sabe).

Nada mas empezar haces: tiempo - tiempo2, que no entiendo como te deja el compilador, porque no hace nada. No se si quieres decir tiempo = tiempo - tiempo2 o qué.

A continuación preguntas si tiempo<10000. como acabas de iniciar el arduino, el contador millis() empieza de cero, así que la primera vez se tira 10 segundos en ese bucle, hasta que millis pasa de 10000.

luego, si no pulsas nada, se mete en ese código, donde hay un montón de delays encadenados. Entiendo que tras los primeros 10 segundos es lo que buscas (cambiar a rojo) .Por tanto el arduino está metido en un montón de delays y cada 12 segundos pasa fugazmente por el control del botón pulsado (ya es casualidad que lo pille en estado bajo, que entiendo es lo que te ofrece cuando pulsas). Es decir, durante todo este tiempo, aunque pulses, pasa de ti porque el arduino no está mirando la entrada del botón. Para solventar esto, como te contaba en un post previo, tienes que utilizar interrupciones.... y no utilizar delay: deberías hacerte una función equivalente, que te retarde la ejecución del código, usando el valor millis. Alternativamente, podrías no utilizar interrupciones, pero verificar la pulsación dentro de la función de los retardos... las alternativas son infinitas.

El bloque que pone:

if (boton=0){
goto empezar;
}

creo que no se ejecuta nunca, pulses o no pulses. No alcanzo a ver para qué lo usas.

Tampoco parece adecuado que a una variable tipo int le asignes un valor HIGH. No es que no se pueda porque HIGH es 1, pero lleva un poco al huerto cuando lees el código.

Como primera medida, intenta eliminar todas las etiquetas y goto. Te obligará a pensar el código de modo más lógico y serás capaz de ver por dónde pasa. Inicializa el valor tiempo2.

te recomiendo que antes de meterte a escribir código organices las ideas tratando de hacer un esquema (tipo diagrama de flujo) donde vayas escribiendo acciones atómicas sencillas y luego con flechas vas organizando dónde debe ir el código en caso de condiciones.

Te diría dónde tocar, pero me temo que no es cosa de tocar una variable o una línea. Si quieres te hago algo, pero te lo tendría que dar la vuelta (lo siento )


salu2

 

[McClane]

Aupa!! No te contesto no porque pase del tema, es que ahora no puedo sacar ni una hora para dedicarte.

@katraska

 

[katraska]

Aupa!! No te contesto no porque pase del tema, es que ahora no puedo sacar ni una hora para dedicarte.

@katraska

No hay problema, cuando lo retomes seguimos ;-)

salu2

 

[McClane]

No hay problema, cuando lo retomes seguimos ;-)

salu2

A ver si ahora.

Cuando programo o intento programar tengo detrás la página de ARDUINO ton todas las instrucciones disponibles, así voy viendo instrucciones que me pueden valer y así intentar echarlas a andar. La instrucción goto sí está contemplada y las etiquetas también, de ahí que las use, ya que no tengo ni puñetera idea ni de C, ni de C+ ni de C++.

Todo lo que veas de tiempo y tiempo2 y demás, son intentos frustrados de intentar restar el tiempo antiguo al nuevo con la esperanza de que se resetee, pero como puedes comprobar, no resetea, así que ahora mismo no lo tengas muy en cuenta.

En cuanto al millis(), el tiempo de 10000ms y el botón, si funciona. Cuando meto tensión al ARDUINO, éste ejecuta el millis, se pone a contar y empieza con la luz verde para coches y la luz roja para peatones. Si pasan esos diez segundos, el semáforo sigue en verde siempre hasta que pulse el botón. Cuando pulso el botón, inmediatamente hace el ciclo del ámbar y rojo para volver a empezar. Si no llega a los diez segundos y yo ya he pulsado el botón, cuando el contador llegue a 10 segundos, el semáforo hace la función. Para ponerlo más claro. Al meter tensión al ARDUINO:

-Si no pulso el botón, SIEMPRE se queda en verde
-Si pulso el botón después de los 10s, cambia inmediatamente a ámbar
-Si pulso el botón antes de los 10s, hasta que no llegue al tiempo estipulado, no cambia a ámbar

Con esto comprobamos que el código en sí, funciona, y que el contador de pulsaciones también lo hace. Que la programación no sea la óptima, te lo compro, bastante que casi consigo hacer el p*to semáforo. Tendré que empezar a cagarla por algún lado. En cuanto a los delays, pues no he encontrado otro código viable con mis conocimientos, que no llegan ni al 1%. De momento, con que me funcione perfecto aunque no esté perfectamente programado, me doy por satisfecho. Iré poniéndome poco a poco retos de estos porque sí, ves que se pueden hacer mil cosas pero te pones a programar tu idea y de esas mil cosas, te salen mil dudas. Lo siguiente que haga seguramente sea un control de temperatura de frío o calor, o ambos, que si baja de temperatura active una salida y si sube de una temperatura, active otra salida. Pero antes quiero que el semáforo funcione.

Si está casi entero, pero me falta que respete esos 10s siempre.

Muchas gracias por la ayuda. Volveré a leerme tu respuesta y cuando tenga un rato y no haga tanto calor me pongo con ello.

 

[SPTR]

Cómo te va el bacalao mclein!!

 

[katraska]

Mira @McClane, un ejemplo de gestión de dos teclas por interrupciones.

Cuando se pulsa una de las teclas se ejecuta la rutina de interrupción (botón_up o botón_down), que lo único que hacen es poner a true una variable global.
En el búcle loop se está mirando continuamente el valor de esas variables, y si de repente están a true es que ha saltado la rutina de interrupción. Haces lo que sea y luego vuelves a poner a false la variable global, para la próxima. Aprovecho a meter un timer para evitar que los rebotes de las teclas hagan que se detecte como varias pulsaciones.

#define PIN_UP 3            // pin de entrada de tecla UP
#define PIN_DOWN 2          // pin de entrada de tecla DOWN
#define TIMER_SWITCH 150    // temporizador para evitar rebotes de teclas

boolean up, down;

//-------------------------------------------------------------------------
void setup() {
  Serial.begin(115200);
  pinMode(PIN_UP, INPUT_PULLUP);
  pinMode(PIN_DOWN, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(PIN_UP), boton_up , RISING);
  attachInterrupt(digitalPinToInterrupt(PIN_DOWN), boton_down, RISING);
  delay(300);       // -- para evitar que salten las interrupciones al comienzo
  up = false;
  down = false;
}

//--------------------------------------------------------------------------
void loop() {
  if (up){
     Serial.println("UP");
     delay(TIMER_SWITCH);
     up = false;
    }

   if (down){
      Serial.println("DOWN");
      delay(TIMER_SWITCH);
      down = false; 
   }
}

// -----------------------------------------------------------------------
//    manejo de interrupción de boton UP pulsado
// -----------------------------------------------------------------------
void boton_up(){
  up = true;
  }


// -----------------------------------------------------------------------
//    manejo de interrupción de boton DOWN pulsado
// -----------------------------------------------------------------------
 void boton_down(){
  down = true;
  }

 

[McClane]

Mira @McClane, un ejemplo de gestión de dos teclas por interrupciones.

Cuando se pulsa una de las teclas se ejecuta la rutina de interrupción (botón_up o botón_down), que lo único que hacen es poner a true una variable global.
En el búcle loop se está mirando continuamente el valor de esas variables, y si de repente están a true es que ha saltado la rutina de interrupción. Haces lo que sea y luego vuelves a poner a false la variable global, para la próxima. Aprovecho a meter un timer para evitar que los rebotes de las teclas hagan que se detecte como varias pulsaciones.

#define PIN_UP 3            // pin de entrada de tecla UP
#define PIN_DOWN 2          // pin de entrada de tecla DOWN
#define TIMER_SWITCH 150    // temporizador para evitar rebotes de teclas

boolean up, down;

//-------------------------------------------------------------------------
void setup() {
  Serial.begin(115200);
  pinMode(PIN_UP, INPUT_PULLUP);
  pinMode(PIN_DOWN, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(PIN_UP), boton_up , RISING);
  attachInterrupt(digitalPinToInterrupt(PIN_DOWN), boton_down, RISING);
  delay(300);       // -- para evitar que salten las interrupciones al comienzo
  up = false;
  down = false;
}

//--------------------------------------------------------------------------
void loop() {
  if (up){
     Serial.println("UP");
     delay(TIMER_SWITCH);
     up = false;
    }

   if (down){
      Serial.println("DOWN");
      delay(TIMER_SWITCH);
      down = false;
   }
}

// -----------------------------------------------------------------------
//    manejo de interrupción de boton UP pulsado
// -----------------------------------------------------------------------
void boton_up(){
  up = true;
  }


// -----------------------------------------------------------------------
//    manejo de interrupción de boton DOWN pulsado
// -----------------------------------------------------------------------
 void boton_down(){
  down = true;
  }

Dejé Arduino durante una temporada. Un juego en concreto me quitaba tiempo y el calor del verano sudando a chorros no era lo mejor para aprender a programar la placa y menos aún con los "sofocos" de "yo he programado esto bien y no sé porqué me dice que está mal".

Ahora que ha venido el "frío" (o más bien se ha ido el calorazo) le he dado otra oportunidad pero esta vez he intentado hacer algo más básico, es decir, retroceder un paso para avanzar (o intentar) dos pasos, por lo que me he hecho un "voltímetro" a costa de tres LEDs, precisión máxima.

En un primer momento empleé un proyecto de ejemplo que viene con el propio Arduino y lo intenté mejorar. El proyecto en sí es una lectura constante del pin A0 para que el conversor lo transforme a digital y me ofrezca un voltaje enviando dicho valor por puerto serie. El programilla es el "ReadAnalogVoltaje", así que esa es su base. No obstante, me lié la manta a la cabeza y decidí complicarme con los correspondientes cabezazos contra la pantalla.

La idea era crear dos variables, una para que encendiese el pin 13 cuando haya menos de 2,5v y otra que encienda el pin 12 cuando haya 2,5v o más. Hacer esto con dos LED no fue difícil, sinceramente (gracias, manual de Arduino ), pero el reto vino incorporando un tercer LED para mostrar un valor intermedio. Aquí vino el comecocos. Mi idea era hacer unas variables con lo siguiente:

• Si hay 4,5v o más, pones en HIGH el led 1
• Si hay 3v o más, pones en HIGH el led 2
• Si hay 4,5v o menos, pones en HIGH el led 2
• Si hay 3v o menos, pones en HIGH el led 3

Como todo iniciado, crees que tienes razón, programas eso y resulta que cuando hay más de 4,5v, se enciende el led 2 y 3, así que no me valía y cambié el orden de las variables sin cambiarlas. El resultado era el mismo pero con tensión baja, es decir, que a 0v, se encendían el led 2 y además el 3. Volvía a modificar las cosas y pasaba lo contrario, y no había coj*nes a apagar el led 2 cuando se salía de escala. Un simple "&" entre ambas instrucciones lo arreglaba todo, y lo mejor de todo fue que usé esa solución como "pff, no creo que tire..." y resulta que funcionó. Sí, podemos decir que este es el primer programilla que hago para Arduino y que funciona sin problemas.

int led1;
int led2;
int led3;

void setup() {
  Serial.begin(9600);
  pinMode(8, OUTPUT);
  pinMode(12, OUTPUT);
  pinMode(13, OUTPUT);
}

void loop() {
 
  int valor = analogRead(A0);
  float voltaje = valor * (5.0 / 1023.0);
  Serial.println(voltaje);
  led1 = (voltaje >= 4.5 == HIGH);
  led2 = (voltaje >= 3 & voltaje < 4.5 == HIGH);
  led3 = (voltaje < 3 == HIGH);
  digitalWrite(8, led1);
  digitalWrite(12, led2);
  digitalWrite(13, led3);
  delay(100); //para no sobrecargar el puerto serie
 
}

Hice antes de éste otro programa muy sencillo pero que también tiene su miga, y es encender el pin 13 cuando se pulsa un pulsador asociado a una entrada digital. Sin pulsar, se encendía, y pulsando, se apagaba, lo lógico, vamos. Finalmente una admiración antes de la variable ("!variable") lo solucionaba todo.

Poco a poco iré descubriendo más cosillas y pensando en más formas de complicarme con algo... y hacer que funcione. El botón del semáforo lo tengo pendiente aún.

 

[McClane]

Mira @McClane, un ejemplo de gestión de dos teclas por interrupciones.

Cuando se pulsa una de las teclas se ejecuta la rutina de interrupción (botón_up o botón_down), que lo único que hacen es poner a true una variable global.
En el búcle loop se está mirando continuamente el valor de esas variables, y si de repente están a true es que ha saltado la rutina de interrupción. Haces lo que sea y luego vuelves a poner a false la variable global, para la próxima. Aprovecho a meter un timer para evitar que los rebotes de las teclas hagan que se detecte como varias pulsaciones.

#define PIN_UP 3            // pin de entrada de tecla UP
#define PIN_DOWN 2          // pin de entrada de tecla DOWN
#define TIMER_SWITCH 150    // temporizador para evitar rebotes de teclas

boolean up, down;

//-------------------------------------------------------------------------
void setup() {
  Serial.begin(115200);
  pinMode(PIN_UP, INPUT_PULLUP);
  pinMode(PIN_DOWN, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(PIN_UP), boton_up , RISING);
  attachInterrupt(digitalPinToInterrupt(PIN_DOWN), boton_down, RISING);
  delay(300);       // -- para evitar que salten las interrupciones al comienzo
  up = false;
  down = false;
}

//--------------------------------------------------------------------------
void loop() {
  if (up){
     Serial.println("UP");
     delay(TIMER_SWITCH);
     up = false;
    }

   if (down){
      Serial.println("DOWN");
      delay(TIMER_SWITCH);
      down = false;
   }
}

// -----------------------------------------------------------------------
//    manejo de interrupción de boton UP pulsado
// -----------------------------------------------------------------------
void boton_up(){
  up = true;
  }


// -----------------------------------------------------------------------
//    manejo de interrupción de boton DOWN pulsado
// -----------------------------------------------------------------------
 void boton_down(){
  down = true;
  }

Tengo el semáforo. No funciona perfecto pero luego por la madrugada subo el código. Es que he salido para celebrarlo.

Código. Omito muchas líneas que no son relevantes para la solución:

[...]
int pulsador(2);
int boton2;
unsigned int boton; //variable de número de pulsaciones
unsigned int tiempoinicial; //variable secundaria de tiempo
unsigned int tiempofinal;

void setup()
{
pinMode(peaton_rojo, OUTPUT);
pinMode(peaton_verde, OUTPUT);
pinMode(coche_verde, OUTPUT);
pinMode(coche_rojo, OUTPUT);
pinMode(coche_ambar, OUTPUT);
pinMode(pulsador, INPUT);
Serial.begin(9600);

}

void loop()

//Inicio, cuenta tiempo y prepara el semáforo para estar en verde

{

  empezar:
  delay(100);
  unsigned long tiempo=millis();
  [...]
  digitalWrite(peaton_rojo, HIGH);
  digitalWrite(coche_rojo, LOW);
  digitalWrite(coche_verde, HIGH);
  tiempoinicial = tiempo - tiempofinal;

//Botón

  boton = digitalRead(pulsador);
  if(boton > 0){
    boton2++;
  }
  if (tiempoinicial < 22000)
  {
    goto empezar;
  
  }else if(boton2 == 0){
    goto empezar;
  }
 
//Cambio a rojo

  continuar:
  [...]

//Peatones

  [...]
  boton2=0; //almacena cero pulsaciones en el botón
  tiempofinal=tiempo; //almacena el tiempo actual

Finalmente no funciona como quería, pero tras el primer ciclo, respeta ya siempre los diez segundos que puse en un primer momento a condición de que en el primer ciclo haya que esperar 22s. Realmente estaba ya desesperado y cambiando y poniendo variables para ver si podía hacerlo, finalmente, de casualidad, ha funcionado.

Me he dado cuenta que cuando hace el ciclo de luces, el tiempo se incrementa en 12s, que es lo que tarda en hacer el ciclo. Eso en algunos casos provocaba la situación anterior, que nada más ponerse en verde, el botón respondía. Era porque sí hacía caso a esa diferencia de 10s, pero es que ejecutar el programa, ya consumía esos 10s de rigor. Finalmente le incrementé el tiempo en el primer ciclo y los siguientes ciclos ya funcionan a poco más de 10s. Lo que me ha costado el hijo p*ta!! El código no es bonito y podrá tener algún fallo (el primer ciclo es un fallo) pero hace más o menos lo que quiere y me doy por satisfecho. Seguiré haciendo códigos pequeños para aprender a manejarlo. El siguiente, intentaré que sea el acelerador de un tren, que acelera poco a poco pero frena en seco. Veremos cómo se me dan las salidas PWM, que de momento no voy mal.

 

[SPTR]

Cómo te lo pasas mc clein, jijijiji,

Yo sin saber mucho, ya veía que eso de los leds, como lo habías puesto al principio, se encenderían todos a la vez, jajajaja, la culpa es tuya que no sabes programar

Ayyy perrilla, como te va el barrillo.

 

[jmalm]

Uff, los goto esos... no me gustan nada jejejejee

 

[McClane]

Uff, los goto esos... no me gustan nada jejejejee

No he sabido hacerlo de otra manera.

 

[McClane]

la culpa es tuya que no sabes programar

Ayyy perrilla, como te va el barrillo.

Y con razón.



Esta noche he pedido una placa de prototipo con varios cables, una pantalla de 16x4 con I2C y una placa CAN-BUS para decirle algo a los coches y que no se cabreen. Ya tengo hasta fin de año para hacerlo funcionar todo bien.

 

[jmborja]

Hola foreros!! He decidido abrir este hilo porque, por lo que veo, hay algo de gente por aquí haciendo cosillas en ARDUINO y molaría que estuviese centralizado, para responder a dudas, mostrar proyectos o resolver problemas que tengamos. Hoy me estreno en ARDUINO con una placa NANO, y parece que ni siquiera llego a arrancar, por lo que es un buen pretexto para iniciar este hilo.

He recibido esta tarde, como digo, una placa NANO por cuatro euros, Por el precio, es evidente que no es original, pero como este proyecto es libre, todos tenemos acceso al diseño de la placa y todos sus datos, por lo que otro fabricante puede sacar su clon o su versión paralela más grande, más pequeña o directamente igual.

El problema es el siguiente: no consigo programar la placa. He querido subir el proyecto del parpadeo del LED integrado en la placa (quizá el programa más sencillo) pero no llega a subirlo. El error que da es el siguiente:

avrdude: stk500_recv(): programmer is not responding
avrdude: stk500_getsync() attempt 1 of 10: not in sync: resp=0x00

Antes de escribir este hilo, me he pegado cabezazos contra el ordenador y he hecho/visto lo siguiente:

-Instalar el controlador FTDI específico para Mac (el genérico no vale)
-Después de instalarlo, he visto que esta placa no trae controlador ATMEL, sino el CH340G
-Se instala el controlador CH340 y CH341
-Ahora, en "Herramientas/Puerto" sale el ARDUINO con dirección /etc/cu.wchusbserial1a1310
-El programa se compila correctamente
-Se selecciona la placa ARDUINO NANO con chip ATMEGA 168, que es el de la placa
-Subo el programa
-Sale el error de arriba

He probado esto mismo con Windows y más de lo mismo. La versión del programa es la más alta en ambos sistemas y en Windows también está instalado el controlador CH340 correspondiente, seleccionándose debidamente.

Lo que veo extra es lo siguiente:

-En Herramientas/Información de la placa" me sale el siguiente código:

BN: Una plata desconocida
VID: 1A86
PID: 7523
SN: Subir cualquier sketch para obtenerlo

-En el Monitor serie, cuando está abierto y pulso el botón RESET de la placa, me devuelve todos los caracteres ASCII que puede manejar la placa

Pero, para terminar...

Al subir un programa, me sale "programmer is not responding" y no hay narices a programar la placa ni en Windows ni en Mac. Es más, el funcionamiemto más errático lo tiene Windows, ya que aquí, me dice directamente "COM14 is busy".

Según veo por Youtube, al menos en Windows, es instalar el controlador CH340 y ya se puede programar la placa, pero en mi caso, es imposible. En teoría, el lunes me llega una ARDUINO UNO (en teoría es la original), a ver si esa funciona o es que se me está escapando algo.

¿Alguno ha tenido algún problema así con placas paralelas o solamente usáis las originales?


Por cierto. Todo esto es para hacer una cabina de simulación para Euro Truck Simulador 2.


Saludos!!

Mi hijo creo que está enredando también en “ésto”.
Le voy a pasar el enlace del hilo

 

[McClane]

Mi hijo creo que está enredando también en “ésto”.
Le voy a pasar el enlace del hilo

Dile si sabe hacer funcionar una pantalla de 20x4 por I2C, que me acaba de llegar, cargo un programa que es "cargar y listo" y aquí no funciona esto.

 

[McClane]

Mi hijo creo que está enredando también en “ésto”.
Le voy a pasar el enlace del hilo

Bueno, dile que he sudado bastante pero que al final lo he conseguido

 

[jmborja]

Dile si sabe hacer funcionar una pantalla de 20x4 por I2C, que me acaba de llegar, cargo un programa que es "cargar y listo" y aquí no funciona esto.

Bueno, dile que he sudado bastante pero que al final lo he conseguido

Ver el archivos adjunto 40756

Cuando venga el finde se lo comentaré

 

[josete_perez]

Pillo sitio en el hilo que tengo en danza un par de proyectos con arduino a la espera qué lleguen los componentes

He visto tutoriales a parte que estos cacharros ya los trasteaba cuando era chispas pero claro entonces el acceso y los precios a los paratos de la época era bastante más elevado que en la actualidad

Me he decidido a montar dos display de números y Leds para los simuladores que me marquen las revoluciones número de marcha y unos leds Con una arduino nano

Y
Por otra parte me quiero hacer un volante con un motor de pasos con su driver para el encoder y una fuente de alimentación que irá conectado a una Leonardo

El tema de conexiones lo tengo claro y el software más o menos pero como siempre me surgira alguna duda y o problema le expondré en el hilo tanto eso como el montaje y si consigo hacerlo funcionar también lo pondré en el hilo

Saludos

 

[elbader]

Te seguiré con interés @josete_perez, aunque mu malas fechas para seguir nada .
¿Por qué un motor de pasos? ¿Para darle "vida" al volante?

 

[josete_perez]

Te seguiré con interés @josete_perez, aunque mu malas fechas para seguir nada .
¿Por qué un motor de pasos? ¿Para darle "vida" al volante?

Xacto, dicen que avanza en pasos de 1,8 grados a parte con el encoder manda hacia donde debe girar con qué intensidad y en qué punto se encuentra

Si los volantes de 200 pavos de plástico ya molan uno con aro de verdad y 9 nm de par tiene que ser un flipe

 

[josete_perez]

Después de seis horas trasteando con la arduino Leonardo he conseguido que funcione, de momento con un display matrix de 8x8 que ya me indica la marcha y hasta tiene animación pero si él display han sido seis horas no me quiero imaginar lo que me va a costar el volante

Ya tengo aquí el motor con su driver, en cuanto llegue la fuente de alimentación me pongo a ver si soy capaz de hacerlo funcionar

La verdad que me tirado unos días entretenido con el aparatejo

 

[pasko]

Hola.

Yo también he trasteado un poco con esto
Tengo un arduino funcionando con sensor de temperatura y humedad y un led infrarrojo para control remoto del split del aire acondicionado.
Me he basado en el software que hay aquí:
https://github.com/danny-source/Arduino_DY_IRDaikin

También compré uno de estos para controlar con la voz una lámpara del salón:
https://www.itead.cc/smart-socket.html
Estos son clones de Arduino basadas en ESP8286, y luego le puse este software:
https://github.com/arendst/Sonoff-Tasmota

Atento a lo que vayáis contando!

Saludos.

 

[josete_perez]

Ha llegado la fuente de alimentación esta noche empiezo las pruebas del motor del volante aunque el aro y el adaptador no han llegado todavía ni he fabricado el soporte pero tampoco me voy a meter más en harina hasta que no sea capaz de hacer que funcione que tengo mis dudas

 

[McClane]

Aquí atento a la que vas a liar.

 

[josete_perez]

Me imagino la escena




Ahora en serio espero que no haga pum y por si acaso 2 extintores tengo

 

[josete_perez]

Funcionar funciona y con la librería de prueba se mueve al principio conecte al revés una de la bobinas y lo único que hacía era vibrar, después de repasar y corregir el error empezó a moverse ahora me falta averiguar porqué se mueve lento , intento subir las revoluciones y vario los pasos del motor pero no se como subir la velocidad o hacer que haga distintas cosas salvo cuando cambio los pines de la placa

Me va a tocar estudiármelo a fondo y hacer muchas pruebas

 

[pasko]

Hola.

Funcionar funciona y con la librería de prueba se mueve al principio conecte al revés una de la bobinas y lo único que hacía era vibrar, después de repasar y corregir el error empezó a moverse ahora me falta averiguar porqué se mueve lento , intento subir las revoluciones y vario los pasos del motor pero no se como subir la velocidad o hacer que haga distintas cosas salvo cuando cambio los pines de la placa

Me va a tocar estudiármelo a fondo y hacer muchas pruebas

Vaya pinta tiene eso!

Si nos dices qué librerías utilizas para el control del paso-a-paso, a lo mejor te podemos ayudar con la velocidad de giro (o a lo mejor no ). Cuantos más ojos, mejor!

Saludos.

 

[josete_perez]

Hola.



Vaya pinta tiene eso!

Si nos dices qué librerías utilizas para el control del paso-a-paso, a lo mejor te podemos ayudar con la velocidad de giro (o a lo mejor no ). Cuantos más ojos, mejor!

Saludos.

Estoy usando el ejemplo que viene como Stepper one revolution es de la única manera que consigo hacer que se mueva

Luego me falta saber como puñetas se mete un archivo hex que es el que comunica la placa con el motor y y para que el calibrador me lo reconozca pero no hay manera o soy mu tonto o en algún sitio la lío

Uso un programa llamado xloader, cargo el archivo hex pero cuando le doy a subir a la placa esta hace un reseteo y se cambia de puerto unos Segundos, luego se queda colgado y no va ni patras