MIKROC 6.0.0 FULL 1 LINK

Hola que tal amigos, les traigo de nuevo otro aporte que será el primero de muchos sobre este nuevo tema que son los microcontroladores, debido a que son el cerebro de todos nuestros proyectos y con ellos podemos desarrollar mejores y buenos proyectos para sorprender a todos.

Ventajas de usar microcontroladores:

*son muy comunes en el mercado y es muy fácil encontrarlos en cualquier tienda de electrónica sobre todo los fabricados por microchip.

*sustituyen a muchos dispositivos externos que solo ocuparían mayor espacio en nuestro circuito, como pueden ser las compuertas lógicas, los flip-flop, los adc y varios ic mas.

*los puedes conectar con diferentes tipos de dispositivos externos como pueden ser pantallas lcd, teclados, sensores, actuadores.

Bien para comenzar con los microcontroladores necesitamos un programa llamado mikroc pro for pic, este programa nos ayudara a realizar nuestros códigos con mayor facilidad debido a que los programaremos en c por ser más fácil de aprender y usar.

Aquí les dejo el link del programa full 

http://www.mediafire.com/download/vh4y18lch94nsg0/MikroC+Pro+for+PIC+2013.zip 

Nuestro primer programa será hacer parpadear un led con el pic 16f887.

Este es el código que debe de contener nuestro programa para que realice el cometido.

void main() {         //función principal

OSCCON=0b01110001;      //declaración del oscilador interno a 8mhz

while(OSCCON.HTS==0);   //espera mientras se estabiliza el oscilador

TRISA.F0=0;            //declaramos el pin 0 del puerto a como salida

PORTA.F0=0;            //damos una salida de 0 lógico al inicio del programa

while(1){             //bucle infinito

 RA0_bit=1;           //mandamos una salida de 1 lógico al pin RA0

 delay_ms(500);       //generamos un retardo de 500ms

 RA0_bit=0;           //mandamos una salida de 0 lógico al pin RA0

 delay_ms(500);       //generamos un retardo de 500ms

}

}

aqui les dejo un videotutorial de como realizar nuestro primer programa y simularlo en proteus:

no se olviden de comentar, saludos.

SEMAFORO CON 555 Y CONTADOR JOHNSON

HOLA QUE TAL, AQUI DE NUEVO CON OTRA ENTRADA A PETICION DE VARIAS PERSONAS SOBRE COMO HACER UN SEMAFORO SIMPLE.

BIEN EL CIRCUITO CONSTA DE UN 555 PARA ENVIAR LOS PULSOS A UN IC 4017 QUE ES UN CONTADOR JOHNSON DE DECADAS, POR CADA PULSO POSITIVO O EN ALTO QUE MANDE EL 555 EL CONTADOR CAMBIARA DE SALIDA LO UNICO ES QUE PARA CADA LED DEL SEMAFORO SE CONECTARA A VARIAS SALIDAS DEL CONTADOR PARA QUE SE MANTENGA POR UN TIEMPO ENCENDIDO.

MATERIALES:
1-NE555
1-CAP 100UF
1-CAP 1UF
2-RES 10K
4-RES 330 OHM
1-LED DE CUALQUIER COLOR PARA EL ESTADO DEL 555
1-LED ROJO
1-LED AMARILLO
1-LED VERDE
10-DIODOS 1N4001 O 1N4002

CIRCUITO SEMAFORO

NO OLVIDEN COMENTAR.

SALUDOS.

CONTADOR 9-0 FLIP FLOP J-K

HOLA COMUNIDAD AQUI DE NUEVO CON OTRO APORTE A PETICION DE UNA PERSONA,
LES TRAEGO EL CONTADOR DESCENDENTE DE 9-0 CON FLIP FLOP J-K EL DIAGRAMA ES ALGO PARECIDO AL ASCENDENTE ANTERIORMENTE POSTEADO AQUI PERO CON UNAS LIGERAS MODIFICACIONES EN LAS CONECCIONES Y CAMBIANDO LA COMPUERTA NAND DE 2 ENTRADAS POR UNA DE CUATRO O IGUAL SE PUEDE PONER 3 COMPUERTAS NAND DE 2 ENTRADAS SI NO SE CUENTA CON LA DE 4... BIEN SIN MAS POR EL MOMENTO LES DEJO EL DIAGRAMA DISFRUTENLO Y NO SE OLVIDEN DE COMENTAR.

