Boton de apagado para OPENELEC- Raspberry-pi

Hola.. cuanto tiempo!! En esta ocasión os presento una adaptación de un circuito muy simple para poder apagar la raspberry-pi de forma ordenada, sin que se corrompan los discos, con OPENELEC.




El esquema es el siguiente: 

Esquema

Luego nos faltan dos archivos. El primero es el script en python que hace un pool al GPIO4 cada segundo. Por lo tanto hay que pulsar por más de un segundo hasta que se apague.

Ambos archivos se ubican en /storage/.config/
El primer archivo se llama softshut.py

# Import the modules to send commands to the system and access GPIO pins
#from subprocess import call
import os
import sys
import time
sys.path.append('/storage/.kodi/addons/python.RPi.GPIO/lib')
import RPi.GPIO as gpio

gpio.setmode(gpio.BOARD) # Set pin numbering to board numbering
gpio.setup(7, gpio.IN) # Set up pin 7 as an input

while True:
    time.sleep(1)
    if(gpio.input(7)):
             os.system("echo 0 >/sys/class/leds/led1/brightness")
             os.system("halt")
       
El otro es autostart.sh que si no existe lo creais. Sirve para lanzar el script anterior al inicio.

(
python /storage/.config/softshut.py
)&

Mas info sobre autostart aqui: http://wiki.openelec.tv/index.php/Autostart.sh

Foto de como queda

Funcionamiento:

Antes de desconectar pulsar por un segundo. Veremos que los leds parpadean hasta que quedan fijos. en ese momento es seguro apagar.

Basado en:
http://www.raspberry-pi-geek.com/Archive/2013/01/Adding-an-On-Off-switch-to-your-Raspberry-Pi

Coche barato, radio cara. Adaptador PWM servo a motor 2/2

Hola.

Lo prometido es deuda, asi que aqui tenemos la segunda parte de este proyecto.

En este vídeo podeis ver cómo es el control de la aceleración del coche, que antes era encendido/apagado y ahora acelera más cuanto más movemos la palanca:

El programa está hecho en CCS y es muy simple. Se divide en dos partes: 1) la lectura del pulso del servo a través del puerto B y 2) la generación de PWM proporcinal a la velocidad, a través del puerto A y B. 1) Lectura del pulso del servo. Esta parte es la más crítica ya que hemos de leer con precisión los pulsos que irían a un servo y convertirlo en una numeración. Para eso usaremos el timer0 del pic. Préviamente hemos calculado los "ticks" que contará este timer y cómo ajustamos el preescaler. Por ejemplo, para el cristal de 4Mhz, sabiendo que un servo en reposo o 50% da un pulso de 1,5ms. xtal=4 incremento:Xtal/4=1us x 8(preescaler) =8us Entonces el contador contará para: 1ms: 1,5ms/8us = 125 1,5ms: 1,5ms/8us = 187 2ms: 1,5ms/8us = 250 Hemos escogido el preescaler de 8 para abarcar esta horquilla entre 0 y 255.

