Afinador electrónico y cromático digital

   En musica, un afinador es un aparato electronico que indica mediante una señal visual (galvanómetro, LCD o LED) la diferencia en cents entre el sonido interpretado y la referencia absoluta que es la nota La 440. Algunos modelos pueden además generar las frecuencias deseadas, para servir de referencia al afinar.
El concertino, que da el la₃ para que afine la orquesta, utiliza previamente un afinador para ajustar su instrumento. También existen afinadores de tipo cromático, que son usados para afinar por notas naturales, sostenidos o bemoles.

Diferencia entre afinador de guitarra cromático y estándar

   Un afinador normal o estándar es aquel en el que el afinador tiene programadas las notas de la guitarra en su afinación correcta (E-B-G-D-A-E), y quizás también de alguna afinación alternativa. El funcionamiento de este afinador es el siguiente: si queremos afinar la 6ª cuerda (E) el afinador nos dirá cuando la toquemos cuan cerca o lejos estamos de la afinación correcta, ya sea por encima o por debajo de la nota. Normalmente hay una aguja digital o real que cuando la afinación es correcta se alinea con la letra de la nota. Si la cuerda que estamos afinando está muy desafinada y nos encontramos varios tonos por encima o por debajo de la nota, el afinador probablemente ni siquiera detectará a cuanto estamos de la afinación correcta. También es un problema cuando queremos utilizar una afinación distinta a la estándar.

   Por otro lado tenemos los afinadores cromáticos, que cumplen la misma función que el estándar pero que nos indican en todo momento la nota en la que está afinada la cuerda. Si quisiéramos seguir afinando la 6ª cuerda en Mi (E) y  la tuviéramos muy desafinada, por ejemplo en C# el afinador nos indicaría C# y conforme subiéramos iría indicando D, D# hasta llegar a E. Este afinador entonces afinar la guitarra con cualquier tipo de afinación alternativa ya que en todo momento visualizamos la nota en la que está la cuerda afinada, también sirve por ejemplo para otras tareas más especiales como el quintaje de la guitarra.

Cómo usar un afinador cromático digital

    Los afinadores cromáticos digitales automáticos suelen usarse mayormente para afinar guitarras eléctricas. Se llaman cromáticos porque los usuarios pueden afinar en las doce notas del sistema musical occidental (C, C#, D, D#, E, F, F#, G, G#, A, A#, B). Son automáticos por que no necesitan que se los ajuste en cada nota, automáticamente la reconocen y la muestran digitalmente. La ventaja de los afinadores cromáticos automáticos es que son muy fáciles de usar y tienen muchas opciones de afinación (afinaciones alternativas, caídas o abiertas, etc.).

Instrucciones:

1) 
Conecta la guitarra al afinador con el cable de 1/4 pulgada (5 mm). Enciende el afinador y sube al máximo el volumen de la guitarra. Si el afinador es un afinador con pedal, deberás pisarlo.

2) 
Fijate que el afinador esté calibrado a 440 hertz. La mayoría de los afinadores están automáticamente calibrados a A-440, y no se necesita ajustar nada. En caso de que tenga una perilla o un interruptor para A-440, lee las instrucciones del afinador para ver cómo se ajusta.

3) 
Fíjate que el afinador esté en modo "barrido". En caso de que se pueda seleccionar entre afinación de barrido o estroboscópica, coloca el afinador en modo de barrido (lee las instrucciones del afinador para saber cómo hacerlo.) Las luces del afinador se moverán despacio y podrás notar mejor los cambios.

4) 
Toca la sexta cuerda (la de sonido más grave o la cuerda "E" baja) con una púa. Aparecerá en el afinador el nombre (letra) de la nota.

5) 
Mueve la clavija correspondiente para que el tono suene más agudo si la nota está por debajo del tono correspondiente, o en un tono "bemol". Mientras muevas la clavija, escucharás que el sonido se va haciendo más agudo y verás que las luces del afinador se acercan al centro.

6) 
Si el tono está sonando por encima de la nota correspondiente o en un tono "sostenido", mueve la clavija para hacer el tono mas grave. Escucharas que el tono de la cuerda se hace más grave al mover la clavija.

7) 
Mueve la clavija para centrar el tono una vez que te estés aproximando al tono correcto. El afinador debería mostrar el nombre de la nota fija y las luces deberían estar en el centro. Ahora, la sexta cuerda está afinada.

8) 
Afina las cinco cuerdas restantes de la misma manera.

Proyecto de 3er Trimestre

   La temática principal del proyecto es el Tiempo. En el cual, tiene 3 requerimientos mínimos y fundamentales:

• Que tenga una salida a PC, en el cual se transmitan datos, de lectura o de escritura.
• Un LCD Alfanumérico.
• Que funcione a pila o a batería, lo cual debe consumir un mínimo, para mayor duración de la batería.

   Nuestro grupo propone la idea de un cronómetro, en el cual, en un renglón del LCD, me muestre el tiempo en minutos y segundos (con decimas de segundos), en caso de que yo apriete un botón, en el renglón de abajo del LCD me muestre cómo quedó el cronómetro en el momento de apretar el boton; mientras en el renglón de arriba siga corriendo el cronómetro. Otro botón en el cual yo paro el tiempo, si lo vuelvo a apretar, que continue desde ese momento. Y otro botón en donde reinicio de cero el cronómetro. También, mediante la PC, yo puedo programar un ciclo de tiempo, por ejemplo, si yo necesito que el crónometro me indique cuántas veces pasaron 12 segundos, que en un lado del LCD me lo indique con un número (12 segundos__1__, 24 segundos__2__, etc).

Lenguaje de programación C

