Cronógrafo de AVR desde el concepto de PCB (7 / 13 paso)

Paso 7: Construcción de la solución; cargar el programa.

Una vez que todo el código está escrito (en realidad haría esto mucho antes durante el desarrollo) lo necesario para construir la solución.  Esto es cuando el compilador traduce todo el código en un archivo HEX.  El archivo HEX es lo que realmente se cargados en el chip y el chip lo único que puede entender.  Si alguna vez has visto un archivo HEX, sabes que es totalmente no-legible por los seres humanos, así que gracias al compilador.  La primera foto muestra el elemento de menú hacer clic en: construir >> generar solución.

En este punto, verás un montón de cosas pasan en la ventana de salida en la parte inferior, y si hay algún error de compilador te ves aquí también.  Si escribió el código exactamente como en el ultimo paso no debería tener ningún error.  Por si acaso, voy copiar y pegar el código en su totalidad directamente desde mi archivo al final de este paso.  Sólo representé fuera que puedo subir archivos también, así que incluí un archivo ZIP con todos los archivos de estudio de ATMEL.

En este punto debe conectar el dragón para el puerto USB de su ordenador.

En la foto 2, en la parte superior derecha, verás destacados "ISP en AVR Dragon".  Haga clic aquí para abrir una ventana para configurar las opciones de la herramienta al igual que cuando fijamos el bits del fusible.  Hacer que su dragón del AVR es seleccionado y ISP para la interfaz y reloj de control del ISP.  Debajo de eso, ajustes de programación debe ya han "borrar chip todo" seleccionado y "preservar la EEPROM" desactivada.  Su circuito de protoboard de potencia, conecte el cable de cinta de 6 pin del dragón, y somos buenos ir.

Ahora a cargar el programa al chip.  Puede haga clic en herramientas >> Programación de dispositivo >> archivo de producción y luego busque el archivo y el programa.  ¡ Pero! Es mucho más fácil simplemente haga clic en Debug >> iniciar sin depuración (Foto 3).  Automáticamente Recompila el programa y lo carga al chip sin otra palabra como no hay rerrors compilación.

Eso es él! Si trabaja debe tener un funcionamiento cronógrafo en un protoboard!  Puedes jugar con él tocando 12VDC a las entradas de sensor (los circuitos de transistor; no los pines de entrada) con un cable puente.  Además, juega con los interruptores DIP y probar el botón 'Mostrar distancia'.  Una vez que un número como resultado, usted puede probar los DIP switches de selección de unidades de salida y verificar los cálculos.

Ahora sería un buen momento para asegurarse de que sus sensores funcionan correctamente con el circuito.  Estoy suponiendo que probablemente nadie va a utilizar los mismos sensores que tengo, prueba lo tuyo ahora antes de empezar a pensar en un Consejo Permanente de la aguafuerte... mejor hacer cambios ahora mientras el circuito está libre de soldadura.

A continuación, tenemos un vistazo a crear el diseño esquemático y la placa con el ExpressPCB...

CÓDIGO EMPIEZA POR DEBAJO DE ESTA LÍNEA ***

/*
* Speed_measurement.c
*
* Creado: 15/09/2012 20:50:23
* Autor: Thomas L
*/

#define F_CPU 14.7456E6

#include < avr/io.h >
#include < util/delay.h >
#include < avr/interrupt.h >

/************************************************************************/
/ * declarar variables globales * /
/************************************************************************/
unsigned int resultado = 0;
int interruptcount = 0;
int largo = 0;
resetcount int largo = 0;

