Fuente de alimentacion de 12Voltios de más 18 amperios


Las fuentes de PC ATX se pueden usar como fuente de alimentación conmutada  de   bajo coste  y  alta corriente  cuando  nos interesen tensiones de 12v , 5v  o  3.3v . :por ejemplo si necesitamos  12 voltios  se podrían  conseguir en muchas fuentes de alimentación  convencionales según algunos   modelos  hasta 18 Amperios o más ,incluso, si necesitamos   una tensión de 5 voltios  !  se podrían lograr hasta 35 Amperios !

La mala noticia  es que algunos modelos de fuentes  de alimentación ATX   cuentan con una protección  que hacen  que se apaguen  automáticamente cuando se  sobrepasa el consumo de  1  amperio, pero ! ,simplemente añadiendo una resistencia de 110 ohmios 1/4 watio entre el pin de arranque (cable verde)  y un  cable  naranja (3.3V)   conseguiremos que no actue la proteccion .!

El estándar ATX (Advanced Technology Extended) se desarrolló como una evolución del factor de forma de Baby-AT siendo una de las características de las placas ATX mas importantes es el tipo de conector a la fuente de alimentación, el cual es de 24 (20+4) contactos que permiten una única forma de conexión y evitan errores como con las fuentes AT y otro conector adicional llamado P4, de 4 contactos.  Este tipo de fuente es el generalizado en los equipos actuales y como aspectos interesantes destacamos:

• Se incorpora la tensión de 3,3 voltios, usada por los dispositivos electrónicos modernos, la alimentación a la placa base se realiza mediante el conector P1.

• No es imprescindible el interruptor, el mando de encendido se realiza desde la placa base y hay una salida permanente de tensión de 5V para alimentar circuitos de
‘alerta’ en el equipo para permitir el arranque remoto, por llamada, etc.
•Dispone también de conectores ‘Molex’ y ‘Mini’ para discos duros, lectores, etc.

ATX 12V :igual a la ATX pero que además aporta un conector nuevo denominado P4 con tomas extras de +12 V(no todas las placas base incorporan el conector extra para 12 V denominado P4).

ATX 2.0:Como consecuencia de la aparición de los buses PCI Express, memorias DDR2, serial ATA, etc. la potencia demandada puede crecer, por esto se ha establecido una definición para las fuentes ATX, la 2.0 , que aumenta el número de pines de 20 a 24, permitiendo el incremento de corriente para las tensiones más usadas (3,3V, 5V y 12V), de modo  que permite añadir los 75 watios que pueden demandar las ampliaciones de tarjetas PCI Express.

En resumen :,de una fuente ATX ,ATX12  o ATX 2.0  se pueden sacar12v, 5v y 3.3v   variando la intensidad  máxima en función del tipo y versión  de esta

Los voltajes positivos sirven para:

• +12 V → Motores, reguladores de voltaje (para potencia alta)
• +5 V → Circuitos de los discos, SIMMs, tarjetas PCI/AGP, tarjetas ISA, reguladores de voltaje, otros chips
• +3.3 V → Chipset, DIMMs, tarjetas PCI/AGP, otros chips

Luego hay dos voltajes negativos, -5V y -12V. Ninguno de los dos se usa realmente para nada hoy en día, sino que se ponen por compatibilidad con hardware antiguo.

Parece ser que antiguamente los puertos serie usaban salidas +12V/-12V, pero hoy en día sólo funcionan con +3.3V o +5V.

También, algunos puertos LAN necesitaban esos -12V pues de hecho, había placas base con puertos LAN integrados que necesitaban ese voltaje.

Respecto a la línea de -5V, sólo es necesaria según las especificaciones del bus ISA, aunque, en realidad, muy pocas tarjetas ISA lo necesitan. Parece que los circuitos analógicos de separación de datos de viejas controladoras de disquetera la usaban.