CIRCUITO

CIRCUITO EN PROTO

 

LOS MATERIALES SON:
1- 74LS13 o 74LS20
2-74LS76
1-74LS47
7- RESISTENCIAS DE 330 OHM
1- DISPLAY DE 7 SEG DE ANODO COMUN

NOTA:
EN EL DIAGRAMA NO PUSE EL GENERADOR DE PULSOS PARA NO HACER MAS GRANDE EL DIAGRAMA PERO SE UTILIZARA EL MISMO POSTEADO EN EL CONTADOR ASCENDENTE DEL SIGUIENTE LINKhttp://shasky21.blogspot.mx/2011/06/contador-de-0-9-con-flipflop-jk.html
COMENTAR ES AGRADECER.

CONTADOR 9-0 FLIPFLOP D

hola amigos aqui les dejo un circuito que es un contador de 9 a 0 con flip flop D 

 MATERIALES:
1- 74LS00
2-74LS74
1-74LS47
1-DISPLAY DE 7 SEGMENTOS ANODO COMUN

NOTA:
PARA GENERAR LOS PULSOS DE RELOJ SE NECESITARAN LOS MATERIALES QUE ESTAN INDICADOS EN EL CONTADOR DE 0-9 POSTEADO AQUI MISMO.

COLAS DINAMICAS EN JAVA

HOLA AMIGOS AQUI DE NUEVO CON ESTE OTRO APORTE QUE SON LAS COLAS DINAMICAS EN JAVA QUE SON PARECIDAS A LA DE PILAS SOLO QUE EN ESTA SE VA ELIMINANDO DE ABAJO HACIA ARRIVA Y COMO ES DINAMICA SE PUEDEN CREAR CIENTOS DE DATOS SIN TOPE EL UNICO TOPE ES LA CAPACIDAD DE MEMORIA DE LA COMPU..... BUENO ES IGUAL SON 3 ARCHIVOS QUE SON LOS SIGUIENTES:

EL ARCHIVO NODOLISTACOLA:

///////////////GENERA NODOS PARA LISTAS DOBLES////////////////////

class NodoListaCola{
    ////3 campos
    Object info;
    NodoListaCola Izq;/////////////asi se declara para apuntar a un dato igual a ellos
    NodoListaCola Der;
   
    /////////////primer constructor/*/////////////////
    public NodoListaCola(Object Dato){
        this.info = Dato;
        this.Izq = null;
        this.Der = null;
    }
   
    /////////////////segundo constructor///////////////
    public NodoListaCola(NodoListaCola Izq, Object Dato){
        this.Izq = Izq;
        this.info = Dato;
        this.Der = null;
    }
}

EL ARCHIVO LISTACOLA:

///////////////////////////LISTA QUE MANIPULA A LOS PUNTEROSY METODOS /////////////

class ListaCola{
    //////PUNTEROS
    public NodoListaCola Primero,Ultimo,Nuevo,Aux,Pos,Ant;
   
    //////constructor
    public ListaCola(){
        Primero = Ultimo = Nuevo = Aux = Pos = Ant = null;
    }
    ////////////////////////INSERTAR COLA//////////
    public void insertarCola(Object dato){
        if(Primero==null){//////////1 caso(lista vacia)
        Primero = new NodoListaCola(dato);
        Ultimo = Primero;
        }
        else{
            Nuevo = new NodoListaCola(Ultimo, dato);
            Ultimo.Der = Nuevo;
            Ultimo = Nuevo;
        }despliegaListaCola();
    }
   
    ///////////////ELIMINAR COLA//////////////
    public void eliminarCola(){
        if(Primero==null){
            System.out.println ("lista vacia");
        }
        else{
        ///hacer cuatro casos
                if(Primero==Ultimo){//// 1 caso
                    Primero=Ultimo=null;
                }
                else {//2caso
                    Primero=Primero.Der;
                    Primero.Izq=null;
                }
           
        }despliegaListaCola();
    }
   
    ////////////////////DESPLEGAR LISTA DOBLE////////////////
    public  void despliegaListaCola(){
        Aux = Primero;
        System.out.println ("#########   LISTA COMPLETA   ###########");
        while (Aux != null) {
            System.out.println (Aux.info);
            Aux = Aux.Der;
        }
        System.out.println ("########################################");
    }



}

Y POR ULTIMO EL APPLISTACOLA:

