/* PROGRAMA QUE USA: ADC 10 bits e INTERRUPCION EXTERNA!

* VALERIE CALA
* ESTADO: FUNCIONA
*/
//**********************Declaracion constantes********************************//
void adc_confi();
unsigned int uso_adc();
unsigned char entrada=1,i;
void secuencia_loop();
//*********************configuracion interrupcion
externa***************************//
ISR(INT0_vect){
secuencia_interrupcion();
}
//*************configuracin puertos*****************************************//
void setup() {
adc_confi();
Serial.begin(9600);
PORTD = 0b11111111; // entrada de pulsador
DDRD = 0b00000000;
PORTA = 0b11111111; //salidas display 7 segmentos
DDRA = 0b11111111;
EICRA = 0x00; // interrupciones
EIMSK = (1<<0);
sei();
}

void loop() {
 unsigned int conversion;
conversion=uso_adc();
Serial.println(conversion);

//secuencia();
if (conversion<=409){
PORTA=0b00111111;
}
else if(conversion<=819){
PORTA=0b00000000;
}
else{
secuencia();
}
}

void secuencia(){ //secuencia principal es lo que estara haciendo el loop

cuando no haya interrupciones o apagados forzados
unsigned char entrada;
char i;
unsigned char
secu[]={0b00111111,0b00000110,0b01011011,0b01001111,0b01001111,0b0
1100110,0b01101101,0b01111101,0b00000111,0b011111111,0b01101111};//
0,1,2,3,4,5,6,7,8,9
entrada = PIND&0x01;//lee si se esta presionando
for(i=0; i<11; i++){
PORTA = secu[i];
delay(1000);
}
}
void secuencia_interrupcion(){
unsigned char
secu1[]={0b00111001,0b01110111,0b00111000,0b01110111};//
INTERRUPCION QUE DICE: CALA
for(i=0; i<4; i++){
PORTA = secu1[i];
delay(70000);// se puso el tiempo lento para visualizar bien la interrupcion
}
}
void secuencia_loop(){
unsigned char
secu2[]={0b01111111,0b00110000,0b00111001,0b01110110,0b00111111};//
INTERRUPCION QUE DICE: bicho
for(i=0; i<5; i++){
PORTA = secu2[i];
delay(70000);// se puso el tiempo lento para visualizar bien la interrupcion
}
}
//******************configuracion ADC*****************************//
void adc_confi(void){
ADMUX=0b01000001; //canal adc 1
ADCSRA=0b10000111;
ADCSRB=0b00000000;
}
//***********************USO DEL ADC********************************//
unsigned int uso_adc(void){
byte izq,der;
unsigned int result;

ADCSRA=ADCSRA|0b01000000;
while ((ADCSRA&0b01000000)!=0){};
 der=ADCL; // asignar a derecha el valor de ADCL
izq=ADCH; // asignar a izquiera el valor de ADCH
result=izq<<8|der; // resultado lectura de los bits en adch y adcl
return (result);

}
//////////////////// fin programa///////////////////////////
// interrupciones externas
//prueba Valerie Cala
// leds encendidos
volatile unsigned char pulser1;
volatile unsigned char pulser2;
void ini_interrup1(void);
ISR(INT1_vect){
pulser1=1;
PORTA=0x00;
}
ISR(INT0_vect){
PORTA=0xFF;
}
void setup() {
PORTA=0b00000111; // salidas para hacer secuencia 1,2,3
DDRA=0b11111111;
PORTD=0b00000011; // pulsadores: pulsador 1 hace 3,2,1//pulsador2 apaga
DDRD=0b00000000;
sei();// habilita la interrupciones
ini_interrup1();

}
void ini_interrup1(void){
EICRA=0b00001010;// se selecciona el flanco por que cual se activa cada
pulsador
EIMSK=0b00000011; // se habilitar el puerto int1 e int o
}
void loop() {
pulser1=0;
while(pulser1==0){
secuencia ();
}
}
void secuencia (){
PORTA=0b00000100;
delay(1000);
PORTA=0b00000010;
delay(1000);
PORTA=0b00000001;
delay(1000);
}
////////////////////////////////////fin programa/////////////////////////////
/* intento de programacion ADC
*Valerie Cala
*adc de 8 bits que enciende todos los leds si v=255, apaga todos si
v<127, si v>127&<255 led=101.
*ESTADO: funciona
*/
//***************** DECLARACION DE FUNCIONES*****************************
#define ADC3D 1
void confuracion_ADC(void);
unsigned int lectura_ADC(void);
void setup() {
 confuracion_ADC();
Serial.begin (9600);
PORTL=0b00000000;
DDRL=0b11111111;
}
void loop() {
unsigned char evaluacion_voltaje=0;
// mostrar el adc omeee!!!!
evaluacion_voltaje=lectura_ADC();
Serial.println(evaluacion_voltaje);
delay(100);
if(evaluacion_voltaje==255){
PORTL=0b00000111;
}
else if (evaluacion_voltaje<=127){
PORTL=0b00000000;
}
else{
PORTL=0b00000101;
}
}
void confuracion_ADC(void){
ADMUX=0b10100011; // voltaje ref 1.1v- justificado a la izquierda y seleccion
de canal ADC 3
ADCSRB=0b00000000; //free runing
ADCSRA=0b10000100; // habilita el adc y selecciona factor de division 16
}
unsigned int lectura_ADC(void){
ADCSRA=ADCSRA|0b01000000;
while((ADCSRA&0b01000000)!=0){};
 return (ADCH);
}
////////////////////////////////fin programa/////////////////////////////
/* intento de programacion ADC
*Valerie Cala
*adc de 8 bits con voltaje de 1.1
*ESTADO: funciona
//***************** DECLARACION DE FUNCIONES*****************************
#define ADC3D 1
void confuracion_ADC(void);
unsigned int lectura_ADC(void);
void setup() {
confuracion_ADC();
Serial.begin (9600);
}
void loop() {
unsigned char evaluacion_voltaje=0;
// mostrar el adc omeee!!!!
evaluacion_voltaje=lectura_ADC();
Serial.println(evaluacion_voltaje);
delay(100);
}
void confuracion_ADC(void){
ADMUX=0b10100011; // voltaje ref 1.1v- justificado a la izquierda y seleccion
de canal ADC 3
ADCSRB=0b00000000; //free runing
ADCSRA=0b10000100; // habilita el adc y selecciona factor de division 16
}
unsigned int lectura_ADC(void){
ADCSRA=ADCSRA|0b01000000;
 while((ADCSRA&0b01000000)!=0){};
return (ADCH);
}
///////////////////////////FIN PROGRAMA//////////////////////
/* realizar timer que Ejecute una interrupcion cada 5mili segundos.
* VALERIE CALA
* ESTADO: FUNCIONA
*/
void retardo (unsigned int miliseg);
volatile unsigned int cuenta;
ISR(TIMER0_COMPA_vect){
cuenta=cuenta+1;
}
void setup() {
sei();
PORTA=0b11111111;
DDRA=0b11111111;
}
void loop() {
PORTA=0b00000011;
retardo(500);
PORTA=0b00000000;
retardo(500);
}