int Main
{

DDRD = 0 X 00;       PORTD entrada de interrupciones externas
DDR = 0XDF;       PORTC salida de 7 segmentos multiplexado y 1 entrada para la visualización de la distancia
DDRB = 0XFF;       PORTB salida fot 7 datos de segmento en bcd
PORTD | = 0XFF;       permiten portd levantan resistencias
(int0 y int1 requieren externo levantan resistencias o 1 interrupciones se activará en reset)

EICRA | = (1 << ISC11) | (1 << ISC01);   configurar interrupciones externas
EIMSK | = (1 << INT1) | (1 << INT0);   //
TCCR1B | = (1 << CS12);     establece escala para timer1 256

/************************************************************************/
/ * declaramos las variables para el cálculo y la presentación * /
/************************************************************************/

unsigned int unos = 0;
unsigned int decenas = 0;
unsigned int cientos = 0;
unsigned int x = 0;
doble ticsfoot = 0;
doble fps = 0;
doble fph = 0;
doble mph = 0;
doble h = 0;
doble mps = 0;
int distancia = 0;

SEI();        activar interrupciones globales

while(1)
{



/************************************************************************/
/ * obtener sensor distancia en pies de pind 0,1,4,5 * /
/************************************************************************/

int distanceinput = (~ PIND & 0x33);
hibits int = (distanceinput >> 2);      tomando pind bits 0,1 y 4,5 para ser
lobits int = (distanceinput & 0 x 03);     valor de distancia en BCD.  Brocas de 2, 3 son los
distancia = (hibits lobits);       pines de interrupción ext ya en usan.

Si (distancia == 0) distancia = 16;



/************************************************************************/
/ * 'listo' indicador LED * /
/************************************************************************/

Si (interruptcount == 0)
{
PORTC | = (1 << 3);
}
otra cosa
{
PORTC & = (0 << 3);
}

/************************************************************************/
/ * cálculos para encontrar la velocidad en unidades de 4 * /
/************************************************************************/

Si (interruptcount == 2) //only calcular cuando han ocurrido dos interrupciones
{
CLI();               deshabilitar las interrupciones globales

ticsfoot = (tiempo / distancia);      distancia distancia entre sensores en pies - ticsfoot es contador tics/pie
FPS = (57600 / ticsfoot);       57600 es contador tics/seg (cpu clk/prescaler)
FPH = (fps * 60 * 60);
mph = (fph / 5280);
km/h = (mph * 1.609344);
MPS = (fps * 0.3048);

EIMSK | = (1 << INT1) | (1 << INT0);      //
SEI();            volver a habilitar las interrupciones externas y las interrupciones globales
}

/************************************************************************/
/ * elegir opciones de salida * /
/************************************************************************/

Si (! () PIND & (1 << PIND6)) & & (PIND & (1 << PIND7))) //choose pies/seg.
{
Round(FPS);
resultado = fps;
}
else if (PIND & (1 << PIND6) & &! () PIND & (1 << PIND7))) //choose metros/seg.
{
Round(MPS);
resultado = mps;
}
else if (PIND & (1 << PIND6) & & (PIND & (1 << PIND7))) //choose kilómetros/hora
{
Round(kph);
resultado = kph;
}
otra cosa //default millas/hr
{
Round(mph);
resultado = mph;
}

Si (resultado > = 999) resultado = 999;







/************************************************************************/
/ * retardo detener múltiples "2ª interrupción" activa * /
/ * sin retrasar la ejecución de código principal * /
/************************************************************************/

resetcount ++;

Si ((resetcount > = 0x00FF) & & (interruptcount > = 2)) //resetcount límite determina el retardo de
{reset //before. 0x00FF aprox. 3 segundos
interruptcount = 0;
resetcount = 0;
}








/************************************************************************/
/ * Mostrar int resultado en pantalla de 3 dígitos siete segmentos * /
/ * retardo da siete segmento decodificador tiempo para decodificar y mostrar los dígitos * /
/************************************************************************/

Si (! () PINC & (1 << PINC5))) //to configuración de distancia de visualización en pantalla
{//only mientras se presiona el botón
resultado = distancia;
}
otra cosa

cientos = (resultado / 100);      Haz 100 lugar dígito
x = (resultado de 100%);
PORTB = (0x00|hundreds);
PORTC | = (1 << 2);        Escriba el dígito
_delay_ms(1);
PORTC & = (0 << 2);

decenas = (x / 10);        conseguir lugar de 10 dígitos
x = x % 10;
PORTB = (0x00|tens);
PORTC | = (1 << 1);        Escriba el dígito
_delay_ms(1);
PORTC & = (0 << 1);

unos = x;          obtener de 1 lugar dígito
PORTB = (0x00|ones);
PORTC | = (1 << 0);        Escriba el dígito
_delay_ms(1);
PORTC & = (0 << 0);

}
}

/************************************************************************/
/ * interrupción sensor 1 * /
/************************************************************************/
ISR(INT0_vect)
{
Si (interruptcount == 0)
{
TCNT1 = 0 X 0000;          reiniciar el contador a 0
interruptcount ++;         incremento interrupción cuenta
EIMSK & = (1 << INT1) | (0 << INT0);      desactivar INT0

}
else if (interruptcount == 1)
{
tiempo = TCNT1;          capturar el valor del contador
interruptcount ++;         incremento interrupción cuenta

}
Else resetcount = 0;

}

/************************************************************************/
/ * interrupción sensor 2 * /
/************************************************************************/
ISR(INT1_vect)
{
Si (interruptcount == 0)
{
TCNT1 = 0 X 0000;         reiniciar el contador a 0
interruptcount ++;        incremento interrupción cuenta
EIMSK & = (0 << INT1) | (1 << INT0);     desactivar la INT1

}
else if (interruptcount == 1)
{
tiempo = TCNT1;         capturar el valor del contador
interruptcount ++;        incremento interrupción cuenta

}
Else resetcount = 0;
}