Reparación estación de soldadura Baku 601D

[AG1]

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.

[AG1]

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.

[Jhousefath]

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!!!

[AG1]

SN8P2714K.jpg
(37.66 kB, 448x211 - visto 4033 veces)

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:

Código: [Seleccionar]

/* 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,

Código: [Seleccionar]

/*
 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,

Código: [Seleccionar]

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:

Código: [Seleccionar]

/* 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.

[gustavopic]

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 ??

[andres lopez]

amigo muchas gracias

[AG1]

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.

[andres lopez]

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

[AG1]

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

Salu2.

[andres lopez]

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

[andres lopez]

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

[AG1]

En el archivo comprimido van los archivos necesarios, aunque el contenido de ellos lo tienes en el hilo.

Salu2.

[andres lopez]

amigo gracias pero yo uso este programa arduino-1.8.13-windows y me da error en #include "\\WD\Baku601D\Baku601D\7seg.c"

[AG1]

Tienes que cambiar la carpeta donde tengas el archivo, en mi caso era "\\WD\Baku601D\Baku601D"

Salu2.

[andres lopez]

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.