void retardo(unsigned int miliseg){

cuenta=0;
TCNT0=0;
OCR0A=249;
TIMSK0|=(1<<OCIE0A);
 TCCR0A=(1<<COM0A1)|(1<<WGM01);
TCCR0B=(1<<CS01)|(1<<CS00);
while (cuenta!=miliseg){};
TCCR0B=0;
}
////////////////FIN PROGRAMA//////////////////
/* realizar timer que jecute una interrupcion cada 5mili segundos.
* VALERIE CALA
* ESTADO: FUNCIONA
*/
void retardo (unsigned int miliseg);
volatile unsigned int cuenta;

ISR(TIMER0_COMPA_vect){
cuenta=cuenta+1;
}

void setup() {
sei();
PORTA=0b11111111;
DDRA=0b11111111;

void loop() {

PORTA=0b00000011;
retardo(500);
 PORTA=0b00000000;
retardo(500);
}
void retardo(unsigned int miliseg){
cuenta=0;
TCNT0=0;
OCR0A=249;
TIMSK0|=(1<<OCIE0A);
TCCR0A=(1<<COM0A1)|(1<<WGM01);
TCCR0B=(1<<CS01)|(1<<CS00);
while (cuenta!=miliseg){};
TCCR0B=0;
}
//////////////////////FIN PROGRAMA////////////////////////
/* SEAL SENOSOIDAL
* VALERIE CALA
* ESTADO: REGULAR
* NO SE HA ANEXADO FILTRO PASABAJO
*/

volatile unsigned int n_comp;

volatile byte pos;
volatile int j=0;
volatile double vector[100];
void tiempo(byte m_segundos);
void pwm(double pos);
void funcion_sen(void);

ISR(TIMER0_COMPA_vect)
{
 n_comp=n_comp+1;
if(n_comp == 49){
pwm(vector[j]);
j++;
}
// Esta rutina se ejecuta cada que transcurren 10us, e incrementa en uno (1)
el valor de la variable n_comp
}
// ------------------------------- PROTOTIPOS DE FUNCION
-------------------------------------------------------
void setup() {
funcion_sen();
sei(); // Se habilitan las interrupciones
PORTB=0xFF;
DDRB=0xFF;
Serial.begin(9600);
}
//------------------------------ RUTINA PRINCIPAL
--------------------------------------------------------
void loop() {
tiempo(1);
Serial.println(n_comp);
/* for(byte i=0; i<100; i++){
pos=vector[i];
pwm(pos);
tiempo(1);
}*/}
// --------------------------- RUTINA PARA RETARDO de 'm' milisegundos
--------------------------------
void tiempo(byte m_segundos)
{
 // Esta rutina progrma el TIMER0 para que ejecute una interrupcion por
comparacion cada que transcurren 10us, en ella se incrementa en uno (1) el
valor de la variable n_comp
// luego espera a que el valor de n_comp coincida con el valor "m_segundos",
antes de retornar al flujo normal del programa.
n_comp=0; // Inicializamos la bandera de conteo en 0, esta se incrementara
en uno (1) cada que transcuran 10us (mediante la rutina de interrupcion)
TCNT0=0; // Inicializamos la cuenta en 0
OCR0A =99; // Utilizando un cristal de 16 MHz y el preescalador de 256, con
este valor de OCR se producira una interrupcion por comparacion cada 50
microsegundos
TIMSK0 |= (1<<1); // habilitamos las interrupciones del timer por
comparacion
TCCR0A = (1<<6)|(1<<1); // Configuramos el TIMER0 en modo CTC (Cler
Timer on Compare), con el pin OC0A activado en modo Toggle y OC0B
desconectado
TCCR0B=0b00000010; // Configuramos un preescalador de 8, esto tomando
en cuenta que se empleara un cristal externo de 16MHz

while(n_comp!= m_segundos){};
TCCR0B=0; // Detenemos el reloj del contador
}
void pwm(double pos){
TCNT2=0; // cuenta en 0
OCR2A=pos; // se asigna el valor el cual ira cambiando
TCCR2A=0b10000011;// clear on comparation y fast pwm
TCCR2B=0b00000001;// no se usa prescalador!!
}
void funcion_sen(void){
for (int i=0;i<100;i++){
vector[i]= i*2*3.1416/100;
vector[i]= sin(vector[i]);
vector[i]=vector[i]+1;
vector[i]=vector[i]/2;
 vector[i]=vector[i]*255;

}
}
///////////////////////////FIN PROGRAMA////////////////////////
/* SEAL SENOSOIDAL
* VALERIE CALA
* ESTADO: FUNCIONA
* NO SE HA ANEXADO FILTRO PASABAJO
*/
//-------------------------------------- DEFINICION DE CONSTANTES
--------------------------------------------------------
#define WGM1 1
#define CS00 0
#define OCIE0A 1
#define COM0A0 6
//-------------------------------------- DEFINICION DE VARIABLES GLOBALES
--------------------------------------------------------
volatile unsigned int n_comp;
volatile byte pos;
volatile int i=0;
volatile double vector[100];