C es un lenguaje de programación creado en 1972 por Dennis M. Ritchie en los Laboratorios Bell como evolución del anterior lenguaje B, a su vez basado en BCPL.

Caracteristicas:

Se trata de un lenguaje de tipos de datos estáticos, débilmente tipificado, de medio nivel pero con muchas características de bajo nivel. Dispone de las estructuras típicas de los lenguajes de alto nivel pero, a su vez, dispone de construcciones del lenguaje que permiten un control a muy bajo nivel. Los compiladores suelen ofrecer extensiones al lenguaje que posibilitan mezclar código en ensamblador con código C o acceder directamente a memoria o dispositivos periféricos.
La primera estandarización del lenguaje C fue en ANSI, con el estándar X3.159-1989. El lenguaje que define este estándar fue conocido vulgarmente como ANSI C. Posteriormente, en 1990, fue ratificado como estándar ISO (ISO/IEC 9899:1990). La adopción de este estándar es muy amplia por lo que, si los programas creados lo siguen, el código es portátil entre plataformas y/o arquitecturas.
 Una de las primeras diferencias que hay en el uso del lenguaje C con respecto al Assembler, es que es multiplataforma, puedo transportar el mismo programa a cualquier procesador sin tipo de esfuerzo extra.
 Optimizar: usar el menor recurso de memoria y tardar el menor tiempo en ejecutar.
 Cross-compilador: compilador que corren en una plataforma para luego bajarse en otra plataforma.
 Compilador: traduce un código escrito en un lenguaje de programación a otro lenguaje de programación.
 Por ejemplo: traducir un código fuente de un programa en lengüaje de alto nivel, a un lengüaje de nivel inferior.
Todas las librerias utilizadas en C terminan en ".h". Siempre tiene que haber un Main para saber cuál es el programa principal.

LCD

Una pantalla de cristal líquido o LCD (sigla del inglés liquid crystal display) es una pantalla delgada y plana formada por un número de píxeles en color o monocromos colocados delante de una fuente de luz o reflectora. A menudo se utiliza en dispositivos electrónicos de pilas, ya que utiliza cantidades muy pequeñas de energía eléctrica.

Configuración de 4 bits y 8 bits

El Bus de datos de un modulo LCD puede ser configurado para trabajar con 4 Bits y con 8 Bits. Para los diseños electrónicos que están limitados por la cantidad de líneas utilizadas en el Bus de datos, podrán utilizar un bus de datos con una longitud de 4 Bits; sin embargo si este no fuera su caso, podrá utilizar el bus de datos completo de 8 Bits. Las señales de control ( RS - R/W - E ) y los diagramas de tiempo explicados anteriormente, trabajan igual sea para un bus de datos de 4 Bits o de 8 Bits. Sin embargo, si usted esta interesado en trabajar el bus de datos con una longitud de 8 Bits, deberá saber que cuando se enciende el modulo LCD la configuración para 8 Bits entra por defecto; es decir que no necesitara programarse, pero la configuración del bus de datos con una longitud de 4 Bits requiere una secuencia cuidadosa de instrucciones previas inmediatamente después de encender el modulo LCD.
La longitud escogida para trabajar el bus de datos deberá hacerse en el principio de la programación del modulo LCD.

Disposición de los pines.

 Descripción de cada pin:

El Pin numero 1 y 2 están destinados para conectarle los 5 Voltios que requiere el modulo para su funcionamiento.
El Pin numero 3 es utilizado para ajustar el contraste de la pantalla; es decir colocar los caracteres mas oscuros o mas claros para poderse observar mejor.
El Pin numero 4: denominado "RS" trabaja paralelamente al Bus de datos del modulo LCD ( Bus de datos son los Pines del 7 al 14 ). Este bus es utilizado de dos maneras, ya que usted podrá colocar un dato que representa una instrucción o podrá colocar un dato que tan solo representa un símbolo o un carácter alfa numérico; pero para que el modulo LCD pueda entender la diferencia entre un dato o una instrucción se utiliza el Pin Numero 4 para tal fin.
Si el Pin numero 4 = 0 le dirá al modulo LCD que esta presente en el bus de datos una instrucción, por el contrario, si el Pin numero 4 = 1 le dirá al modulo LCD que esta presente un símbolo o un carácter alfa numérico.
El Pin numero 5: denominado "R/W" trabaja paralelamente al Bus de datos del modulo LCD ( Bus de datos son los Pines del 7 al 14 ). También es utilizado de dos maneras, ya que usted podrá decirle al modulo LCD que escriba en pantalla el dato que esta presente en el Bus; por otro lado también podrá leer que dato esta presente en el Bus.
Si el Pin numero 5 = 0 el modulo LCD escribe en pantalla el dato que esta presente el Bus; pero si el Pin numero 5 = 1 significa que usted necesita leer el dato que esta presente el bus del modulo LCD.
El Pin numero 6: denominado "E" que significa habilitación del modulo LCD tiene una finalidad básica: conectar y desconectar el modulo. Esta desconexión no estará referida al voltaje que le suministra la corriente al modulo; la desconexión significa tan solo que se hará caso omiso a todo lo que este presente en el bus de datos de dicho modulo LCD.
Los Pines desde el numero 7 hasta el numero 14 representan 8 líneas que se utilizan para colocar el dato que representa una instrucción para el modulo LCD o un carácter alfa numérico. El Bus de datos es de 8 Bits de longitud y el Bit menos significativo esta representado en el Pin numero 7, el Pin mas significativo esta representado en el Pin numero 14
Los Pines 15 y 16: estarán destinados para suministrar la corriente a la retroiluminación. Es importante conocer que no todos los módulos LCD disponen de retroiluminación aunque tenga los pines de conexión en el circuito impreso.

Conexión del LCD a un PIC16F84a

Actividades de programación