Como norma general estos son los códigos de colores de los cables :

  •  Los cables AMARILLOS nos van a proporcionar los 12v.
  •  Los cables ROJOS nos van a proporcionar los 5v ).
  •  Los cables NARANJAS nos van a proporcionar 3.3v.
  •  Los cables NEGROS nos van a proporcionar la masa o tierra.
  • El cable verde, que es el que enciende la fuente de alimentación cuando está conectado a masa  o una resistencia de bajo valor .

Según todas las indicaciones  anteriores,para  nuestra  fuente de alimentación de 12V seguiremos los siguientes pasos:

  •  Uniremos los cables AMARILLOS que son los que nos  van a proporcionar los +12v.
  • Conectaremos  un cable NARANJA (3.3v)  por medio de una resistencia de 110 ohmios y lo uniremos al cable verde.
  •  Uniremos los cables NEGROS que nos van a proporcionar la masa o tierra.
  • El cable verde, que es el que enciende la fuente de alimentación,le conectaremos  una resistencia de 110 ohmios  junto con cualquier cable negro .

Y   a continuación éste  sería el esquema de conexiones partiendo del propio conector:

fuente de 12v

..
Con este artificio ,simplemente añadiendo una resistencia de 110ohmios entre el pin de arranque (cable verde)  y un  cable  naranja (3.3V)   conseguiremos que no actué la protección, consiguiendo el amperaje que indica la etiqueta de la fuente pudiendo usar esta fuente  para una infinidad de  situaciones(cargador de batería,para alimentar dispositivos diseñados para funcionar con baterias,etc)

NOTA: esta técnica  no funciona desgraciadamente ne fuentes ATX de reciente fabricación , por lo  que recomendamos usar varias funtes en paralelo para obtener los resultados esperados

En el caso de solo disponer de dos fuentes de alimentación   para obtener 12V en ,nuestro montaje  conectaríamos los cables amarillos de cada fuente  juntos  al igual que con los negros  y luego uniríamos  ambas salidas estos mediante un diodo Schottkyy de potencia ( o en su defecto uno de silicio de potencia)   .

Por ultimo para  que arranquen  a la vez ambas fuentes ,   conectaremos una pequeña resistencia (500 ohmios ) permanentemente  entre el  cable verde y cualquier negro de cada fuente

El  montaje   final   (que el autor ha probado con éxito para alimentar maquinaria  agrícola  que  se alimentaba con una batería de automóvil )   seria  el  siguiente:

fuentes en paralelo

(1)Los diodos son Schottky adecuados a la potencia que vaya circular( se pueden sustituir  por  diodos de potencia nornales en caso de no disponer de estos)

(2)Las resistencias son de 500ohmios 1/4W

(3)Adaptar la sección el cableado de salida   a  la potencia que vaya a circular

Por cierto, usando esta técnica de forma idéntica , se puede obtener una fuente  de 5V de alta corriente , en cuyo caso en el caso de solo disponer de dos fuentes de alimentación   en ,nuestro montaje  conectaríamos los  hilos rojos de cada fuente  juntos  al igual que los negros  y luego uniríamos estos mediante un diodo  Schottky de potencia ( o en su defecto uno de silicio de potencia)   .

Por ultimo,  para  que arranquen  a la vez ambas fuentes ,   conectaremos una pequeña resistencia (500 ohmios ) permanentemente  entre el  cable verde y cualquier negro de cada fuente.

Se puede ampliar información aqui

Anuncios

Cómo conectar un display LCD a tu Raspberry-Pi


En este post Mark Wiliams  nos muestra con  todo detalle   cómo conectar y utilizar un display de   16 x 2 LCD en modo 4 bits sobre una Raspberry Pi usando la  librería WiringPi que permite programar de forma fácil dispositivos externos.

El LCD  usando es un display  OLED azul (LCD) de 16 × 2 de adafruit basado en el clásico HD44780 de Hitachi ,el cual es un standard “de facto ” en cuanto a displays lcd alfanumericos.

Esta modelo de pantalla cuenta con ultra-alto contraste  ,mayor incluso que las clásicas pantallas LCD restroliluminadas, por lo que la legibilidad es excelente desde cualquier ángulo.

