Oficios Técnicos

www.sapiensman.com/tecnoficio


Información para el estudiante y el trabajador de oficios técnicos. 

 

 


 

  sapiensman.com/ESDictionary


WORK FROM HOME. Jobs, company reviews, advice.


 

APLICACIONES ELECTRÓNICAS

VÍDEOS : https://www.youtube.com/

1 - ARDUINO NANO

Juego de luces secuenciales con Arduino NANO

----------------------------- Sketch Arduino :

void setup() { //Iniciamos la función setup
pinMode (6,OUTPUT);
pinMode (7,OUTPUT);
pinMode (8,OUTPUT);

}

void loop() { //Inciamos la funcion loop
digitalWrite(6, HIGH); //Encendemos el led 6
delay (150);
digitalWrite(6, LOW); //Apagamos el led 6
delay (150);

digitalWrite(7, HIGH); //Encendemos el led 7
delay (150);
digitalWrite(7, LOW); //Apagamos el led 7
delay (150);

digitalWrite(8, HIGH); //Encendemos el led 8
delay (150);
digitalWrite(8, LOW); //Apagamos el led 8
delay (150);
}

2 - Juego de luces secuenciales con PIC12F675

Juego de luces secuenciales con 4 leds, para el gráfico de diseño son de color amarillo, el programa desarrollado con mikroC PRO, está cargado en un microcontrolador PIC12F675, al variar la posición del potenciómetro RV1, se varía la velocidad del juego de luces, dispone de un botón de RESET, para reiniciar el programa.

Abajo el circuito desarrollado en PROTEUS :

 

Proyecto en mikroC PRO for PIC :

 

int lectura = 0; // declaro una variable como entero
unsigned velo = 0;

void main() {
ANSEL = 1; // REGISTRO DE FUNC. ESPECIALES. SELECCIONO UNA ENTRADA ANALÓGICA ENTRE ANS3 ANS2 ANS1 ANS0. 1 Indica ANS0
CMCON=7; // REGISTRO DE FUNC. ESPECIALES. Comparator Control Register of the analog comparator. Bits to control the comparator
ADCON0 = 0; // ADCON0 es REGISTRO DE FUNC. ESPECIALES. Configuración A/D. Referencia de voltaje, o VDD o Vref,
TRISIO = 0;
GPIO = 1;
IOC =0;

while(1){
lectura = ADC_Read (0);

velo = lectura * 1.1;

if (lectura > 816) {
velo = 816;
}

GPIO.f1=1;
Vdelay_ms(velo);
GPIO.f2=1;
Vdelay_ms(velo);
GPIO.f4=1;
Vdelay_ms(velo);
GPIO.f5=1;
Vdelay_ms(velo);

GPIO=0;
Vdelay_ms(velo);

}}

El programa fue cargado al microcontrolador PIC12F675 con PICkit3 :

 

3 - Registro de desplazamiento 74HC595 con Arduino

Cómo usar el registro de desplazamiento 74HC595 con Arduino ?

En este proyecto vamos a hacer uso de uno de los  registros de desplazamiento mas populares, el 74HC595, y veremos cómo usarlo con Arduino y los beneficios de su interface.

Introducción

Normalmente, consideremos una pequeña aplicación donde se busca controlar 8 LEDs con la ayuda de un Arduino Nano (o cualquier microcontrolador). Esta aplicación, es sin embargo, muy básica y simple, requeriría del uso de 8 pines de entrada/salida de la placa Arduino, una para cada LED.

Pero consideremos ahora un proyecto un poco mas avanzado, donde sus requerimientos son los de controlar los mismos 8 LEDS y hacer a la vez otras cosas como, por ejemplo mostrar un mensaje o cualquier información en un Display LCD de 16x2 o hacer de interface de un dispositivo de Bluetooth para controlar los LEDs mediante un móvil inteligente !!.

Este tipo de proyectos de mayor envergadura consumirían un gran cantidad de sus pines I/O en su plaqueta Arduino y no habría suficiente cantidad restante para otros dispositivos adicionales.

Y aquí es donde el registro de desplazamiento viene a suplir estas carencias.

 

Qué es un registro de desplazamiento (Shift Register en Inglés) ?

Un registro de desplazamiento es básicamente un circuito integrado conversor serie a paralelo. El mismo toma una entrada serie a través de un único pin (aunque en realidad para el proyecto necesitamos 3 pines, lo que veremos después) y la convierte en una salida paralela de 8 bits, reduciendo así efectivamente el número de pines en uso entre el microcontrolador y los dispositivos de salida.

Existen también otros tipos de registros de desplazamiento como por ejemplo entrada serie y salida paralelo (es el que nos interesa), entrada serie y salida serie, entrada paralelo y salida serie y entrada paralelo y salida paralelo.