En este caso, el siguiente código generado en lenguaje Assembler, permite crear un juego de luces al colocar un 1 en la entrada.

;------------------------------------------------------------------------------------
    List        p=PIC16F84A
    INCLUDE        <p16F84A.inc>
    __CONFIG     _XT_OSC & _WDT_OFF & _CP_OFF & _PWRTE_ON
    ERRORLEVEL    -302
;------------------------------------------------------------------------------------
    ORG            0x000
    goto        Main
    ORG            0x004
      retfie
#DEFINE         bank1    bsf STATUS, RP0
#DEFINE         bank0    bcf STATUS, RP0
;------------------------------------------------------------------------------------
Main
        bank1
        clrf        TRISB
        movlw        0x1F
        movwf        TRISA
        bank0
        clrf        PORTB
;------------------------------------------------------------------------------------
Loop
        btfsc        PORTA, 0
        goto         Loop
        movlw        0xA0
        xorwf        PORTB, F
        movlw        0x05
        xorwf        PORTB, F
        goto        Loop
;-------------------------------------------------------------------------------------
  END   
 
  En esta actividad, podemos colocar un mensaje "Hola Mundo"  en un LCD de 16x2, en movimiento:

;--------------------------------------------------------------------------------------      
 ; ZONA DE DATOS

    LIST        P=16F84A
    INCLUDE     
    __CONFIG    _CP_OFF &  _WDT_OFF & _PWRTE_ON & _XT_OSC
    ERRORLEVEL      -302

    CBLOCK  0x0C
    ENDC

; ZONA DE CÓDIGOS

    ORG    0
Inicio
    call    LCD_Inicializa          
Principal
    movlw    Mensaje0              
    call    LCD_MensajeMovimiento
    goto    Principal              

; Mensajes ----------------------------------------------------------------------------

Mensajes
    addwf    PCL,F
Mensaje0                          
    DT                          
    DT HOLA MUNDO 
    DT                 , 0x0      
;---------------------------------------------------------------------------------------


   END
;---------------------------------------------------------------------------------------

 Estas son las librerías que se utilizaron (LCD y Retardos).



;-----------------------LIBRERÍAS--------------------------------------------------


    CBLOCK
    LCD_Dato
    LCD_GuardaDato
    LCD_GuardaTRISB
    LCD_Auxiliar1
    LCD_Auxiliar2
    ENDC

LCD_CaracteresPorLinea    EQU    .16          

#DEFINE  LCD_PinRS    PORTA,0
#DEFINE  LCD_PinRW    PORTA,1
#DEFINE  LCD_PinEnable    PORTA,2
#DEFINE  LCD_BusDatos    PORTB

; Subrutina LCD_Inicializa ------------------------------------------------------------

LCD_Inicializa
    bsf        STATUS,RP0              
    bcf        LCD_PinRS             
    bcf        LCD_PinEnable
    bcf        LCD_PinRW
    bcf        STATUS,RP0
    bcf        LCD_PinRW              
                                  
    bcf        LCD_PinEnable          
    bcf     LCD_PinRS              
    call    Retardo_20ms
    movlw    b'00110000' 
    call    LCD_EscribeLCD          
    call    Retardo_5ms 
    movlw    b'00110000' 
    call    LCD_EscribeLCD
    call    Retardo_200micros
    movlw    b'00110000' 
    call    LCD_EscribeLCD
    call    Retardo_20micros      
    movlw    b'00100000'              
    call    LCD_EscribeLCD
    call    Retardo_20micros      
 


    call    LCD_2Lineas4Bits5x7
    call    LCD_Borra            
    call    LCD_CursorOFF     
    call    LCD_CursorIncr         
    return

; Subrutina LCD_EscribeLCD -----------------------------------------------------------


LCD_EscribeLCD
    andlw    b'11110000'              
    movwf    LCD_Dato              
    movf    LCD_BusDatos,W          
    andlw    b'00001111'              
    iorwf    LCD_Dato,F             
                                 
    bsf        STATUS,RP0              
    movf    TRISB,W                  
    movlw    b'00001111'              
    andwf    PORTB,F                  
    bcf        STATUS,RP0             
;
    movf    LCD_Dato,W              
    movwf    LCD_BusDatos        
    bsf        LCD_PinEnable       
    bcf        LCD_PinEnable        
    bsf        STATUS,RP0            
    movf    LCD_GuardaTRISB,W     
    movwf    TRISB
    bcf        STATUS,RP0              
    return

; Subrutinas variadas para el control del módulo LCD -----------------------------------------

LCD_CursorIncr                      
    movlw    b'00000110'
    goto    LCD_EnviaComando

LCD_CursorOFF                     
    movlw    b'00001100'
    goto    LCD_EnviaComando

LCD_Borra                          
    movlw    b'00000001'              
    goto    LCD_EnviaComando
LCD_2Lineas4Bits5x7                  
    movlw    b'00101000'              
;    goto    LCD_EnviaComando      

; Subrutinas LCD_EnviaComando y LCD_Caracter ------------------------------------

LCD_EnviaComando
    bcf        LCD_PinRS             
    goto    LCD_Envia

LCD_Caracter
    bsf        LCD_PinRS              
    call    LCD_CodigoCGROM          

LCD_Envia
    movwf    LCD_GuardaDato          
    call    LCD_EscribeLCD          
    swapf    LCD_GuardaDato,W      
                                  
    call    LCD_EscribeLCD          
    btfss    LCD_PinRS              
    call    Retardo_2ms              
    call    Retardo_50micros
    return 

; Subrutina LCD_CodigoCGROM -----------------------------------------------------------


LCD_CodigoCGROM
    movwf    LCD_Dato              