El LCD ,como  adelantaba utiliza el controlador HD44780 el cual  está presente en casi todas las pantallas LCD.Como es habitual en este tipo de displays que utilizan este controlador por lo general tienen 14 ó 16 pines. (En etse caso elLCD tiene 16, numerados del 0 al 16)
A veces, todos estos pines están presentes, pero alguno  no se utiliza,por ejemplo, los pines 15 y 16 son para back-light que en este modelo no se utilizan
PINES DEL HD44780  EN DETALLE
Pin 1 Ground.
Pin 2 Tensión de alimentación de OLED y la lógica
Pin 3 Por lo general está conectado a un potenciómetro para controlar el contraste de la pantalla.
Pin 4 La señal de selección de registro (RS) determina si los valores de los bits de datos se interpretan como una orden (la pantalla del claro ejemplo) o los datos (aka: un personaje para mostrar).
Pin 5 ¿La lectura / escritura pin. En el modo de lectura, este pin se utiliza para obtener información de la pantalla LCD para averiguar si la pantalla LCD se puede aceptar comandos o para indicar que está demasiado ocupado.
No necesitamos esta función podemos esperar el tiempo máximo de una orden que debe ser por escrito (200us) antes de enviar el siguiente comando.
Si la lectura está activada y Pin4 en la pantalla LCD está conectado a un pin en el Raspberry Pi, hay una posibilidad de que pueda destruir su Pi. Sólo quiero volver a escribir en el LCD, nunca queremos leer de él. Así que esto siempre debe estar conectado a tierra.
Pin 6 La patilla de habilitación (E) funciona como el comando / data enclavamiento de señales para la pantalla LCD. La pantalla LCD se enganchará en lo que está en los bits de datos y procesarlos en el flanco descendente de la señal E
Es decir, cuando este pin va de baja, la pantalla LCD se llevará a la entrada de los pines de datos en este momento.
Clavijas 7 y 14 Son los pines de datos. En el modo de pin 4, sólo se usan los pines 11 a 14.
Los contactos 15 y 16 Se utilizan para la luz de fondo si está presente.

Cableado del LCD   a tu Raspberry

A continuación se muestra cómo conectar el LCD a la Raspberry Pi. Vamos a utilizar el modo de pin 4, así que no hay necesidad de conectar los pines 7 a 10. Este LCD no utiliza los pines de luz de fondo, pines 15 y 16 . Asimismo,en el ejemplo tampoco se utiliza el pin de contraste, pin 3.

Código

En el pasado, usted habría tenido que conocer los registros utilizados por el controlador para configurar la pantalla, coloque el cursor o incluso escribir un carácter único.Hoy en día todo esto e ha simplifico muchísimo , que en el caso de la Raspberry gracias a la librería  WiringPi .

Instalación WiringPi;

@ raspberrypi pi ~ $ sudo apt-get update
@ raspberrypi pi ~ $ git clone git :/ / git.drogon.net / wiringPi
@ raspberrypi pi ~ $ cd wiringPi
@ raspberrypi pi ~ $ git pull origen
@ raspberrypi pi ~ $. / build