En este proyecto, usaremos el circuito integrado de registro de desplazamiento entrada serie y salida paralelo (Serial IN and Parallel OUT) llamado 74HC595.

Diagrama del circuito en Proteus,

Hacemos el ensayo previo de funcionamiento en Proteus con un Arduino Nano, que puede ser también con Arduino Uno,

A partir de la hoja de datos del 74HC595, tenemos los siguientes datos :

Nota: Hay varios fabricantes de 74HC595, y la convención de nombres para cada fabricante puede ser diferente. La imágenes de abajo corresponden a la hoja de datos provista por Texas Instruments.

Como se ve en el circuito, sólo se usan 3 pines del Arduino Nano que controlan 8 LEDs. Los tres pines necesarios son el 11 (entrada de reloj), 12 ( entrada de almacenamiento de registro de reloj) y 14 (entrada de datos). Todos los LEDs se polarizan con una resistencia de 220 Ω. Para mayor seguridad, se puede conectar una fuente separada de 5V, con tierra común para la alimentación de los LEDs.

En algún momento u otro, puede quedarse sin pines en su placa Arduino y necesitar ampliarla con registros de desplazamiento. Este ejemplo se basa en el 74HC595. La hoja de datos se refiere al 74HC595 como un "registro de desplazamiento de entrada en serie, salida en serie o en paralelo de 8 bits con latches de salida; de 3 estados". Tengamos en cuenta que los latches son dispositivos biestables asíncronos que no tienen entrada de reloj y cuyo cambio en los estados de salida es función del estado presente en las entradas y de los estados previos en las salidas (retroalimentación). En otras palabras, puede usarlo para controlar 8 salidas a la vez mientras solo ocupa unos pocos pines en su microcontrolador. Puede vincular varios registros para ampliar aún más su salida. (Los usuarios también pueden desear buscar otros chips controladores con "595" o "596" en sus listados de números de partes, hay muchos. El STP16C596, por ejemplo, puede activar 16 LEDs y elimina las resistencias en serie con los mismos haciendo uso de fuentes de corriente constante incorporadas).

Cómo funciona todo esto ?, es a través de algo llamado "comunicación serial síncrona", es decir, puede activar un pulso en un pin hacia arriba y hacia abajo, comunicando así un byte de datos al registro bit a bit. Es dando un pulso en el segundo pin, el pin del reloj (clock), que separa los bits. Esto contrasta con el uso de la "comunicación en serie asíncrona" de la función Serial.begin (), que depende de que el transmisor y el receptor se ajusten de forma independiente a una velocidad de datos especificada acordada. Una vez que el byte completo se transmite al registro, los estados HIGH o LOW contenidos en cada bit se distribuyen en cada uno de los pines de salida individuales. Esta es la parte de la "salida paralela", en la que todos los pines hacen lo que usted quiere que hagan todos a la vez.

La parte de "salida en serie" de este componente está disponible en su pin adicional que puede pasar la información en serie recibida del microcontrolador nuevamente sin cambios. Esto significa que puede transmitir 16 bits seguidos (2 bytes) y los primeros 8 se desplazarán a través del primer registro al segundo registro y se expresarán allí.

El término "3 estados" se refiere al hecho de que puede configurar los pines de salida como de alta, baja o "alta impedancia". A diferencia de los estados HIGH y LOW, no puede configurar los pines a su estado de alta impedancia individualmente. Solo puede configurar todo el chip. Esto es algo bastante especializado: piense en una matriz de LEDs que podría necesitar ser controlada por microcontroladores completamente diferentes dependiendo de una configuración de modo específica incorporada en su proyecto.

Para mayor información, obtener la hoja de datos (Data Sheet) donde se dispone de mayores detalles.

 

----------------------------- Sketch Arduino :

 

int latchPin = 5;
int clkPin = 6;
int dataPin = 4;

byte LED = 0;

void setup()
{
Serial.begin(9600);
pinMode(latchPin, OUTPUT);
pinMode(dataPin, OUTPUT);
pinMode(clkPin, OUTPUT);
}

void loop()
{
int i=0;
LED = 0;
shiftLED();
delay(400);
for (i = 0; i < 8; i++)
{
bitSet(LED, i);
Serial.println(LED);
shiftLED();
delay(500);
}
}

void shiftLED()
{
digitalWrite(latchPin, LOW);
shiftOut(dataPin, clkPin, MSBFIRST, LED);
digitalWrite(latchPin, HIGH);
}

Código en GitHub