LCD_EnheMinuscula                  
    sublw    'ñ'                   
    btfss    STATUS,Z
    goto    LCD_EnheMayuscula      
    movlw    b'11101110'             
    movwf    LCD_Dato
    goto    LCD_FinCGROM
LCD_EnheMayuscula
    movf    LCD_Dato,W              
    sublw    'Ñ'                  
    btfss    STATUS,Z
    goto    LCD_Grado             
    movlw    b'11101110'            
    movwf    LCD_Dato              
    goto    LCD_FinCGROM 
LCD_Grado
    movf    LCD_Dato,W             
    sublw    'º'                   
    btfss    STATUS,
    goto    LCD_FinCGROM         
    movlw    b'11011111'              
    movwf    LCD_Dato
LCD_FinCGROM
    movf    LCD_Dato,W              
    return





; Librería LCD_MENS.INC


    CBLOCK
    LCD_ApuntaCaracter              
                                  
                                 
    LCD_ValorCaracter             
    ENDC                         


; Subrutina LCD_MensajeMovimiento -----------------------------------------------------

    CBLOCK 
    LCD_CursorPosicion              
    ENDC                          

LCD_MensajeMovimiento
    movwf    LCD_ApuntaCaracter     
    movlw    Mensajes              
    subwf    LCD_ApuntaCaracter,F 
    decf    LCD_ApuntaCaracter,F  
LCD_PrimeraPosicion
    clrf    LCD_CursorPosicion   
    call    LCD_Borra             
LCD_VisualizaCaracter             
    movlw    LCD_CaracteresPorLinea 
    subwf    LCD_CursorPosicion,W
    btfss    STATUS,Z
    goto    LCD_NoEsFinalLinea
LCD_EsFinalLinea
    call    Retardo_200ms        
    call    Retardo_200ms
    movlw    LCD_CaracteresPorLinea-1
    subwf    LCD_ApuntaCaracter,F  
    goto    LCD_PrimeraPosicion       
LCD_NoEsFinalLinea                  
    movf    LCD_ApuntaCaracter,W
    call    Mensajes              
    movwf    LCD_ValorCaracter     
    movf    LCD_ValorCaracter,F      
    btfsc    STATUS,Z              
    goto    LCD_FinMovimiento      
LCD_NoUltimoCaracter2
    call    LCD_Caracter          
    incf    LCD_CursorPosicion,F  
                                  
    incf    LCD_ApuntaCaracter,F  
    goto    LCD_VisualizaCaracter  
LCD_FinMovimiento                  
    return                          
 

    CBLOCK
    R_ContA                      
    R_ContB
    R_ContC
    ENDC

; RETARDOS de 20 hasta 500 microsegundos ------------------------------------------------

Retardo_200micros              
    nop                          
    movlw    d'64'              
    goto    RetardoMicros      

Retardo_50micros              
    nop                          
    movlw    d'14'              
    goto    RetardoMicros      

Retardo_20micros              
    movlw    d'5'             

RetardoMicros
    movwf    R_ContA              
Rmicros_Bucle
    decfsz    R_ContA,F          
    goto    Rmicros_Bucle      
    return                      

; RETARDOS de 1 ms hasta 200 ms. --------------------------------------------------------
;
Retardo_200ms                 
    movlw    d'200'              
    goto    Retardos_ms          

Retardo_20ms                  
    movlw    d'20'              
    goto    Retardos_ms          

Retardo_5ms                      
    movlw    d'5'              
    goto    Retardos_ms          

Retardo_2ms                      
    movlw    d'2'              
    goto    Retardos_ms          

Retardos_ms
    movwf    R_ContB              
R1ms_BucleExterno
    movlw    d'249'              
    movwf    R_ContA             
R1ms_BucleInterno
    nop                          
    decfsz    R_ContA,F          
    goto    R1ms_BucleInterno  
    decfsz    R_ContB,F          
    goto    R1ms_BucleExterno   
    return                      


;---------------------------------------------------------------------------------

END         

 ;---------------------------------------------------------------------------------

En esta actividad, hicimos un temporizador de tiempo:


;--------------------------------------------------------

    List p=PIC16F84A
    Include <p16f84a.inc>
__Config    _XT_OSC    & _WDT_OFF & _PWRTE_ON & _CP_OFF       
    Errorlevel -302

;--------------------------------------------------------
#DEFINE bank0  bcf STATUS, RP0
#DEFINE bank1  bsf STATUS, RP0
    CBLOCK 0x0C
    contador
    ENDC

;--------------------------------------------------------

ORG     0x000
goto     Main
ORG      0x004
Retfie

;---------------------------------------------------------
Main
    bank1
    bsf    TRISA, RA4
    clrf    TRISB    ;TRISB---> Salida
    movlw    0x28    ;Dividiendo por 256 
    movwf    OPTION_REG    ;por RA4
    bcf    INTCON, T0IF
    bank0
    clrf    TMR0

;---------------------------------------------------------

Loop
    btfss    INTCON, T0IF
    goto    Loop

    bcf        INTCON, T0IF
    incf    contador, F
    movf     contador, F
    movwf    PORTB
    goto    Loop

;----------------------------------------------------------

END

;----------------------------------------------------------

En esta actividad, hicimos un timer:

;-----------------------------------------------------------------
;TIMER0_INT
;Mediante interrupciones contar cantidad de overfload del TMR0
;Mostrar esa cuenta en PORTB
;TMR0 como temporizador sin prescaler (frec_interna= fext = 4)
;==> fext / (4.64)
;-----------------------------------------------------------------

    List p=PIC16F84A
    Include <p16f84a.inc>
    __Config    _XT_OSC    & _WDT_OFF & _PWRTE_ON & _CP_OFF       
    Errorlevel -302