1. #include <16F84.H>
3. #FUSES NOWDT      //No Watch Dog Timer
4. #FUSES HS      //para cristal de 6MHz
5. #FUSES PUT     //power up timer habilitado
6. #FUSES NOPROTECT//lectura habilitada del codigo del pic
8. //#use delay(clock=4000000) // 4 MHz OSC
9. //#use delay(clock=3579000) // 4 MHz OSC
10. #use delay(clock=6000000) // 6 MHz OSC
12. #USE FAST_IO (A)
13. #USE FAST_IO (B)
16. #define PIN_SERVOi1     PIN_B4
17. #define PIN_SERVOi2     PIN_B5
18. #define PIN_SERVOi3     PIN_B6
19. #define PIN_SERVOi4     PIN_B7
21. #define PIN_MOTOR1R     PIN_A0
22. #define PIN_MOTOR1L     PIN_A1
23. #define PIN_MOTOR2R     PIN_A2
24. #define PIN_MOTOR2L     PIN_A3
26. #define PIN_MOTOR3R     PIN_B0
27. #define PIN_MOTOR3L     PIN_B1
28. #define PIN_MOTOR4R     PIN_B2
29. #define PIN_MOTOR4L     PIN_B3
31. #define PIN_LED       PIN_A4
34. /*
35. xtal=3,57   incremento= 1.117 x 8 = 8,94 us
36. 1.5ms= 167
37. ULIMIT= 167 +10
38. LLIMIT= 167 -10
40. xtal=558k   inc= 7.168 x 1
41. =195
42. xtal=6 inc= 0,666  x 16 =10.66666
43. =140
45. */
46. #define ULLIMIT 140
47. #define ULIMIT 150
48. #define LLIMIT 130
51. int8 tempo,ledco;
52. int8 timerco1,motor1L,motor1R;
53. int8 timerco2,motor2L,motor2R;
54. int8 timerco3,motor3L,motor3R;
55. int8 timerco4,motor4L,motor4R;
58. int8 scounter;
59. int8 semaforo;
60. boolean ledb;
63. //**********************************************************************************
64. //**********************************************************************************
65. #INT_RB
66. void interrupcionRB() {
68. SWITCH(input_b()&0xF0){
70.     case 0b00010000:set_timer0(0); semaforo=1;break;
71.     case 0b00100000:set_timer0(0); semaforo=2;break;
72.     case 0b01000000:set_timer0(0); semaforo=3;break;
73.     case 0b10000000:set_timer0(0); semaforo=4;break;
74.    
75.     case 0:
76.         switch (semaforo){
77.        
78.             case 1:timerco1=get_timer0();semaforo=0;ledco++;break;
79.             case 2:timerco2=get_timer0();semaforo=0;ledco++;break;
80.             case 3:timerco3=get_timer0();semaforo=0;ledco++;break;
81.             case 4:timerco4=get_timer0();semaforo=0;ledco++;break;
82.    
83.         }
84.     default:
85.         semaforo=0;
87.    
88. }
91. //**********************************************************************************
92. //******************************  M A I N  *****************************************
93. //**********************************************************************************
94. void main(){
96.    
97.    set_tris_a(0);  // todo salida
98.    set_tris_b(0b11110000);  // todo salida rb4,6,7 entrada
99.    output_a(0);
100.    output_b(0);
101.    output_high(PIN_LED);
102.    
103.      
104.    setup_timer_0(RTCC_INTERNAL|RTCC_DIV_16);   //activamos timer0 como interno
105.    set_timer0(0);
108.     motor1L,motor1R=0;
109.     motor2L,motor2R=0;
110.     motor3L,motor3R=0;
111.     motor4L,motor4R=0;
112.    
113.     timerco1,timerco2,timerco3,timerco4=ULLIMIT;
116.    enable_interrupts(INT_RB);
117.    enable_interrupts(GLOBAL);
118.    
119.    
120.    
121.    
122.    for(ledco=0;ledco<5;ledco++) {output_bit(PIN_LED,ledb);
123.     ledb=!ledb;
124.     delay_ms(500);
125.    
126.    }
127.  
128. while(1){  //bucle infinito  
131.     for(tempo=0;tempo<=100;tempo++){
132.     // PWM DEL MOTOR
133.    
134.     //evaluamos aqui para no perder tiempo
135.    
136.     if(tempo==95 ){
137.         if(ledco++ >254){
138.             output_bit(PIN_LED,ledb);
139.             ledb=!ledb;
140.             ledco=0;
141.         }      
142.     }else if(tempo==96 ){
143.        
144.         if(timerco1 > ULIMIT ){ motor1R=(--timerco1-ULIMIT)*3;motor1L=0;}
145.         else if(timerco1 < LLIMIT) {motor1L=(LLIMIT-timerco1++)*3;motor1R=0;}
146.         else{motor1R=0;motor1L=0;}
148.     }else if(tempo==97 ){
149.    
150.         if(timerco2 > ULIMIT ){ motor2R=(--timerco2-ULIMIT)*3;motor2L=0;}
151.         else if(timerco2 < LLIMIT) {motor2L=(LLIMIT-timerco2++)*3;motor2R=0;}
152.         else{motor2R=0;motor2L=0;}
153.        
154.     }else if(tempo==98 ){
155.    
156.         if(timerco3 > ULIMIT ){ motor3R=(--timerco3-ULIMIT)*3;motor3L=0;}
157.         else if(timerco3 < LLIMIT) {motor3L=(LLIMIT-timerco3++)*3;motor3R=0;}
158.         else{motor3R=0;motor3L=0;}
159.        
160.     }else if(tempo==99 ){
161.    
162.         if(timerco4 > ULIMIT ){ motor4R=(--timerco4-ULIMIT)*3;motor4L=0;}
163.         else if(timerco4 < LLIMIT) {motor4L=(LLIMIT-timerco4++)*3;motor4R=0;}
164.         else{motor4R=0;motor4L=0;}     
165.        
166.     }
167.    
168.    
169.         output_bit(PIN_MOTOR1R,(motor1R >tempo));
170.         output_bit(PIN_MOTOR1L,(motor1L >tempo));
171.        
172.         output_bit(PIN_MOTOR2R,(motor2R >tempo));
173.         output_bit(PIN_MOTOR2L,(motor2L >tempo));
174.        
175.         output_bit(PIN_MOTOR3R,(motor3R >tempo));
176.         output_bit(PIN_MOTOR3L,(motor3L >tempo));
177.        
178.         output_bit(PIN_MOTOR4R,(motor4R >tempo));
179.         output_bit(PIN_MOTOR4L,(motor4L >tempo));
180.                
181.        
182.         delay_us(100);
183.        
184.    
185.     } //bucle tempo
186.    
187.    
188. } //end while  
189. }

Adaptador KKL-VAGCom 409 para diagnosis OBD

Después de varias pruebas y navegar aquí y allá he conseguido un esquemita para fabricarse un interface KKL VAGCom 409. El motivo era poder conectarme a mi coche a través de OBD y borrar varias alarmas, concretamente la pesada y recurrente del AIRBAG de mi FIAT.

En el tema software podéis usar el FIAT ECUSCAN, ahora llamado Multiecuscan que en su versión free servirá para el propósito. No voy a entrar en el funcionamiento del programa que es bastante fácil y podéis encontrar amplia información en Internet.

Proto-tipo

Uno de los quebraderos de cabeza ha sido configurar el puerto COM con el usb ya que el Windows no es demasiado amigable y los portátiles modernos ya no lo traen, entonces es recomendable comprarse el adaptador USB-RS232. Recomiendo abrir el "administrador de dispositivos" y observar los puertos, entonces conectar el adaptador USB-RS232 y ver que COM aparece. Luego ya podemos configurar el FIATECUSCAN con ese puerto COM.

Aunque se llame KKL VAGCom 409 no se usa la línea L, solo la K. En este caso el airbag para este modelo de FIAT se conecta en el pin 3 pero otros dispositivos pueden conectarse en los pin's 7 o 9. No lo he probado en otras marcas. Además sólo necesitamos el pin 16 para los 12V del coche y el pin 4 o 5 de negativo.

El esquema es bastante sencillo, he añadido un led para visualizar la actividad de la línea K. La resistencia de 200K alimenta el zener de 5,1V que a su vez alimenta el MAX232, por eso recomiendo que sea de 1/2W pues la de 1/4 se calienta un poco. También se puede usar un 7805 para esto.

KKL-VAGCOM

kkl- vagcom: esquema

El esquema es un poco rústico y carece de aislamientos, por eso os recomiendo usar un portátil con su batería, sobretodo NO usar alimentadores de esos que convierten 12 a 19 para alimentar el PC, tampoco conviene que el PC toque partes metálicas del coche. 

Tampoco me responsabilizo del daño que podáis hacer a la ECU del coche, al PC o a vosotros mismos... Estamos manipulando el AIRBAG y hay una remota posibilidad que este salte!

Acabemos de contar la historia.. he llegado aquí después de comprarme un adaptador ELM327 chino y comprobar que justamente para el airbag necesitaba el KKL VAGCom. Herido mi orgullo por el tremendo error no concibo comprarme otro cable y esperar otro mes a que venga desde China, además he podido reutilizar el conector OBD y el interface serie bluetooth me lo estoy mirando de reojo para otros proyectos.

Después de conectarme al coche tampoco he podido borrar las alarmas.... A parte del fallo del airbag del asiento, falla el lateral derecho, el izquierdo....

Si te ha sido de utilidad esta entrada o si quieres aportar algo por favor deja tus comentarios..

Coche barato, radio cara. Adaptador PWM servo a motor 1/2

Hola.
Basicamente queremos controlar motores con una radio sin usar los servos.

Con un coche de radiocontrol barato que evidéntemente trae una radio muy sencilla basada en el famoso "superchip" no tenemos ni mucho alcance ni control, ya que la transmisión es del tipo 1 o 0, osea encendido o apagado, ¿podemos adaptar una radio con servos? si con un control electrónico adecuado.

Nuestro proyecto consiste en sustituir todo o parte del control existente del coche. Finalmente he conservado la parte de actuación de los motores compuesta por los puentes H y he implementado los controles con un PIC. El PIC elegido es el famoso 16F84 pero podemos usar tamben un 12F629 o 683, en ese caso sólo dispondremos de 2 canales y con el 16F84 aprovechamos hasta 4.

El coche dispone de un motor de tracción trasera y otro de dirección, accionados por puentes H de transistores, entonces por cada motor hemos de generar 2 señales PWM  una por cada sentido de giro del motor.

El esquema esta adaptado para cuatro canales, aunque sólo usamos dos. Por lo demás no puede ser más sencillo (podemos simplificar si utizamos un PIC12 de 8 pins con oscilador interno..)

Al ser un control PWM conseguimos que el coche acelere poco a poco según giramos la palanca , no como el coche original que iba a trompicones.

Una vez todo montado, se sella bien con cola para evitar que se desmonte con los golpes y traqueteo. La radio se fija con gomas para poder retirarla caso de destrozar el coche.

En próximas entradas incluiré el código en C del PIC y el archivo .HEX

A disfrutarlo!

Bienvenidos a Xusco-Invents

Un blog sobre tecnologia, electrónica, telefonia, inventos y aplicaciones.

Cosas xuscas e ingeniosas, para entretenerse .. o no?