Funcionamiento : Inicialmente, todos los LEDs estarán apagados, ya que la variable LED está en cero (byte LED = 0;), luego cada bit es puesto en 1 usando la función "bitSet" y es desplazada usando la función "shifOut" , por lo que se verá que los LEDs se encienden en esa secuencia. Si usted quiere apagar el LED, puede usar la función "bitClear".

Las aplicaciones para este diseño pueden ser :

  • Controles de LEDs
  • Conmutadores de red
  • Servidores
  • Infraestructura de potencia
  • Aplicaciones electrónicas
  • Simple uso de la conversión de datos serie a paralelo

 

Sintaxis

shiftOut (dataPin, clockPin, bitOrder, valor)

Parámetros

  • dataPin: el pin en el cual dar salida a cada bit. Tipos de datos permitidos: int.
  • clockPin: el pin a conmutar una vez que el dataPin se ha establecido al valor correcto. Tipos de datos permitidos: int.
  • bitOrder: en qué orden se desplazan los bits; puede ser MSBFIRST o LSBFIRST. (El bit más significativo primero, o el bit menos significativo primero).
  • valor: los datos a los que se van dar salida. Tipos de datos permitidos: byte.

// Notas: Código Arduino para usar un registro de desplazamiento 74HC595 //
// para contar de 0 a 255 //
//****************************************************************

//Pata conectada a ST_CP de 74HC595
int latchPin = 5;
//Pata conectada a SH_CP de 74HC595
int clockPin = 6;
////Pata conectada a DS de 74HC595
int dataPin = 4;

void setup() {
// hay que establecer las patas de salida porque están direccionados en el bucle principal
pinMode(latchPin, OUTPUT);
pinMode(clockPin, OUTPUT);
pinMode(dataPin, OUTPUT);

pinMode(10, OUTPUT);


}

void loop() {
// rutina de conteo ascendente

digitalWrite(10, HIGH); // enciende cada vez que se llega al fin del contador o se 255
delay(1000); // retardo de bucle
digitalWrite(10, LOW);


for (int j = 0; j < 256; j++) {

digitalWrite(latchPin, LOW); // pata de latchPin puesta a tierra y manténgala baja mientras esté transmitiendo

shiftOut(dataPin, clockPin, LSBFIRST, j);

digitalWrite(latchPin, HIGH);// retorna latchPin a valor alto para indicar al chip que
// ya no necesita recibir información


delay(100); // retardo de bucle
}

}

 

 

Mas proyectos : >> Siguiente >> | 2

 

 

Tus Compras en Línea. Libros. Informática. Automóvil. Indumentaria  ... VER PRODUCTOS >> : 0 - 1 - 2 - 3 - 4 - 5 - 6 - 7 - 8 - 9 - 10 - 11 - 12 - 13 - 14 - 15 - 16 - 17 - 18 - 19 - 20 - 21 - 22 - 23 - 24 - 25 - 26 - 27 - 28 - 29 - 30 - 31 - 32 - 33 - 34 - 35 - 36 - 37 - 38 - 39 - 40 - 41 - 42 - 43 - 44 - 45 - 46 - 47 - 48 - 49 - 50 - 51 - 52 - 53 - 54 - 55 - 56 - 57 - 58 - 59 - 60 - 61 - 62 - 63 - 64 - 65 - 66 - 67 - 68 - 69 - 70 - 71 - 72 - 73 - 74 - 75 - 76 - 77 - 78 - 79 - 80 - 81 - 82 - 83 - 84 - 85 - 86 - 87 - 88 - 89 - 90 - 91 - 92 - 93 - 94 - 95 - 96 - 97 - 98 - 99 - 100 - 101 - 102 - 103 - 104 - 105 - 106 - 107 - 108 - 109 - 110 - 111 - 112 - 113 - 114 - 115 - 116 - 117 - 118 - 119 - 120 - 121 - 122 - 123 - 124 - 125 - 126 - 127 - 128 - 129 - 130 - 131 - 132 - 133 - 134 - 135 - 136 - 137 - 138 - 139 - 140 - 141 - 142 - 143 - 144 - 145 - 146 - 147 - 148 - 149 - 150 - 151 - 152 - 153 - 154 - 155 - 156 - 157 - 158 - 159 - 160 - 161 - 162 - 163 - 164 - 165 - 166 - 167 - 168 - 169 - 170 - 171 - 172 - 173 - 174 - 175 - 176 - 177 - 178 - 179 - 180 - 181 - 182 - 183 - 184 - 185 - 186 - 187 - 188 - 189 - 190 - 191 - 192 - 193 - 194 - 195 - 196 - 197 - 198 - 199 - 200 - 201 - 202 - 203 - 204 -


 

 

 
Volver arriba

OTROS TEMAS RELACIONADOS :