;-----------------------------------------------------------------
#DEFINE bank0  bcf STATUS, RP0
#DEFINE bank1  bsf STATUS, RP0
    CBLOCK 0x0C
    contador
    d1
    d2
    ENDC

;-----------------------------------------------------------------

    ORG     0x000
    goto     Main

    ORG      0x004
    bcf        INTCON,T0IF
    incf    contador,F
    movf    contador,W
    movwf    PORTB
    retfie

;-----------------------------------------------------------------
Main
    bank1
    clrf    TRISB    ;TRISB---> Salida
    movlw    b'00001000'   
    movwf    OPTION_REG
    movlw    0xA0
    movwf        INTCON
    bank0
    clrf    TMR0
    clrf    PORTA
    call    delay_200ms

;-----------------------------------------------------------------

Loop
    incf    PORTA,F
    movf    PORTA,W
    sublw    .10
    btfsc    STATUS,Z
    call    delay_200ms   
    goto    Loop


;-----------------------------------------------------------------

delay_200ms
    decfsz    d1,F
    goto    S-1
    decfsz    d2,F
    goto    S-3
    return
;-----------------------------------------------------------------

    END

;-----------------------------------------------------------------

Proyecto de Teslápolis: Caja Musical

   Para la feria de ciencias Teslápolis, decidimos presentar una caja musical con un villancico, para demostrar lo que se puede hacer en programación, tanto en Assembler como en C, y además es interesante para las personas que no tengan conocimientos en el campo de la electrónica y programación para que se den una cierta idea de lo que hacemos en la materia.
   El proyecto lo hicimos en base a investigación en internet.
 Para poder hacer proyecto, primero necesitamos el programa en el cual le vamos a colocar en nuestro PIC16F84A. Luego de haber investigado en internet, encontramos un programa (escrito tanto en Assembler como en C) para nuestro programa y de ejemplo muestra que a la salida (mediante un parlante) podremos escuchar un villancico de Navidad.
   Éste es el código:
 ;------------------------------------------------------
    include <p16f84A.inc>
    LIST P=PIC16F84A
    __CONFIG _CP_OFF & _WDT_OFF & _PWRTE_ON & _XT_OSC

    ERRORLEVEL    -302
;------------------------------------------------------
    ORG 0x00

    goto Main

    ORG 0x05
 CBLOCK     0x0C
    d1
    d2
    d3
    d4
 ENDC
    #DEFINE    bank1    bsf    STATUS,RP0
    #DEFINE bank0    bcf    STATUS,RP0
;-----------------------------------------------------------
Main
    bank1
    clrf    TRISB
    movlw    0x1F
    movwf    TRISA
    bank0
    goto NotasMus
;---------------------------------------------------------------
NotasMus
    call NotaRE
    call Delay4seg
    goto NotasMus

NotaDO
    movlw 0x01
    goto    $+1
    goto    $+1
    goto    $+1
    goto    $+1
    goto    $+1
    movwf PORTB
    movlw 0x00
    goto    $+1
    goto    $+1
    goto    $+1
    goto    $+1
    goto    $+1
    movwf PORTB
    return

NotaRE
    movlw 0x01
    goto    $+1
    goto    $+1
    goto    $+1
    goto    $+1
    nop
    movwf PORTB
    movlw 0x00
    goto    $+1
    goto    $+1
    goto    $+1
    goto    $+1
    nop
    movwf PORTB
    return

;Terminan las notas

Delay4seg
    movlw    0xB6
    movwf    d1
    movlw    0x99
    movwf    d2
    movlw    0x2C
    movwf    d3
Delay_0
     decfsz    d1, f
    goto    $+2
    decfsz    d2, f
    goto    $+2
    decfsz    d3, f
    goto    Delay_0

            ;1 cycle
    nop
;------------------------------------------------------
    END
;------------------------------------------------------

   Éste es el mismo código pero escrito en lenguaje C:
//-----------------------------------------------------
#include<16F84A.h>
#FUSES NOWDT                    //No Watch Dog Timer
#FUSES XT                       //Crystal osc <= 4mhz for PCM/PCH , 3mhz to 10 mhz for PCD
#FUSES NOPUT                    //No Power Up Timer
#FUSES NOPROTECT                //Code not protected from reading

#use delay(clock=4000000)
#use fast_io(A)

void pausa(void)
{
      output_low(PIN_B0);
      delay_ms(5);
      return;
}

//Equivalencia de notas musicales
void notaSol(void)
{
         Long Sol = 1000000/(393.1*2);
         output_high(PIN_B0);
         delay_us(Sol);
         output_low(PIN_B0);
         delay_us(Sol);
         return;
}

void notaDoH(void)
{
         long DoH = 1000000/(522*2);
         output_high(PIN_B0);
         delay_us(DoH);
         output_low(PIN_B0);
         delay_us(DoH);
         return;
}

void notaReH(void)
{
         long ReH = 1000000/(588*2);
         output_high(PIN_B0);
         delay_us(ReH);
         output_low(PIN_B0);
         delay_us(ReH);
         return;
}

void notaMiH(void)
{
         long MiH = 1000000/(660*2);
         output_high(PIN_B0);
         delay_us(MiH);
         output_low(PIN_B0);
         delay_us(MiH);
         return;
}

void notaLa(void)
{
         long La = 1000000/(439.9*2);
         output_high(PIN_B0);
         delay_us(La);
         output_low(PIN_B0);
         delay_us(La);
         return;
}

void notaSi(void)
{
         long Si = 1000000/(494.0*2);
         output_high(PIN_B0);
         delay_us(Si);
         output_low(PIN_B0);
         delay_us(Si);
         return;
}