import java.util.Scanner;
class AppListaCola{
    public static void main(String args[]){
        ListaCola lista = new ListaCola();
        Integer DatoB,DatoI;
        int opcion;
       
        //Inicializacion del teclado
        Scanner Teclado = new Scanner(System.in);
        do{
            System.out.println ("1) INSERTAR COLA");
            System.out.println ("2) ELIMINAR COLA");
            System.out.println ("3) DESPLEGAR LISTA");
            System.out.println ("4) SALIR");
            opcion = Teclado.nextInt();
            switch (opcion) {
                case 1: System.out.println ("Que dato quieres insertar en la Lista:  ");
                        DatoI = new Integer(Teclado.nextInt());
                        lista.insertarCola(DatoI);
                        break;
                case 2: lista.eliminarCola();
                        break;
                case 3: lista.despliegaListaCola();
                        break;
                case 4: System.out.println ("BYE....");
                        break;
                                   
                default :System.out.println ("\topcion no valida intenta de nuevo\n");
            }
        }while (opcion != 4);
    }
}

BUENO AMIGOS AQUI ESTAN LOS ARCHIVOS ESPERO Y LES GUSTEN COMENTEN...

PILAS DINAMICAS EN JAVA

AQUI LES TRAEGO UN NUEVO APORTE QUE SON LAS PILAS DINAMICAS EN JAVA A DIFERENCIA DE LAS ESTATICAS ESTAS NO TIENEN UN TOPE DE LLENADO POR LO CUAL PUEDEN CREAR CIENTOS DE DATOS E IGUAL DE ELIMINARLOS... BUENO ASI LES DEBEN DE QUEDAR LOS ARCHIVOS:

EL ARCHIVO NODOLISTAPILA:

///////////////GENERA NODOS PARA LISTAS DOBLES////////////////////

class NodoListaPila{
    ////3 campos
    Object info;
    NodoListaPila Izq;/////////////asi se declara para apuntar a un dato igual a ellos
    NodoListaPila Der;
   
    /////////////primer constructor/*/////////////////
    public NodoListaPila(Object Dato){
        this.info = Dato;
        this.Izq = null;
        this.Der = null;
    }
   
    /////////////////segundo constructor///////////////
    public NodoListaPila(NodoListaPila Izq, Object Dato){
        this.Izq = Izq;
        this.info = Dato;
        this.Der = null;
    }

}


EL OTRO ARCHIVO ES EL LISTAPILA:


///////////////////////////LISTA QUE MANIPULA A LOS PUNTEROSY METODOS /////////////

class ListaPila{
    //////PUNTEROS
    public NodoListaPila Primero,Ultimo,Nuevo,Aux,Pos,Ant;
  
    //////constructor
    public ListaPila(){
        Primero = Ultimo = Nuevo = Aux = Pos = Ant = null;
    }
    //////////////////PUSH////////////////
    public void insertarPush(Object dato){
        if(Primero==null){//////////1 caso(lista vacia)
        Primero = new NodoListaPila(dato);
        Ultimo = Primero;
        }
        else{
            Nuevo = new NodoListaPila(Ultimo, dato);
            Ultimo.Der = Nuevo;
            Ultimo = Nuevo;
        }despliegaListaPila();
    }

    ///////////////POP//////////////
    public void eliminarPop(){
        if(Primero==null){
            System.out.println ("lista vacia");
        }
        else{
        ///hacer cuatro casos
                if(Primero==Ultimo){//// 1 caso
                    Primero=Ultimo=null;
                }
                else {//2caso
                    Ultimo=Ultimo.Izq;
                    Ultimo.Der=null;
                }
          
        }despliegaListaPila();
    }
  
    ////////////////////DESPLEGAR LISTA DOBLE////////////////
    public  void despliegaListaPila(){
        Aux = Primero;
        System.out.println ("#########   LISTA COMPLETA   ###########");
        while (Aux != null) {
            System.out.println (Aux.info);
            Aux = Aux.Der;
        }
        System.out.println ("########################################");
    }
}


Y EL ULTIMO ARCHIVO APPLISTAPILA:

import java.util.Scanner;
class AppListaPila{
    public static void main(String args[]){
        ListaPila lista = new ListaPila();
        Integer DatoB,DatoI;
        int opcion;
       
        //Inicializacion del teclado
        Scanner Teclado = new Scanner(System.in);
        do{
            System.out.println ("1) PUSH");
            System.out.println ("2) POP");
            System.out.println ("3) DESPLEGAR LISTA");
            System.out.println ("4) SALIR");
            opcion = Teclado.nextInt();
            switch (opcion) {
                case 1: System.out.println ("Que dato quieres insertar en la Lista:  ");
                        DatoI = new Integer(Teclado.nextInt());
                        lista.insertarPush(DatoI);
                        break;
                case 2: lista.eliminarPop();
                        break;
                case 3: lista.despliegaListaPila();
                        break;
                case 4: System.out.println ("BYE....");
                        break;
                                   
                default :System.out.println ("\topcion no valida intenta de nuevo\n");
            }
        }while (opcion != 4);
    }
}

BUENO ESO ES TODO AMIGOS ESPERO Y LES SIRVA DE MUCHO....COMENTEN..

PILAS ESTATICAS EN JAVA

AQUI LES TENGO OTRO APORTE QUE NOS ENVIO NUESTRO AMIGO JUAN QUE SE TRATA DE LAS PILAS ESTATICAS EN JAVA BUENO NO LES DIGO MAS PORQUE EL CODIGO HABLA POR SI SOLO BUENO AQUI ESTA :

import java.util.Scanner;
  
public class Cola{
  
    public static int max = 5, tope = -1;
    public static int cola[]=new int[max];

    public static void main(String args[]){
        int DatoI;
        int opcion=0;
        Scanner Teclado = new Scanner(System.in);
        do{
            System.out.println ("///////////////////////");
            System.out.println ("Elige una opcion:");
            System.out.println ("1.Insertar dato");
            System.out.println ("2.Retirar dato");
            System.out.println ("3.Desplegar Pila");
            System.out.println ("4.Salir");
            opcion=Teclado.nextInt();
          
            switch(opcion){
                case 1: System.out.println ("Que dato deseas agregar:");
                        DatoI=Teclado.nextInt();
                        Push(DatoI);
                        System.out.print("\n");
                        break;
                case 2: Pop();
                        break;
                case 3: Desplegar();
                        break;              
            }  
          
        }while(opcion!=4);
    }    //Fin de Main
      
//---------- METODO PUSH (insertar dato) ------------------------------
  
    public static void Push(int DatoI){
        if(tope < max-1){
            tope++;
            cola[tope] = DatoI;
        }              
          
        else
            System.out.println ("\n¡¡Cola llena, no se puede agregar mas elementos!!\n");
    }//Fin del Metodo Push

//---------- METODO POP (retirar dato) --------------------------------
  
    public static void Pop(){
        if(tope > -1){
            System.out.println("Elemento que sale es: "+ cola[0]+"\n");
            for (int i = 0; i<tope; i++) {
                cola[i]=cola[(i+1)];
            }
        tope--;
        }
        else
        System.out.println("\n¡¡No hay mas elementos en cola!!\n");
    }//fin del Metodo POP  
      
//----------- Desplegar ----------------------------------------------

    public static void Desplegar(){
        System.out.println ("***** Elementos en Cola *****");
        for(int i=0; i<=tope; i++){
            System.out.print("\t"+cola[i]);
          
        }
        System.out.print("\n*****************************\n");
    }


}//fin de la clase Cola

AGRADESCANLE A JUAN POR EL APORTE....

MENU DE LISTAS LIGADAS DOBLES EN JAVA

ESTE ES LA TAREA DE PROGRAMACION JAVA DE MENU DE LISTAS LIGADAS DOBLES ESTOS SON LOS TRES ARCHIVOS QUE TIENEN QUE TENER:

EL 1° ARCHIVO SE LLAMARA NODOLISTAD ESTE ARCHIVO CONTIENE LOS CONSTRUCTORES DE LOS NODOS Y ASI QUEDATA EL PROGRAMA:

///////////////GENERA NODOS PARA LISTAS DOBLES////////////////////

class NodoListaD{
    ////3 campos
    Object info;
    NodoListaD Izq;/////////////asi se declara para apuntar a un dato igual a ellos
    NodoListaD Der;
   
    /////////////primer constructor/*/////////////////
    public NodoListaD(Object Dato){
        this.info = Dato;
        this.Izq = null;
        this.Der = null;
    }
   