// ---------------- RUTINA DE SERVICIO DE INTERUPCION ISR POR COMPARACION

TIMER0 -------------------------------------
ISR(TIMER0_COMPA_vect)
{
n_comp=n_comp+1; // Esta rutina se ejecuta cada que transcurren 10us, e
incrementa en uno (1) el valor de la variable n_comp
}
// ------------------------------- PROTOTIPOS DE FUNCION
-------------------------------------------------------
void tiempo(byte m_segundos);
void pwm(double pos);
void funcion_sen(void);
// ----------------------- RUTINA DE CONFIGURACION
------------------------------------------------------
void setup() {
sei();
PORTB=0xFF;
DDRB=0xFF;
}

//------------------------------ RUTINA PRINCIPAL

--------------------------------------------------------
void loop() {

funcion_sen();
for(byte i=0; i<100; i++){
pos=vector[i];
pwm(pos);
tiempo(1);
}
}
// --------------------------- RUTINA PARA RETARDO de 'm' milisegundos
--------------------------------
void tiempo(byte m_segundos)
{
// Esta rutina progrma el TIMER0 para que ejecute una interrupcion por
comparacion cada que transcurren 10us, en ella se incrementa en uno (1) el
valor de la variable n_comp
// luego espera a que el valor de n_comp coincida con el valor "m_segundos",
antes de retornar al flujo normal del programa.
 n_comp=0; // Inicializamos la bandera de conteo en 0, esta se incrementara
en uno (1) cada que transcuran 10us (mediante la rutina de interrupcion)
TCNT0=0; // Inicializamos la cuenta en 0
OCR0A = 249; // Utilizando un cristal de 16 MHz y el preescalador de 256, con
este valor de OCR se producira una interrupcion por comparacion cada 2ms
TIMSK0 |= (1<<OCIE0A); // habilitamos las interrupciones del timer por
comparacion
TCCR0A = (1<<COM0A0)|(1<<WGM1); // Configuramos el TIMER0 en modo
CTC (Cler Timer on Compare), con el pin OC0A activado en modo Toggle y OC0B
desconectado
TCCR0B=0b00000101; // Configuramos un preescalador de 256, esto
tomando en cuenta que se empleara un cristal externo de 16MHz

while(n_comp!= m_segundos){};
TCCR0B=0; // Detenemos el reloj del contador
}
void pwm(double pos){
TCNT2=0;
OCR2A=pos;
TCCR2A=0b10000011;
TCCR2B=0b00000001;
}
void funcion_sen(void){
for (int i=0;i<100;i++){
vector[i]= i*2*3.1416/100;
vector[i]= sin(vector[i]);
vector[i]=vector[i]+1;
vector[i]=vector[i]/2;
vector[i]=vector[i]*255;

} }
////////////////////////FIN PROGRAMA///////////////////////
 /*PROGRAMA QUE INTERRUPMPE UNA SECUENCIA PARA MOSTRAR EL
NUMERO 6
* VALERIE CALA
* ESTADO: FUNCIONA
*/
unsigned char entrada=1,i;
ISR(INT0_vect){
PORTA = 0b01111101; //interrupcion en numero 6
delay(4000);
}
void setup() {
PORTD = 0b11111111; // entrada de pulsador
DDRD = 0b00000000;
PORTA = 0b11111111; //salidas display 7 segmentos
DDRA = 0b11111111;
EICRA = 0x00;
EIMSK = (1<<0);
sei();
}
void loop() {
secuencia();
}
void secuencia(){
unsigned char entrada;
char i;
unsigned char
secu[]={0b00111111,0b00000110,0b01011011,0b01001111,0b01001111,0b0
1100110,0b01101101,0b01111101,0b00000111,0b011111111,0b01101111};//
0,1,2,3,4,5,6,7,8,9
entrada = PIND&0x01;//lee si se esta presionando
 for(i=0; i<11; i++){
PORTA = secu[i];
delay(500);
}
}
////////////////////////FIN PROGRAMA///////////////////////////