void notaFaH(void)
{
         long FaH = 1000000/(698*2);
         output_high(PIN_B0);
         delay_us(FaH);
         output_low(PIN_B0);
         delay_us(FaH);
         return;
}

void main()
{

   set_tris_b(0b00000000); //RB0 como salida, los demás como entrada
   int i,j; // Contadores
   output_b(0x00); //Limpiamos PORTB
   while(TRUE)
   {
      if(INPUT(PIN_B1))
      {
      for (i=0;i<131;i++)
         {
         notaSol();
         }
      pausa();
      for (i=0;i<174;i++)
         {
         notaDoH();
         }
      pausa();
      for (i=0;i<87;i++)
         {
         notaDoH();
         }
      pausa();
      for (i=0;i<98;i++)
         {
         notaReH();
         }
      pausa();
      for (i=0;i<87;i++)
         {
         notaDoH();
         }       
      pausa();
      for (i=0;i<82;i++)
         {
         notaSi();
         } 
      pausa();
      for (i=0;i<147;i++)
         {
         notaLa();
         } 
      pausa();
      for (i=0;i<147;i++)
         {
         notaLa();
         } 
      pausa();
      for (i=0;i<147;i++)
         {
         notaLa();
         }
      pausa();
      for (i=0;i<196;i++)
         {
         notaReH();
         }
      pausa();
      for (i=0;i<98;i++)
         {
         notaReH();
         }
      pausa();
      for (i=0;i<110;i++)
         {
         notaMiH();
         }
      pausa();
      for (i=0;i<98;i++)
         {
         notaReH();
         }
      pausa();
      for (i=0;i<87;i++)
         {
         notaDoH();
         }   
      pausa();
      for (i=0;i<164;i++)
         {
         notaSi();
         }
      pausa();
      for (i=0;i<131;i++)
         {
         notaSol();
        }
      pausa();
      for (i=0;i<131;i++)
         {
         notaSol();
         }
      pausa();
      for (i=0;i<220;i++)
         {
         notaMiH();
         } 
      pausa();
      for (i=0;i<110;i++)
         {
         notaMiH();
         }
      pausa();
      for (i=0;i<116;i++)
         {
         notaFaH();
         }
      pausa();
      for (i=0;i<110;i++)
         {
         notaMiH();
         }
      pausa();
      for (i=0;i<98;i++)
         {
         notaReH();
         }
      pausa();
      for (i=0;i<174;i++)
         {
         notaDoH();
         }
      pausa();
      for (i=0;i<147;i++)
         {
         notaLa();
         }
      pausa();
      for (i=0;i<65;i++)
         {
         notaSol();
         }
      pausa();
      for (i=0;i<65;i++)
         {
         notaSol();
         }
      pausa();
      for (i=0;i<147;i++)
         {
         notaLa();
         }
      pausa();
      for (i=0;i<196;i++)
         {
         notaReH();
         }
      pausa();
      for (i=0;i<165;i++)
         {
         notaSi();
         }
      pausa();
      for(j=0;j<2;j++)
         {
         for (i=0;i<174;i++)
            {
            notaDoH();
            }
         }
      output_low(PIN_B0);
      delay_ms(1000);
      }
   }
}

   Luego hicimos la simulación en Proteus para verificar que el programa funcione correctamente.

   Éste sería el resultado en práctica con un protoboard, el inconveniente que hubo fue que la melodía se escuchaba a muy bajo volumen, eso se puede arreglar (no ocurre en todos los casos).

Actividad Nº4: Amplificadores Operacionales

 Introducción teórica:
    
   Los Amplificadores Operacionales (AO) son circuitos integrados que contienen varias etapas transistorizadas acopladas todas ellas en continua con el objetivo de lograr una altísima ganancia de tensión.
Por su gran versatilidad, quizás éstos sean los circuitos integrados analógicos de baja señal más usados hoy día como interfases de entrada al mundo digital.

Experiencia Nº1: Amplificador Inversor

1 - Armar prolijo el circuito del amplificador inversor, mostrado en la siguiente figura:

2) Dibujar el circuito esquemático en el KiCad. En J1 ubicar el Jumper.

   Luego de haber realizado el circuito en el protoboard, respetando el gráfico de arriba, y haber puesto el nodo VS a GND para verificar el correcto conexionado y que el amplificador no este quemado, se procede a las mediciones

Experiencia Nº2: Amplificador No Inversor y Buffer

1) Armar el siguiente circuito:

 

5 - Diseñar el PCB (No hacer) de tal manera que reuna dos requisitos: 1) sea de dimensiones inferiores a 60 mm x 60 mm y 2) que tanto las conexiones de alimentación como la entrada Vs y la salida Vo, coincidan perfectamente para su inserción en el protoboard mediante pines rectos.

Actividad de la fecha 27/8/13

La siguiente línea de codigos (escrito en lenguaje Assembler) nos podrá permitir escribir "Hola Mundo" en una pantalla LCD de 16 caracteres.
;---------------------------------------------------------------------------
    List        p=PIC16F84A
    INCLUDE        <p16F84A.inc>
    __CONFIG _WDT_OFF & _CP_OFF & _XT_OSC & _PWRTE_ON
    ERRORLEVEL -302

    CBLOCK    0X0C
    ENDC
;-------------------------------------------------------------------
    ORG        0x000
Inicio
    call    LCD_Inicializa
    movlw    'H'
    call    LCD_Caracter
    movlw    'o'
    call    LCD_Caracter
    movlw    'l'
    call    LCD_Caracter
    movlw    'a'
    call    LCD_Caracter
    movlw    .1
    call    LCD_Caracter
    movlw    'M'
    call    LCD_Caracter
    movlw    'u'
    call    LCD_Caracter
    movlw    'n'
    call    LCD_Caracter
    movlw    'd'
    call    LCD_Caracter
    movlw    'o'
    call    LCD_Caracter

    sleep                   