    /////////////////segundo constructor///////////////
    public NodoListaD(NodoListaD Izq, Object Dato){
        this.Izq = Izq;
        this.info = Dato;
        this.Der = null;
    }
   
    //////////////////tercer constructor//////////////
    public NodoListaD(Object Dato, NodoListaD Der){
        this.Izq = null;
        this.info = Dato;
        this.Der = Der;
    }
   
    //////////////////cuarto constructor////////////////
    public  NodoListaD(NodoListaD Izq, Object Dato, NodoListaD Der){
        this.Izq = Izq;
        this.info = Dato;
        this.Der = Der;
    }
}

EL 2° ARCHIVO SE LLAMARA LISTAD ESTE ARCHIVO SON LAS FUNCIONES QUE CREARAN LOS NODOS CON LOS DIFERENTES CONSTRUCTORES:


///////////////////////////LISTA QUE MANIPULA A LOS PUNTEROSY METODOS /////////////

class ListaD{
    //////PUNTEROS
    public NodoListaD Primero,Ultimo,Nuevo,Aux,Pos,Ant;
   
    //////constructor
    public ListaD(){
        Primero = Ultimo = Nuevo = Aux = Pos = Ant = null;
    }
    ////////////////////////INSERTAR AL FRENTE//////////
    public void insertarAlFrente(Object dato){
        if(Primero==null){//////////1 caso(lista vacia)
        Primero = new NodoListaD(dato);
        Ultimo = Primero;
        }
        else{
            Nuevo = new NodoListaD(Ultimo, dato);
            Ultimo.Der = Nuevo;
            Ultimo = Nuevo;
        }despliegaLista();
    }
    ////////////////INSERTAR ATRAS//////////////
    public void insertarAtras(Object dato){
        if(Primero==null){
            Primero = new NodoListaD(dato);
            Ultimo = Primero;
        }
        else {
            Nuevo = new NodoListaD(dato,Primero);
            Primero.Izq=Nuevo;
            Primero = Nuevo;
        }despliegaLista();
    }
    /////////INSERTAR ANTES DE //////////
    public void insertarAntesDe(Object DatoB,Object DatoI){
        if(Primero==null){
            System.out.println ("lista vacia");
        }
        else{/////hay datos
            if(buscar(DatoB)== true){
                ///////EMPEZAR A REALIZAR EL METODO
                if(Aux==Primero){///caso 1
                Nuevo= new NodoListaD(DatoI,Primero);
                Primero.Izq = Nuevo;
                Primero=Nuevo;
                }
                else{//en caso de que no este al inicio de la lista
                    Nuevo = new NodoListaD(Ant,DatoI , Aux);
                    Aux.Izq = Nuevo;
                    Ant.Der=Nuevo;
                }
            }   
        }
        despliegaLista();
    }
    ////////////////INSERTAR     DESPUES DE///////////////
    public void insertarDespuesDe(Object DatoB, Object DatoI){
        if(Primero==null){
            System.out.println ("lista vacia");
        }
        else{///hay metodos
            if(buscar(DatoB)== true){
                //////EMPEZAR A REALIZAR EL METODO/////
                if(Aux==Ultimo){
                    Nuevo=new NodoListaD(Aux,DatoI);
                    Aux.Der=Nuevo;
                    Ultimo=Nuevo;
                }
                else{///en caso de que no este al inicio de la lista
                    Nuevo= new NodoListaD(Aux,DatoI,Aux.Der);
                    Aux.Der = Nuevo;
                    Pos = Aux.Der;
                    Pos.Izq =Aux.Der;
                }
               
            }
        }despliegaLista();
    }
    ///////////////METODO ELIMINAR NODO//////////////
    public void eliminarNodo(Object DatoB){
        if(Primero==null){
            System.out.println ("lista vacia");
        }
        else{
            if(buscar(DatoB)==true){///hacer cuatro casos
                if(Primero==Ultimo){//// 1 caso
                    Primero=Ultimo=null;
                }
                else if(Aux==Primero){//2caso
                    Primero=Aux.Der;
                    Primero.Izq=Aux=null;
                }
                else if(Aux==Ultimo){//3 caso
                    Ultimo=Ant;
                    Ultimo.Der=Aux=null;
                }
                else{//4 caso
                    Ant.Der=Pos;
                    Pos.Izq=Ant;
                    Aux=null;
                }
            }
        }despliegaLista();
    }
    /////////////METODO PARA SUSTITUIR DATO///////////////
    public void modificaLista(Object DatoB,Object DatoI){
        if(Primero==null){
            System.out.println ("lista vacia");
        }
        else{
            if(buscar(DatoB)==true){
                Aux.info=DatoI;
            }
        }despliegaLista();
    }
    //////////////////////////METODO BUSCAR/////////
    public boolean  buscar(Object DatoB){
        Aux = Primero;
        boolean bandera = false;
        while (Aux != null && bandera != true) {
            if(DatoB.equals(Aux.info)){// si encuentra el dato //la funcion .equals sirve para comparar el contenido de una direccion de memoria
                bandera = true;
            }
            else{//apunta al siguiente nodo
                Ant = Aux;
                Aux = Aux.Der;
                Pos = Aux.Der;
            }
        }
        if(bandera == true){
            return true;
        }
        else{
            System.out.println ("ese dato no existe");
            return false;
        }
    }
    ////////////////////DESPLEGAR LISTA DOBLE////////////////
    public  void despliegaLista(){
        Aux = Primero;
        System.out.println ("#########   LISTA COMPLETA   ###########");
        while (Aux != null) {
            System.out.println (Aux.info);
            Aux = Aux.Der;
        }
        System.out.println ("########################################");
    }
}


