TODOPIC
FORO TÉCNICO => Foro Técnico => Mensaje iniciado por: AG1 en 20 de Abril de 2016, 20:32:33
-
He "roto" la estación de soldadura Baku601D. He visto que lo que se ha estropeado el único microcontrolador que incorpora, un Sonix SN8P2714K.
De momento estoy desarrollando un programa para un Arduino mini Pro 5V, que gestione el funcionamiento de la estación de soldadura. He hecho un adaptador para insertar el módulo Arduino en el zócalo DIP de 28 pines del SN8P2714K y así ir realizando pruebas.
¿Alguien tiene alguna sugerencia o ayuda para abreviar la reparación?
Salu2.
-
Bueno por fin tengo la estación de soldadura funcionando. El importe de las horas empleadas en la reparación de la misma superaría con creces el valor de la misma.
No he encontrado nada de información sobre este modelo, aunque sí sobre otros modelos similares que me han permitido comprender el funcionamiento de la misma.
Para repararla he tenido:
1º hacerme un esquema de la estación.
2º He tenido que fabricarme el adaptador del zócalo DIP28 del Sonix SN8P2714K al Arduino Mini Pro 5V.
3º Por último, y mas laborioso, implementar un programa para el Arduino que gestione el circuito de la estación.
Salu2.
-
Amigo buen dia, me acabo de encontrar con tu post y es exactamente la informacion que ando buscando, que por cierto no he encontrado nada, tengo mi estacion la cual se daño el pic y tambien pensaba en hacer una adaptacion con arduino ya que no consigo el pic, por lo cual espero me puedas ayudar con explicarme que es lo que hiciste para hacer funcionar tu estacion.
De antemano gracias.
Saludos!!!
-
- Tienes que ingresar para ver archivos adjuntos -
Aunque el hilo es ya antiguo, a petición mediante MP de Antonio Lopez voy a detallar lo que recuerdo de como reparar la estación de soldadura, la sustitución del micro dañado por un módulo Arduino mini Pro 5V:
El archivo a cargar en Arduino sera el Baku601D.ino:
/* BAKU601D Soldering Controller
2016 L. Serrano.
www.allm2m.com
*/
#include "Arduino.h"
#include <avr/wdt.h> // incluimos esta biblioteca para poder utilizar el perro guardian
float fResolucion=0.0; // un bit, 5/1024 = 0.0048828125V
float fTime = 0.0; // Time
//---------
float fTimeSampling;
float fTimeLast;
int iPID_o_OnOff = 0; // 0=PWM, 1=OnOff. Configuración inicial del controlador
//Constantes necesarias para SolderingIron.c
const float fADCMax = 5.0; // máximo rango convertidor ADC
//Constantes y variables necesarias para HotAirGun.c
float fTSetAir = 0.0; // Set point [C]
volatile int contadorEncoder=22;
const int MaxcontadorEncoder=22; // maximo 22
volatile int anteriorEstadoEncoder=0;
//long contadorEncoderAnterior = 0;
int lastMSB = 0;
int lastLSB = 0;
#include "\Baku601D_files\7seg.c"
#include "\Baku601D_files\SolderingIron.c"
#include "\Baku601D_files\HotAirGun.c"
const int iADCResolucion = 1024; // para convertidor ADC de 10 bits
void updateEncoder(){
int MSB = digitalRead(encoderUP); //MSB = most significant bit
int LSB = digitalRead(encoderDN); //LSB = least significant bit
int EstadoEncoder = (MSB << 1) |LSB; //converting the 2 pin value to single number
int sum = (anteriorEstadoEncoder << 2) | EstadoEncoder; //adding it to the previous EstadoEncoder value
if(sum == 0b1101 || sum == 0b0100 || sum == 0b0010 || sum == 0b1011) if (contadorEncoder < MaxcontadorEncoder) contadorEncoder ++;
if(sum == 0b1110 || sum == 0b0111 || sum == 0b0001 || sum == 0b1000) if(contadorEncoder > 0) contadorEncoder --;
anteriorEstadoEncoder = EstadoEncoder; //store this value for next time
}
void setup()
{
// Añadir AL PRINCIPIO de setup() wdt_disable() para desabilitar el perro guardian
wdt_disable();
//Configuramos los pines a ulilizar por el display
// cátodos
pinMode(Segmento_A, OUTPUT);
pinMode(Segmento_B, OUTPUT);
pinMode(Segmento_C, OUTPUT);
pinMode(Segmento_D, OUTPUT);
pinMode(Segmento_E, OUTPUT);
pinMode(Segmento_F, OUTPUT);
pinMode(Segmento_G, OUTPUT);
pinMode(Segmento_DP, OUTPUT);
// ánodos
pinMode(Digito1, OUTPUT);
pinMode(Digito2, OUTPUT);
pinMode(Digito3, OUTPUT);
pinMode(AirMotor, OUTPUT);
pinMode(encoderUP, INPUT_PULLUP);
pinMode(encoderDN, INPUT_PULLUP);
pinMode(SwitchGun, INPUT_PULLUP);
pinMode(AirHeater, OUTPUT);
AirHeater_OFF();
AirMotor_OFF();
ApagaSegmentos(); //
fResolucion = fADCMax / iADCResolucion; // un bit, 5/1024 = 0.0048828125V
fTimeLast = millis();
for (int veces=3; veces > 0; veces--)
{
VisualizaNumero(0,8); //Parpadeo de los 3 segmentos G
delay(400);
}
//call updateEncoder() when any high/low changed seen
//on interrupt 0 (pin 2), or interrupt 1 (pin 3)
attachInterrupt(0, updateEncoder, CHANGE);
attachInterrupt(1, updateEncoder, CHANGE);
//WDTO_15MS WDTO_30MS WDTO_60MS WDTO_120MS WDTO_250MS WDTO_500MS WDTO_1S
//WDTO_2S WDTO_4S WDTO_8S
//AL FINAL de setup() wdt_enable(WDTO_60MS); // habiliutamos el perro guardian
}
void loop()
{
// Despertamos al perro
wdt_reset();
fTime = millis() / 1000.0 ;
fTimeSampling = fTime - fTimeLast;
fTimeLast = fTime ;
// Soldering Station
LeeTemperaturaSold();
Lee_VR1(); // lee potenciometro de regulacion temperatura soldador(VR1)
PIDSold(); // Proceso de estacion Soldadura
// SMD Station
LeeTemperaturaAir();
if (!Air_Gun_Ok()) // Si la pistola esta en su soporte
{
AirHeater_OFF(); // Apaga resistencia calefactora
if (fTempAir <45) AirMotor_OFF(); // Si la pistola esta fuera de su receptaculo y la temperatura <45°C
if (fTempAir >60) AirMotor_ON_Max(); // Si la pistola esta fuera de su receptaculo y la temperatura >60°C, motor a maxima velocidad
}
if (SMD_Station()== true)
{
if (Air_Gun_Ok()) // Si la pistola esta fuera de su soporte, siempre aire
{
////
//////
if (fTempAir >230) AirMotor_ON_Max(); // Si la pistola esta fuera de su receptaculo y la temperatura >250°C, motor a maxima velocidad
else AirMotor_ON(); // Si la pistola esta fuera del receptaculo, aire On
Lee_VR2(); // lee potenciometro de regulacion temperatura aire(VR1)
Control_ON_OFF_Aire(); // Proceso de estacion Aire
VisualizaNumero((int) fTempAir,3); //Visualiza la temperatura actual del aire
}
else
{
Lee_VR2();
VisualizaNumero((int) fTSetAir,0); //Visualiza la temperatura deseada para el aire
}
}
else
{
AirHeater_OFF();
VisualizaNumero((int) fTempSold,0); //Visualiza la temperatura actual del soldador
}
}
e incluirá los archivos 7seg.c,
/*
Ejemplo de visualizacion en un display de 7 segmentos, de 3 digitos con Arduino,
sin utilizar resistencias limitadoras de corriente. Estas rutinas se han implementado para un display de color rojo SM310401K.
*/
/*
Estas rutinas se pueden portar facilmente para el uso con un microcontrolador PIC.
Para la gestión del display se necesitan 11 pin
*/
// Anodos (dígitos contando por la izquierda)
int Digito1 = 6; // Control PWM ánodo dígito 1
int Digito2 = 5; // Control PWM ánodo dígito 2
int Digito3 = 9; // Control PWM ánodo dígito 3
// Cátodos
int Segmento_A = A4; // Segmento A del display
int Segmento_B = A5; // Segmento B del display
int Segmento_C = A3; // Segmento C del display
int Segmento_D = 7; // Segmento D del display
int Segmento_E = 12; // Segmento E del display
int Segmento_F = 13; // Segmento F del display
int Segmento_G = 8; // Segmento G del display
int Segmento_DP = 0; // Segmento DP(punto decimal) del display
// Configuramos las salidas
//en el Seup del Sketch
//Enciende los segmentos de un dígito
void VisualizaDigito(int digito_N)
{
#define Segmento_ON LOW // Cátodo ON por nivel Low
#define Segmento_OFF HIGH // Cátodo OFF por nivel High
switch (digito_N)
{
case 0:
digitalWrite(Segmento_A, Segmento_ON);
digitalWrite(Segmento_B, Segmento_ON);
digitalWrite(Segmento_C, Segmento_ON);
digitalWrite(Segmento_D, Segmento_ON);
digitalWrite(Segmento_E, Segmento_ON);
digitalWrite(Segmento_F, Segmento_ON);
break;
case 1:
digitalWrite(Segmento_B, Segmento_ON);
digitalWrite(Segmento_C, Segmento_ON);
break;
case 2:
digitalWrite(Segmento_A, Segmento_ON);
digitalWrite(Segmento_B, Segmento_ON);
digitalWrite(Segmento_D, Segmento_ON);
digitalWrite(Segmento_E, Segmento_ON);
digitalWrite(Segmento_G, Segmento_ON);
break;
case 3:
digitalWrite(Segmento_A, Segmento_ON);
digitalWrite(Segmento_B, Segmento_ON);
digitalWrite(Segmento_C, Segmento_ON);
digitalWrite(Segmento_D, Segmento_ON);
digitalWrite(Segmento_G, Segmento_ON);
break;
case 4:
digitalWrite(Segmento_B, Segmento_ON);
digitalWrite(Segmento_C, Segmento_ON);
digitalWrite(Segmento_F, Segmento_ON);
digitalWrite(Segmento_G, Segmento_ON);
break;
case 5:
digitalWrite(Segmento_A, Segmento_ON);
digitalWrite(Segmento_C, Segmento_ON);
digitalWrite(Segmento_D, Segmento_ON);
digitalWrite(Segmento_F, Segmento_ON);
digitalWrite(Segmento_G, Segmento_ON);
break;
case 6:
digitalWrite(Segmento_A, Segmento_ON);
digitalWrite(Segmento_C, Segmento_ON);
digitalWrite(Segmento_D, Segmento_ON);
digitalWrite(Segmento_E, Segmento_ON);
digitalWrite(Segmento_F, Segmento_ON);
digitalWrite(Segmento_G, Segmento_ON);
break;
case 7:
digitalWrite(Segmento_A, Segmento_ON);
digitalWrite(Segmento_B, Segmento_ON);
digitalWrite(Segmento_C, Segmento_ON);
break;
case 8:
digitalWrite(Segmento_A, Segmento_ON);
digitalWrite(Segmento_B, Segmento_ON);
digitalWrite(Segmento_C, Segmento_ON);
digitalWrite(Segmento_D, Segmento_ON);
digitalWrite(Segmento_E, Segmento_ON);
digitalWrite(Segmento_F, Segmento_ON);
digitalWrite(Segmento_G, Segmento_ON);
break;
case 9:
digitalWrite(Segmento_A, Segmento_ON);
digitalWrite(Segmento_B, Segmento_ON);
digitalWrite(Segmento_C, Segmento_ON);
digitalWrite(Segmento_D, Segmento_ON);
digitalWrite(Segmento_F, Segmento_ON);
digitalWrite(Segmento_G, Segmento_ON);
break;
}
}
void VisualizaSegG()
{
digitalWrite(Segmento_G, Segmento_ON);
}
void VisualizaDP()
{
digitalWrite(Segmento_DP, Segmento_ON);
}
void ApagaSegmentos()
{
digitalWrite(Segmento_A, Segmento_OFF);
digitalWrite(Segmento_B, Segmento_OFF);
digitalWrite(Segmento_C, Segmento_OFF);
digitalWrite(Segmento_D, Segmento_OFF);
digitalWrite(Segmento_E, Segmento_OFF);
digitalWrite(Segmento_F, Segmento_OFF);
digitalWrite(Segmento_G, Segmento_OFF);
digitalWrite(Segmento_DP, Segmento_OFF);
}
// Brillo del display:
// Cada dígito esta encendido Brillo_Display microsegundos.
// Luego estÁ apagado hasta que hallan transcurrido 20ms desde que se llamó a la función.
// Asumimos que cada dígito esta encendido 1000us.
// Cada dígito estará encendido 1ms, como hay 3 dígitos, el display estará apagado completamente 17ms.
// Esta relación de 1ms a 17ms equivale a 5.88% ???? on time (PWM).
// Definimos la variable Brillo_Display que varía desde:
// 5000 brillo deslumbrante (corriente consumida por un dígito: 15.7mA)
// 2000 brillo muy fuerte (corriente consumida por un dígito: 11.4mA)
// 1000 bastante luminoso (corriente consumida por un dígito: 5.9mA)
// 500 normal (corriente consumida por un dígito: 3mA)
// 200 tenue pero legible (corriente consumida por un dígito: 1.4mA)
// 50 tenue pero legible (corriente consumida por un dígito: 0.56mA)
// 5 tenue pero legible (corriente consumida por un dígito: 0.31mA)
// 1 tenue pero legible en la oscuridad (corriente consumida por un dígito: 0.28mA)
void VisualizaNumero(int Numero, int DP)
{
#define Brillo_Display 400
#define Anodo_Digito_ON HIGH
#define Anodo_Digito_OFF LOW
long beginTime = millis();
for(int digito = 3 ; digito >0 ; digito--)
{
//Conecta los ánodos de los 3 dígitos Brillo_Display microsegundos
switch(digito)
{
case 1:
digitalWrite(Digito1, Anodo_Digito_ON);
break;
case 2:
digitalWrite(Digito2, Anodo_Digito_ON);
break;
case 3:
digitalWrite(Digito3, Anodo_Digito_ON);
break;
}
//Conecta los segmentos de este dígito, como resultado lo enciende.
if (DP==0)
{
VisualizaDigito(Numero % 10);
Numero /= 10;
}
else
{
if (DP==8) VisualizaSegG(); // Visualiza los 3 segmentos G
else //Visuliza el númmero y los DP de los segmentos indicados
{
VisualizaDigito(Numero % 10);
Numero /= 10;
if (digito == DP) VisualizaDP();
}
}
delayMicroseconds(Brillo_Display);
//Visualiza dígito Brillo_Display microsegundos (1us a 5000us, 500 esta bastante bien)
ApagaSegmentos(); // Desconecta todos los segmentos, como resultado dígitos apagados.
//Desconecta los ánodos de 3 dígitos
digitalWrite(Digito1, Anodo_Digito_OFF);
digitalWrite(Digito2, Anodo_Digito_OFF);
digitalWrite(Digito3, Anodo_Digito_OFF);
}
while( (millis() - beginTime) < 10) ;
//Espera 20ms, con los dígitos apagados, antes de volver a refrescar el display con un nuevo número.
}
SolderingIron.c,
int SensorTempSold = A2; // pin sensor temperatura soldador 18
int ReguladorTempSold = A1; // pin potenciometro de regulación de temperatura soldador 17
int pwmHeater = 11; // pin PWM Soldering Heating 27
const float fAmplificacionSold= 20000/270; // 20K / 270 = 74 aprox.
const float fSensibilidadTermocuplaSold = 0.000041; // Termocupla tipo K
//const float fSensibilidadTermocuplaAir= 0.000068; // Termocupla tipo E
//--PID
const float fKpSold = 10.0; // proportional gian (Value tested with HQ Soldering Iron = 10 )
const float fKiSold = 1.0; // integral gian (Value tested with HQ Soldering Iron = 1)
const float fKdSold = 10.0; // derivative gian (Value tested with HQ Soldering Iron = 10)
// Cálculos
float fTempSold = 0.0; // Temperatura [C]
float fTSetSold = 0.0; // Set point [C]
float fVoltajeSold; // Voltaje desde entrada A1
//--PID
float fEkSold = 0.0; //error actual
float fEk_1Sold = 0.0; //último error
float fPWMSold; //salida PWM
float fIntegralTermSold =0.0;
int iTemperaturaSoldador()
{
// Leer una entrada analogica lleva alrededor de 100 microsegundos (0.0001s).
return analogRead(SensorTempSold);
}
float fLimitSold (float fVariable, float fMax, float fMin)
{
//Funcion saturacion
if (fVariable > fMax)
{
fVariable = fMax ;
}
if (fVariable < fMin)
{
fVariable = fMin ;
}
return fVariable ;
}
float fPIDsencilloSold()
{
// Calcula el comando PID, primero calcula los coeficientes
float fPIDsencillo;
fIntegralTermSold = fIntegralTermSold + fKiSold * fEkSold * fTimeSampling;
fIntegralTermSold = fLimitSold(fIntegralTermSold, 255.0, 0.0);
fPIDsencillo = fKpSold * fEkSold + fIntegralTermSold + fKdSold * (fEkSold - fEk_1Sold); // PIDSencillo
fPIDsencillo = fLimitSold(fPIDsencillo, 255.0, 0.0);
return fPIDsencillo;
}
void LeeTemperaturaSold()
{
fVoltajeSold = iTemperaturaSoldador() * fResolucion; // lee el pin de entrada y calcula Voltaje
fTempSold = fVoltajeSold/fAmplificacionSold/fSensibilidadTermocuplaSold; // calcula la Temperatura del soldador
fEkSold = fTSetSold - fTempSold; // error para PID sencillo
}
void Lee_VR1()
{
// 1024 / 280 = 3.6571428571428571428571428571429 bits por grado
// 1024 / 281 = 3.6441281138790035587188612099644 bits por grado
// fResolucion = fADCMax / iADCResolucion= 5V/1024 = 0.0048828125V
// 0.017858V ºC
// 0V 200ºC, 5V 480ºC
// La regulación es de 200ºC, de 200ºC a 480ºC
// Leer una entrada analógica lleva alrededor de 100 microsegundos (0.0001s)
int Valor_VR1=analogRead(ReguladorTempSold);
fTSetSold=(Valor_VR1/3.64413)+200; // fTSet con temperatura indicada por mando VR1
}
void PIDSold()
{
iPID_o_OnOff = 0; //on off
if (iPID_o_OnOff == 1 ) // Si control OnOff activo
{
// regulación On-Off
// control ON-OFF sencillo, funciona bien (entre +8 y -2 degC de SetPoint)
if (fEkSold < 0)
{
analogWrite(pwmHeater, 0); // resistencia OFF
}
else
{
analogWrite(pwmHeater, 255); // resistencia ON
}
}
if (iPID_o_OnOff == 0 ) // Si control PID activo
{
// regulación PID
fPWMSold = fPIDsencilloSold(); // Calcula comando PID
fEk_1Sold = fEkSold; // guarda el último error
analogWrite(pwmHeater, fPWMSold); // ejecuta el comando
}
}
y HotAirGun.c:
/* Gestion de la pistola de aire caliente de la estación Baku 601D. */
long Timer_encoder=0;
int SensorTempAire = A7; // pin sensor temperatura aire 19
int ReguladorTempAire = A0; // pin potenciometro de regulación de temperatura aire(VR2) 16
int AirMotor = 10; // PWM pin Air Motor 1
int AirHeater = 1; // pin Air Heating 4
int encoderUP = 2; // pin flujo aire UP 5 INT0
int encoderDN = 3; // pin flujo aire DOWN 6 INT1
int SwitchGun = A6; // interruptor Reed pistola aire 7
int Sw_SMD_Station = 4; // interruptor encendido sección aire 26
const float fAmplificacionAir= 24000/220; // 24K / 220 = 109 aprox.
//const float fSensibilidadTermocuplaAir= 0.000068; // Termocupla tipo E
const float fSensibilidadTermocuplaAir= 0.000041; // Termocupla tipo K
// Cálculos
float fTempAir = 0.0; // Temperatura [C]
float fVoltajeAir; // Voltaje desde entrada A1
//--PID
float fEkAir = 0.0; //error actual
int iTemperaturaAire()
{
// Leer una entrada analogica lleva alrededor de 100 microsegundos (0.0001s).
return analogRead(SensorTempAire);
}
float fLimitAir (float fVariable, float fMax, float fMin)
{
//Funcion saturacion
if (fVariable > fMax)
{
fVariable = fMax ;
}
if (fVariable < fMin)
{
fVariable = fMin ;
}
return fVariable ;
}
void LeeTemperaturaAir()
{
fVoltajeAir = iTemperaturaAire() * fResolucion; // lee el pin de entrada y calcula Voltaje
fTempAir= fVoltajeAir/fAmplificacionAir/fSensibilidadTermocuplaAir; // calcula la Temperatura de la pistola de aire
fEkAir = fTSetAir - fTempAir; // error para PID sencillo
}
void AirMotor_ON_Max()
{
digitalWrite(AirMotor, LOW); // Motor ventilador ON a maxima velocidad
}
void AirMotor_ON()
{
if (millis()<(Timer_encoder))
{
digitalWrite(AirMotor, HIGH); // Motor ventilador OFF
}
else
{
digitalWrite(AirMotor, LOW); // Motor ventilador ON
// delay(2); // Deja que el motor tome velocidad
Timer_encoder=millis()+(contadorEncoder*2);
}
}
void AirMotor_OFF()
{
digitalWrite(AirMotor, HIGH); // Motor ventilador OFF
}
void AirHeater_ON()
{
digitalWrite(AirHeater, LOW); // Resistencia aire ON
}
void AirHeater_OFF()
{
digitalWrite(AirHeater, HIGH); // Resistencia aire OFF
}
boolean SMD_Station()
{
if (digitalRead(Sw_SMD_Station) == LOW) return true;
else return false;
}
boolean Air_Gun_Ok() // Si la pistola esta fuera de su soporte
{
// Cuando esta en el soporte, el rele Reed , por medio de la PTC, pone
// el pin SwitchGun a nivel LOW
if (analogRead(SwitchGun) > 512) return true; // nievel high
else return false;
}
void Lee_VR2()
{
// 1024 / 350 = 2.9257142857142857142857142857143 bits por grado
// 1024 / 351 = 2.9173789173789173789173789173789 bits por grado
// fResolucion = fADCMax / iADCResolucion= 5V/1024 = 0.0048828125V
// 0.01428571428571428571428571428571ºC 5/350
// 0V 500ºC , 5V 150ºC .
// La regulación es de 500ºC, de 150ºC a 500ºC
// Leer una entrada analógica lleva alrededor de 100 microsegundos (0.0001s)
int Valor_VR2=analogRead(ReguladorTempAire);
Valor_VR2=1024-Valor_VR2; // VR2 esta invertido, a principio escala 5V y a final escala 0V
//float fTSetAir=0.0;
fTSetAir=(Valor_VR2/2.91738)+150; // fTSetA con temperatura indicada por mando VR2
}
void Control_ON_OFF_Aire()
{
// regulación On-Off
// control ON-OFF sencillo, funciona bien (entre +8 y -2 degC de SetPoint)
if (fEkAir < 0)
{
digitalWrite(AirHeater, HIGH); // resistencia OFF
}
else
{
digitalWrite(AirHeater, LOW); // resistencia ON
}
}
En estos archivos van indicadas las conexiones de los pines del Arduino mini Pro 5V al los respectivos pines del micro.
Salu2.
-
hola, y si en vez de hacer ese adaptador usas un arduino comun, que viene con el micro en zocalo y programas el zocalo y se lo sacas y a la placa??
he visto que se ahce
es unsar el arduino como programador .
no va ??
-
amigo muchas gracias
-
hola, y si en vez de hacer ese adaptador usas un arduino comun, que viene con el micro en zocalo y programas el zocalo y se lo sacas y a la placa??
he visto que se ahce
es unsar el arduino como programador .
no va ??
El programa solamente funciona correctamente con el Arduino mini Pro 5V.
El programa no está diseñado ni para la versión de 3.3V ni para cualquier otro Arduino que no sea el Arduino mini Pro 5V.
En caso de sustituir el Arduino mini Pro 5V por otro distinto, sería necesario modificar el programa y en algunos casos incluso el circuito.
Salu2.
-
una pregunta y este si funciona? y lo otro es que no tengo muy claro lo del código como lo tengo que copiar al arduino.exe me da varios errores
-
Parece que sea el de 5V y el micro es el Atmega328p. No te lo puedo asegurar pues se venden muchas versiones. Si el oscilador que lleva es el de 16Mhz, yo diría que si.
Esta página te puede sacar de dudas https://arduino.stackexchange.com/questions/8511/how-to-identify-arduino-mini-pro-5v-vs-3-3v/28400 (https://arduino.stackexchange.com/questions/8511/how-to-identify-arduino-mini-pro-5v-vs-3-3v/28400)
Salu2.
-
amigo y donde dice que hay que cargar este archivo Baku601D.ino no entiendo mucho sobre el tema pero no lo encuentro gracias por la ayuda
-
amigo me puedes pasar el archivo Baku601D.ino Dios le pague que pena la molestia es que el programa me da errores cuando coloco el código que colocaste
-
En el archivo comprimido van los archivos necesarios, aunque el contenido de ellos lo tienes en el hilo.
Salu2.
-
amigo gracias pero yo uso este programa arduino-1.8.13-windows y me da error en #include "\\WD\Baku601D\Baku601D\7seg.c"
-
Tienes que cambiar la carpeta donde tengas el archivo, en mi caso era "\\WD\Baku601D\Baku601D"
Salu2.
-
amigo nada me da el siguiente error
Arduino:1.8.13 (Windows 7), Tarjeta:"Arduino Pro or Pro Mini, ATmega328P (5V, 16 MHz)"
Baku601D:37:10: fatal error: \\WD\Baku601D\Baku601D\7seg.c: Invalid argument
#include "\\WD\Baku601D\Baku601D\7seg.c"
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
compilation terminated.
exit status 1
\\WD\Baku601D\Baku601D\7seg.c: Invalid argument
Este informe podría contener más información con
"Mostrar salida detallada durante la compilación"
opción habilitada en Archivo -> Preferencias.
-
Tienes que cambiar la carpeta donde tengas el archivo, en mi caso era "\\WD\Baku601D\Baku601D"
Salu2.
Tienes que modificar el archivo "Baku601D.ino:
En la línea que incluye (#include...) el archivo tienes que sustituir el nombre de la carpeta donde se encuentre el archivo.
Tienes que hacerlo para los 3 archivos que se incluyen.
Yo los tenía en la carpeta "\\WD\Baku601D\Baku601D" , desconozco en qué carpeta los tienes tú.
Salu2
-
Tienes que cambiar la carpeta donde tengas el archivo, en mi caso era "\\WD\Baku601D\Baku601D"
Salu2.
Tienes que modificar el archivo "Baku601D.ino:
En la línea que incluye (#include...) el archivo tienes que sustituir el nombre de la carpeta donde se encuentre el archivo.
Tienes que hacerlo para los 3 archivos que se incluyen.
Yo los tenía en la carpeta "\\WD\Baku601D\Baku601D" , desconozco en qué carpeta los tienes tú.
listo amigo pero ya me da como 16 errores al copilar el programa me dice que es mejor verificar con que versión de programa fue creado me puedes regalar la version con que copilaste el programa gracias
Salu2
-
listo amigo pero ya me da como 16 errores al copilar el programa me dice que es mejor verificar con que versión de programa fue creado me puedes regalar la version con que copilaste el programa gracias
No es mas sencillo, decir cuales son los errores en ves de estar adivinando cual es el problema?
-
listo amigo pero ya me da como 16 errores al copilar el programa me dice que es mejor verificar con que versión de programa fue creado me puedes regalar la version con que copilaste el programa gracias
No es mas sencillo, decir cuales son los errores en ves de estar adivinando cual es el problema?
listo
-
Hola Andres:
La versión de Arduino con que se compilo fue la 1.6.8
He cambiado el archivo comprimido para que sea más fácil realizar su compilación. En el van 2 carpetas, una con el archivo principal y la otra con los 3 archivos restantes:
Copia estas 2 carpetas con sus archivos en el directorio raíz del disco duro del ordenador.
Con la versión 1.6.8 de Arduino, previamente configurada para programar placas Arduino pro o Pro Mini y Procesadores Atmega328 (5V, 16Mhz), abre el archivo Baku601D.ino que se encuentra en la carpeta Baku601D y pulsa verificar, y el programa deberá compilar correctamente............
- Tienes que ingresar para ver archivos adjuntos -
Salu2.
-
listo amigo por fin el error mio era que yo no colocaba los archivos en la raíz del disco duro muchas gracias por todo ya solo falta la conectar todo
-
Hola Andres:
La versión de Arduino con que se compilo fue la 1.6.8
He cambiado el archivo comprimido para que sea más fácil realizar su compilación. En el van 2 carpetas, una con el archivo principal y la otra con los 3 archivos restantes:
Copia estas 2 carpetas con sus archivos en el directorio raíz del disco duro del ordenador.
Con la versión 1.6.8 de Arduino, previamente configurada para programar placas Arduino pro o Pro Mini y Procesadores Atmega328 (5V, 16Mhz), abre el archivo Baku601D.ino que se encuentra en la carpeta Baku601D y pulsa verificar, y el programa deberá compilar correctamente............
- Tienes que ingresar para ver archivos adjuntos -
amigo pero tengo una duda con las colecciones del display no veo a que pata del ic van gracias por la ayuda, también seria bueno que colocaras un vídeo de como quedo tu estación funcionando
// Anodos (dígitos contando por la izquierda)
int Digito1 = 6; // Control PWM ánodo dígito 1
int Digito2 = 5; // Control PWM ánodo dígito 2
int Digito3 = 9; // Control PWM ánodo dígito 3
// Cátodos
int Segmento_A = A4; // Segmento A del display
int Segmento_B = A5; // Segmento B del display
int Segmento_C = A3; // Segmento C del display
int Segmento_D = 7; // Segmento D del display
int Segmento_E = 12; // Segmento E del display
int Segmento_F = 13; // Segmento F del display
int Segmento_G = 8; // Segmento G del display
int Segmento_DP = 0; // Segmento DP(punto decimal) del display
Salu2.
-
El esquema que hice fue este:
-
Debes conectar bien todos los hilos del display para no quemarlo, ya que el display creo que es de 1.8V y esta alimentado por 5V (por software la corriente que circula por los segmentos no lo hace constantemente).
Salu2
-
Debes conectar bien todos los hilos del display para no quemarlo, ya que el display creo que es de 1.8V y esta alimentado por 5V (por software la corriente que circula por los segmentos no lo hace constantemente).
Salu2
Hola amigo que bueno ese diagrama pero ya me sale este error al programar espero su ayuda gracias
In file included from C:\Baku601D\Baku601D.ino:40:0:
In file included from C:\Baku601D\Baku601D.ino:40:0:
\Baku601D_files\HotAirGun.c: In function 'void AirMotor_ON()':
\Baku601D_files\HotAirGun.c:65:16: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]
if (millis()<(Timer_encoder))
~~~~~~~~^~~~~~~~~~~~~~~~
El Sketch usa 4788 bytes (15%) del espacio de almacenamiento de programa. El máximo es 30720 bytes.
Las variables Globales usan 65 bytes (3%) de la memoria dinámica, dejando 1983 bytes para las variables locales. El máximo es 2048 bytes.