El código siguiente es un ejemplo muy simple de mostrar un poco de texto en la línea superior de la pantalla LCD. Hay una lista completa de todas las funciones de la biblioteca en el LCD WiringPi sitio web.

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
#include <wiringPi.h>           //WiringPi headers
#include <lcd.h>                //LCD headers from WiringPi
#include <stdio.h>              //Needed for the printf function below
//Pin numbers below are the WiringPi pin numbers
#define LCD_RS  3               //Register select pin
#define LCD_E   0               //Enable Pin
#define LCD_D4  6               //Data pin 4
#define LCD_D5  1               //Data pin 5
#define LCD_D6  5               //Data pin 6
#define LCD_D7  4               //Data pin 7
int main()
{
    int lcd;                //Handle for LCD
    wiringPiSetup();        //Initialise WiringPi
    //Initialise LCD(int rows, int cols, int bits, int rs, int enable, int d0, int d1, int d2, int d3, int d4, int d5, int d6, int d7)
    if (lcd = lcdInit (2, 16,4, LCD_RS, LCD_E ,LCD_D4 , LCD_D5, LCD_D6,LCD_D7,0,0,0,0)){
            printf ("lcdInit failed! \n");
            return -1 ;
    }
    lcdPosition(lcd,0,0);           //Position cursor on the first line in the first column
    lcdPuts(lcd, "Character LCD");  //Print the text on the LCD at the current cursor postion
    getchar();                      //Wait for key press
    lcdClear(lcd);                  //Clear the display
}
Lineas 1 y 2 se requieren ya que estos son los encabezados de la biblioteca LCD WiringPi.
Líneas 7 y 12 son las definiciones de los pines utilizados para conectar el LCD a la Raspberry Pi. Los números de pin se puede encontrar aquí.
Línea 21 sirve para  inicializar el LCD con LCDINIT ()
Los argumentos usados en la funcion lcdint() son:;
(int rows, int cols, int bits, int rs, int enable, int d0, int d1, int d2, int d3, int d4, int d5, int d6, int d7)
rows = Numero de filas del  LCD
cols = Numero de columnas del  LCD
bits = Numeros de bits usados como datos (   8 o 4).
rs = Pin de seleccion
enable =  pin activacion
d0-d7 = modo 8 o 4 bit modo. In modor 4 bit,solamente  usar  pins desde d0 a d3( como en todosl los displays HD44780). Si se utiliza el modo de 8 bits, es necesario especificar los pins del d0 a d7. En el código de ejemplo anterior, estamos utilizando el modo de 4 bits.El código siguiente es lo que se utiliza en el vídeo en la parte inferior de este post

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
205
206
207
208
209
210
211
212
213
214
215
#include <signal.h>
#include <stdlib.h>
#include <stdio.h>
#include <wiringPi.h>
#include <lcd.h>
#include <string.h>
#include <time.h>
char level0[8] = { 0b00000, 0b00000, 0b00000, 0b00000, 0b00000, 0b00000, 0b00000, 0b11111};
char level1[8] = { 0b00000, 0b00000, 0b00000, 0b00000, 0b00000, 0b00000, 0b11111, 0b11111};
char level2[8] = { 0b00000, 0b00000, 0b00000, 0b00000, 0b00000, 0b11111, 0b11111, 0b11111};
char level3[8] = { 0b00000, 0b00000, 0b00000, 0b00000, 0b11111, 0b11111, 0b11111, 0b11111};
char level4[8] = { 0b00000, 0b00000, 0b00000, 0b11111, 0b11111, 0b11111, 0b11111, 0b11111};
char level5[8] = { 0b00000, 0b00000, 0b11111, 0b11111, 0b11111, 0b11111, 0b11111, 0b11111};
char level6[8] = { 0b00000, 0b11111, 0b11111, 0b11111, 0b11111, 0b11111, 0b11111, 0b11111};
char level7[8] = { 0b11111, 0b11111, 0b11111, 0b11111, 0b11111, 0b11111, 0b11111, 0b11111};
#define COLUMNS 16
#define LCD_RS  3
#define LCD_E   0
#define LCD_D4  6
#define LCD_D5  1
#define LCD_D6  5
#define LCD_D7  4
void uptime(void);
void memory(void);
void volume(void);
void scrollText(void);
void INThandler(int sig);
int mymillis(void);
char message[] = "WWW.MARKS-SPACE.COM";
int count =0;
int j = 0;
FILE *uptime_file, *mem_file;
char *temp;
int lcd;
int main()
{
signal(SIGINT, INThandler);
wiringPiSetup () ;
if (lcd = lcdInit (2, 16,4, LCD_RS, LCD_E ,LCD_D4 , LCD_D5, LCD_D6,LCD_D7,0,0,0,0)){
printf ("lcdInit failed! \n");
return -1 ;
}
int uptimeTimer;
while(1){
lcdClear (lcd);
volume();
sleep(1);
memory();
sleep(4);
lcdClear (lcd);
uptimeTimer  = mymillis();
while ((mymillis() - uptimeTimer) < 5000)
uptime();
sleep(1);
lcdClear (lcd);
scrollText();
}
}
void uptime(void)
{
unsigned int uptime_unsorted = 0;
unsigned char c;
unsigned int DD;
unsigned int HH;
unsigned int MM;
unsigned int SS;
uptime_file=fopen("/proc/uptime","r");
if(NULL != uptime_file)
{
while((c=fgetc(uptime_file))!= '.')
{
unsigned int i;
i = atoi(&c);
uptime_unsorted = (uptime_unsorted * 10) + i;
}
SS = uptime_unsorted % 60;
MM = uptime_unsorted / 60 % 60;
HH = uptime_unsorted / 60 / 60 % 24;
DD = uptime_unsorted / 60 / 60 / 24;
printf("\x1B[2J");
printf("Uptime:D%i,%02i:%02i:%02i\n",DD,HH,MM,SS);
lcdPosition(lcd,0,0);
lcdPrintf(lcd,"Uptime:  Days %i", DD);
lcdPosition(lcd,4,1);
lcdPrintf(lcd,"%02i:%02i:%02i",HH,MM,SS);
}
else
{
printf("Open file \"proc/uptime\" failed!\n");
}
void memory(void)
{
char MemTotal[35];
char MemFree[35];
char total[35];
char free[35];
lcdClear (lcd);
mem_file=fopen("/proc/meminfo","r");
if(NULL != mem_file)
{
fscanf(mem_file,"%*s%s%*s", MemTotal);
fscanf(mem_file,"%*s%s%*s", MemFree);
printf("\x1B[2J");
lcdPosition(lcd,0,0);
lcdPrintf(lcd,"MemTotal-%sk",MemTotal);
lcdPosition(lcd,0,1);
lcdPrintf(lcd,"MemFree -%sk",MemFree);
fclose(mem_file);
}
else
{
printf("Open file \"/proc/meminfo\" failed!\n");
}
}
void volume(void)
{
//Defined custom characters for volume display
lcdCharDef  (lcd, 0, level0);
lcdCharDef  (lcd, 1, level1);
lcdCharDef  (lcd, 2, level2);
lcdCharDef  (lcd, 3, level3);
lcdCharDef  (lcd, 4, level4);
lcdCharDef  (lcd, 5, level5);
lcdCharDef  (lcd, 6, level6);
lcdCharDef  (lcd, 7, level7);
lcdClear (lcd);
int i;
lcdPosition (lcd, 9,1);
lcdPuts (lcd, ":Volume");
for (i = 0; i < 7; i++){
lcdPosition (lcd, i, 1);
lcdPutchar  (lcd, i);
usleep(400000);
}
}
void  scrollText(void)
{
int i,n;
int h ;
int tempSpace = 0;
char scrollPadding[] = "                   ";
int messageLength = strlen (scrollPadding)+strlen(message);
for (n=0;n<messageLength;n++){
h = COLUMNS;
usleep(300000);
printf("\x1B[2J");
if ( j > messageLength )
j = 0;
for (i = 0  ; i  < j ; i ++){
scrollPadding[h-j] = message[i];
h++;
}
lcdPosition(lcd,0,0);
lcdClear (lcd);
lcdPrintf(lcd,"%s",scrollPadding);
j++;
}
}
void  INThandler(int sig)
{
lcdClear (lcd);
fclose(uptime_file);
signal(sig, SIG_IGN);
exit(0);
}
int mymillis(void)
{
struct timeval tv;
gettimeofday(&tv, NULL);
return (tv.tv_sec) * 1000 + (tv.tv_usec)/1000;
}

Y por último en este vídeo podemos  ver el excelente rendimiento que ofrece este display con nuestro Raspberry Pi

Fuente  aquí