EL 3° ARCHIVO SE LLAMARA APPLISTAD ESTE ES EL MENU DE DONDE SE EJECUTARAN LAS FUNCIONES:



import java.util.Scanner;
class AppListaD{
    public static void main(String args[]){
        ListaD lista = new ListaD();
        Integer DatoB,DatoI;
        int opcion;
       
        //Inicializacion del teclado
        Scanner Teclado = new Scanner(System.in);
        do{
            System.out.println ("1) Insertar al frente");
            System.out.println ("2) Insertar al Atras");
            System.out.println ("3) Insertar Antes de");
            System.out.println ("4) Insertar Despues de");
            System.out.println ("5) Eliminar Dato");
            System.out.println ("6) Modificar Dato");
            System.out.println ("7) DesplegarLista");
            System.out.println ("8) Salir");
            opcion = Teclado.nextInt();
            switch (opcion) {
                case 1: System.out.println ("Que dato quieres insertar al frente de la Lista:  ");
                        DatoI = new Integer(Teclado.nextInt());
                        lista.insertarAlFrente(DatoI);
                        break;
                case 2: System.out.println ("Que dato quieres insertar Atras de la Lista:  ");
                        DatoI = new Integer(Teclado.nextInt());
                        lista.insertarAtras(DatoI);
                        break;
                case 3: System.out.println ("Que dato quieres insertar Antes de la Lista:  ");
                        DatoI = new Integer(Teclado.nextInt());
                        System.out.println ("Atras de que dato quieres insertar el :"+DatoI);
                        DatoB = new Integer(Teclado.nextInt());
                        lista.insertarAntesDe(DatoB,DatoI);
                        break;
                case 4: System.out.println ("Que dato quieres insertar Despues de la Lista:  ");
                        DatoI = new Integer(Teclado.nextInt());
                        System.out.println ("Despues de que dato quieres insertar el :"+DatoI);
                        DatoB = new Integer(Teclado.nextInt());
                        lista.insertarDespuesDe(DatoB,DatoI);
                        break;
                case 5: System.out.println ("Que dato quieres ELiminar de la Lista: ");
                        DatoB = new Integer(Teclado.nextInt());
                        lista.eliminarNodo(DatoB);
                        break;
                   case 6: System.out.println ("Que dato quieres buscar para sustituir: ");
                           DatoB = new Integer(Teclado.nextInt());
                           System.out.println ("Que dato quieres poner en el numero "+DatoB+":");
                           DatoI = new Integer(Teclado.nextInt());
                           lista.modificaLista(DatoB,DatoI);
                        break;
                   case 7: lista.despliegaLista();
                        break;
                case 8: System.out.println ("\tbye...\n");
                        break;                               
                default :System.out.println ("\topcion no valida intenta de nuevo\n");
            }
        }while (opcion != 8);
    }
}


BUENO AMIGOS COMENTEN PARA DECIR QUE LES PARESE ACEPTO NEGATIVAS, INSULTOS Y DEMAS AUNQUE LOS BORRARE PERO USTEDES COMENTEN HAHAHAHA AUNQUE SEA PARA AGRADECER......