;------------------------------------------------------------------
    INCLUDE <LCD_4BIT.inc>    ;Subrutinas de control del módulo LCD
    INCLUDE    <RETARDOS.inc>    ;Subrutnas de retardo
;------------------------------------------------------------------
    END
;------------------------------------------------------------------

Para que el programa funcione como muestra el ejemplo, debemos obtener previamente las librerías "LCD_4BIT.inc" y "RETARDOS.inc", ya que estas librerias contienen subrutinas en la cual facilitan la habilitación y la escritura del código, estas librerías se encuentran en el libro, se pueden obtener de internet. Esta no es la única manera de escritura para poder escribir en un LCD, hay otro método más sencillo y además se puede escribir en el lenguaje C.

Actividad N°5: Programación Elemental

Manejo de PORTS
Ejercicio 1
Por el Puerto B se obtiene el dato de las cinco líneas del Puerto A al que está conectado un array de interruptores. Por ejemplo, si por el Puerto A se introduce "---11001", por el Puerto B aparecerá "xxx11001" (el valor de las tres líneas superiores no importa).

;---------------------------------------------------------------


    List p=PIC16F84A
    Include <p16f84a.inc>
    __Config    _XT_OSC    & _WDT_OFF & _PWRTE_ON & _CP_OFF      
    ERRORLEVEL -302
   
;---------------------------------------------------------------  
 
#DEFINE bank0  bcf STATUS, RP0
#DEFINE bank1  bsf STATUS, RP0

;---------------------------------------------------------------
    ORG        0x000
    goto    Main
   
    ORG        0x004
    retfie
   
;---------------------------------------------------------------  

Main

    bank1
    clrf    TRISB
    movlw    0x1F
    movwf    TRISA
    bank0
    clrf    PORTB
   
;---------------------------------------------------------------  
   
Loop
    movf    PORTA, W
    movwf    PORTB
    goto Loop
;---------------------------------------------------------------
END 



Funciones Matemáticas
Ejercicio 2
Por el Puerto B se obtiene el dato de las cinco líneas del Puerto A, al que está conectado un array de interruptores, sumándole el valor de una constante, por ejemplo 74.
Es decir: (PORTB)=(PORTA)+Constante

;---------------------------------------------------------------


    List p=PIC16F84A
    Include <p16f84a.inc>
    __Config    _XT_OSC    & _WDT_OFF & _PWRTE_ON & _CP_OFF       
    ERRORLEVEL -302
   
;---------------------------------------------------------------   
   
#DEFINE bank0  bcf STATUS, RP0
#DEFINE bank1  bsf STATUS, RP0

;---------------------------------------------------------------
    ORG        0x000
    goto    Main
   
    ORG        0x004
    retfie
   
;---------------------------------------------------------------   

Main

    bank1
    clrf    TRISB
    movlw    0x1F
    movwf    TRISA
    bank0
    clrf    PORTB
   
;---------------------------------------------------------------   
   
Loop
    movf    PORTA, W
    addlw    .74
    movwf    PORTB
    goto Loop
;---------------------------------------------------------------
    END

Ejercicio 3
Por el Puerto B se obtiene el dato del Puerto A multiplicado por 2.
Es decir: (PORTB)=2(PORTA)=(PORTA)+(PORT A).

;---------------------------------------------------------------


    List p=PIC16F84A
    Include <p16f84a.inc>
    __Config    _XT_OSC    & _WDT_OFF & _PWRTE_ON & _CP_OFF      
    ERRORLEVEL -302
  
;---------------------------------------------------------------  
  
#DEFINE bank0  bcf STATUS, RP0
#DEFINE bank1  bsf STATUS, RP0

;---------------------------------------------------------------
    ORG        0x000
    goto    Main
  
    ORG        0x004
    retfie
  
;---------------------------------------------------------------  

Main

    bank1
    clrf    TRISB
    movlw    0x1F
    movwf    TRISA
    bank0
    clrf    PORTB
  
;---------------------------------------------------------------  
  
Loop
    movf    PORTA, W
    addwf    PORTA, W
    movwf    PORTB
    goto Loop
;---------------------------------------------------------------
    END


Máscaras
Ejercicio 4
Por el Puerto B obtiene el dato del Puerto A, pero en la salida los bits pares se fijan siempre a "1". El orden de los bits será "b7 b6 b5 b4 b3 b2 b1 b0", siendo los pares el b6, b4, b2 y el b0.
Por ejemplo, si por el Puerto A se introduce el dato b'---01100', por el Puerto B se visualiza  b'01011101'. Observar que los bits pares están a "1" (efectivamente: Puerto B = b'x1x1x1x1') y los impares permanecen con el dato del puerto de entrada (efectivamente: Puerto A = b'---x1x0x' y Puerto B = b'xxxx1x0x').

;---------------------------------------------------------------


    List p=PIC16F84A
    Include <p16f84a.inc>
    __Config    _XT_OSC    & _WDT_OFF & _PWRTE_ON & _CP_OFF      
    ERRORLEVEL -302
  
;---------------------------------------------------------------  
  
#DEFINE bank0  bcf STATUS, RP0
#DEFINE bank1  bsf STATUS, RP0

;---------------------------------------------------------------
    ORG        0x000
    goto    Main
  
    ORG        0x004
    retfie
  
;---------------------------------------------------------------  

Main
    bank1
    clrf    TRISB
    movlw    0x1F
    movwf    TRISA
    bank0
Loop
    movf    PORTA,W
    iorlw    0x55
    movwf    PORTB
    goto    Loop;---------------------------------------------------------------
    END
Ejercicio 5 
Por el Puerto B obtiene el dato del Puerto A, pero en las salida los bits impares se fijan siempre a "0". El orden de los bits será "b7 b6 b5 b4 b3 b2 b1 b0", siendo los impares el b7, b5, b3 y b1.
Por ejemplo si por el Puerto A se introduce el dato b'---01100', por el Puerto B se visualiza  b'00000100'. Observar que los bits impares están a "0" (efectivamente: Puerto B = b'0x0x0x0x') y los pares permanecen con el dato del puerto de entrada (efectivamente: Puerto A = b'---0x1x0' y Puerto B = b'---0x1x0').

 ;-----------------------------------------------------------------------------------------------------------
    LIST        p=PIC16F84A
    INCLUDE    <p16F84A.inc>
    __CONFIG    _XT_OSC & _WDT_OFF & _CP_OFF & _PWRTE_ON
    ERRORLEVEL    -302
;-----------------------------------------------------------------------------------------------------------
    ORG        0x000
    goto    Main
    ORG        0x004
    retfie
;-----------------------------------------------------------------------------------------------------------
;Definiciones
;-----------------------------------------------------------------------------------------------------------
#DEFINE    bank0    bcf    STATUS,RP0
#DEFINE    bank1    bsf    STATUS,RP0
;-----------------------------------------------------------------------------------------------------------
Main
    bank1
    clrf    TRISB
    movlw    0x1F
    movwf    TRISA
    bank0
Loop
    movf    PORTA,W
    andlw    0x55
    movwf    PORTB
    goto    Loop  
;-----------------------------------------------------------------------------------------------------------
    END

Ejercicio 6
Por el Puerto B se obtiene el dato del Puerto A invirtiendo los bits pares. Los impares se dejan como en la entrada. El orden de los bits será "b7 b6 b5 b4 b3 b2 b1 b0", siendo los pares el b6, b4, b2 y el b0.
Por ejemplo, si por el Puerto A se introduce "---11001", por el Puerto B aparecerá "xxx01100".  Observar que los bits pares están invertidos (efectivamente: Puerto A = "---1x0x1" y Puerto B = "xxxx0x1x0") y en los impares permanece el dato del puerto de entrada (efectivamente: Puerto A = "---x1x0x' y Puerto B = b'xxxx1x0x').  

 ;-----------------------------------------------------------------------------------------------------------
    LIST        p=PIC16F84A
    INCLUDE    <P16F84A.INC>
    __CONFIG    _XT_OSC & _CP_OFF & _WDT_OFF & _PWRTE_ON
    ERRORLEVEL    -302
;-----------------------------------------------------------------------------------------------------------
    ORG    0X000
    goto    Main
    ORG    0x004
    retfie
;-----------------------------------------------------------------------------------------------------------
;Definiciones
;-----------------------------------------------------------------------------------------------------------
#DEFINE    bank0    bcf    STATUS,RP0
#DEFINE    bank1    bsf    STATUS,RP0
;-----------------------------------------------------------------------------------------------------------
Main
    bank1
    clrf    TRISB
    movlw    0x1F
    movwf    TRISA
    bank0
Loop
    movf    PORTA,W
    xorlw    0x55
    movwf    PORTB
    goto    Loop
  
;-----------------------------------------------------------------------------------------------------------
    END

Ejercicio 7
Por el Puerto B se obtiene el dato del Puerto A invertidos los unos y ceros. Por ejemplo, si por el Puerto A se introduce "---11001", por el Puerto B aparecerá "xxx00110" (no importa el estado de los tres bits superiores del Puerto B).

 ;-----------------------------------------------------------------------------------------------------------
    LIST        p=PIC16F84A
    INCLUDE    <P16F84A.INC>
    __CONFIG    _XT_OSC & _CP_OFF & _WDT_OFF & _PWRTE_ON
    ERRORLEVEL    -302
;-----------------------------------------------------------------------------------------------------------
    ORG    0X000
    goto    Main
    ORG    0x004
    retfie
;-----------------------------------------------------------------------------------------------------------
;Definiciones
;-----------------------------------------------------------------------------------------------------------
#DEFINE    bank0    bcf    STATUS,RP0
#DEFINE    bank1    bsf    STATUS,RP0
;-----------------------------------------------------------------------------------------------------------
Main
    bank1
    clrf    TRISB
    movlw    0x1F
    movwf    TRISA
    bank0
Loop
    movf    PORTA,F
    comf    PORTA,W
    movwf    PORTB
    goto    Loop
   
;-----------------------------------------------------------------------------------------------------------
    END

Ejercicio 8
Por el Puerto B obtiene el dato del Puerto A intercambiando los nibbles alto y bajo. Por ejemplo, si por el Puerto A se introduce "---11001" por el Puerto B aparecerá "1001xxx1".

 ;-----------------------------------------------------------------------------------------------------------
    LIST        p=PIC16F84A
    INCLUDE    <P16F84A.INC>
    __CONFIG    _XT_OSC & _CP_OFF & _WDT_OFF & _PWRTE_ON
    ERRORLEVEL    -302
;-----------------------------------------------------------------------------------------------------------
    ORG    0X000
    goto    Main
    ORG    0x004
    retfie
;-----------------------------------------------------------------------------------------------------------
;Definiciones
;-----------------------------------------------------------------------------------------------------------
#DEFINE    bank0    bcf    STATUS,RP0
#DEFINE    bank1    bsf    STATUS,RP0
;-----------------------------------------------------------------------------------------------------------
Main
    bank1
    clrf    TRISB
    movlw    0x1F
    movwf    TRISA
    bank0
Loop
    movf    PORTA,F
    swapf    PORTA,W
    movwf    PORTB
    goto    Loop
  
;-----------------------------------------------------------------------------------------------------------
    END