CAN (acrónimo del inglés Controller Area Network) es un protocolo de comunicaciones desarrollado por la firma alemana Robert Bosch GmbH, basado en una topología bus para la transmisión de mensajes en entornos distribuidos.

Can Sniffer

Lee la entrada completa

Y para que quiero yo esto? Pues desde hace unos cuantos años, el aumento de electrónica en los coches ha obligado a los fabricantes a implantar una red dentro del vehículo para poder comunicar todos los sensores, actuadores y cpus del coche sin tener que tirar metros y metros de cables para conectarlos todos. Con este bus, podemos comunicar toda la electrónica del coche ¡¡¡con solo dos hilos!!! (Cosas de la transmision diferencial y el CSMA). Aunque en la realidad, por ejemplo en los coches del grupo Volkswagen cada vehículo tiene tres buses, el de Tracción, el de Confort, y el de “Infotaiment”. Como es de esperar, las comunicaciones mas vitales del coche van por el de tracción, lo referente a los asientos, el climatizador, puertas, ventanas luces etc va por el de confort, y por último la información del cuadro de instrumentos (a.k.a Cockpit) la radio, el navegador … va por el de “infotaiment”. Y aquí es donde me interesa el sniffer, ya que en mi coche, la radio se puede comunicar con el Cockpit para mostrar información en el FIS, incluso en coches con mandos en el volante (manos libres, control de la radio…) puedes a través de este bus saber cuando se pulsa un botón. Todo esto enfocado a algún día llevar en el coche un CarPC/TabletPC y dotarlo de funcionalidades añadidas.

El cacharro en si es bien sencillo.

• Un controlador del CAN-BUS
• Arduino
• Software adecuado (Do It Yourself)

En principio solo vamos a analizar una parte de las comunicaciones, ya que por el bus viaja mucha información, y solo una parte nos interesa, ademas esta va codificada (que no cifrada) a su manera, ya que aunque el CAN es un estándar, cada fabricante pone los datos en el bus como le da la gana.

Una vez tengamos la información que necesitemos, podemos reprogramar arduino para que simplemente conecte el pc con el CAN-BUS.

Aquí dejo la foto del caos-cableado que une todo. La idea es que también lleve su tarjeta SD/microSD para que almacene todos los mensajes durante los viajes y después analizarlos sin necesidad del PC siempre en el coche.

CAN Sniffer sin LCD

El caso es que ayer, y hoy, he visto en la TV como reducían el problema de la ley sinde a que nos iban a impedir descargar material protegido por derechos de autor. NO, NO y NO!! El problema de la ley sinde es que quieren que el gobierno a través de una comisión decida que webs se pueden cerrar automáticamente. Ya no solo las webs de descargas “ilegales”, si no que por ejemplo, podrían censurar esta o cualquier página de internet que considerasen oportuno. Es verdad que el proceso es mas complejo, pero a groso modo es así. Porque lo primero que hacen es cerrarte la web de manera cautelar, y luego llamamos al juez, y ya sabemos como es la justicia, te puedes tirar años, y mientras están de pleitos, tu página web está cerrada, y una web que cierra por un periodo largo, (de entre unos meses a varios años) es una web que muere automáticamente.

NO SE DEJEN ENGAÑAR POR LA CORTINA DE HUMO BASADA EN LA PIRATERÍA

No se si están equivocados ellos, o yo, porque creo que toda (o una gran parte) la gente que a través de internet se ha movilizado sabe lo que nos jugamos realmente. Esta ley es propia de una dictadura / tiranía a lo China, Cuba o Venezuela. Esto demuestra lo podridos que están los políticos de este país.

A si que estad atentos a próximos movimientos del gobierno, que ahora con las navidades tienen tiempo de negociar con los independentistas para que les ayuden a cambio de favores….

Nota: Yo no estoy a favor de la piratería (tampoco estoy a favor del modelo de negocio de la industria de la cultura), pero para cerrar cualquier tipo de web, aunque sea de forma cautelar, primero tiene que haber la autorización de un juez, al igual que para que la policía registre tu casa necesita primero una orden de registro.

Está hecho con Arduino, un array de pares darlington (ULN2003A) y un shift register 74HC595. Solo falta montarlo en una placa, soldarlo con unos cuantos mas shift registers y tendremos una marquesina. Esuqema de conexion de la matriz de 8×8:

Las resistencias que hay entre los integrados y la matriz, a mi me ha funcionado con resistencias de entre 0,5K Ohm y 1k Ohm
El codigo está aquí.

// 8*8 LED matrix with ULN2003A & 74HC595
// Made by Vadim S.
//On 25.06.2009
// Mod by Alwar
//On 13.06.2010
///Pin connected to ST_CP of 74HC595
int latchPin = 8;
//Pin connected to SH_CP of 74HC595
int clockPin = 12;
////Pin connected to DS of 74HC595
int dataPin = 11;
int x;
int y;
// here the definion of all the letter(big ans small) and numbers
#define A     {B00111100,B01000010,B01000010,B01000010,B01111110,B01000010,B01000010,B01000010}
#define B     {B01111100,B01000010,B01000010,B01111100,B01000010,B01000010,B01000010,B01111100}
#define C     {B00111110,B01000000,B01000000,B01000000,B01000000,B01000000,B01000000,B00111110}
#define D     {B01111100,B01000010,B01000010,B01000010,B01000010,B01000010,B01000010,B01111100}
#define E     {B01111110,B01000000,B01000000,B01111100,B01000000,B01000000,B01000000,B01111110}
#define F     {B01111110,B01000000,B01000000,B01111100,B01000000,B01000000,B01000000,B01000000}
#define G     {B00111100,B01000010,B01000010,B01000000,B01000111,B01000010,B01000010,B00111100}
#define H     {B01000010,B01000010,B01000010,B01111110,B01000010,B01000010,B01000010,B01000010}
#define I     {B00111000,B00010000,B00010000,B00010000,B00010000,B00010000,B00010000,B00111000}
#define J     {B00011100,B00001000,B00001000,B00001000,B00001000,B01001000,B01001000,B00110000}
#define K     {B01000100,B01001000,B01010000,B01100000,B01010000,B01001000,B01000100,B01000010}
#define L     {B01000000,B01000000,B01000000,B01000000,B01000000,B01000000,B01000000,B01111110}
#define M     {B01000100,B10101010,B10010010,B10010010,B10000010,B10000010,B10000010,B10000010}
#define N     {B01000010,B01100010,B01010010,B01001010,B01001010,B01001010,B01000110,B01000010}
#define O     {B00111100,B01000010,B01000010,B01000010,B01000010,B01000010,B01000010,B00111100}
#define P     {B00111100,B01000010,B01000010,B01000010,B01111100,B01000000,B01000000,B01000000}
#define Q     {B00111100,B01000010,B01000010,B01000010,B01000010,B01000110,B00111110,B00000001}
#define R     {B00111100,B01000010,B01000010,B01000010,B01111100,B01000100,B01000010,B01000010}
#define S     {B00111100,B01000010,B01000000,B01000000,B00111100,B00000010,B01000010,B00111100}
#define T     {B11111110,B00010000,B00010000,B00010000,B00010000,B00010000,B00010000,B00010000}
#define U     {B01000010,B01000010,B01000010,B01000010,B01000010,B01000010,B01000010,B00111100}
#define V     {B01000010,B01000010,B01000010,B01000010,B01000010,B01000010,B00100100,B00011000}
#define W     {B10000010,B10000010,B10000010,B10000010,B10010010,B10010010,B10101010,B01000100}
#define X     {B01000010,B01000010,B00100100,B00011000,B00011000,B00100100,B01000010,B01000010}
#define Y     {B10000010,B01000100,B00101000,B00010000,B00010000,B00010000,B00010000,B00010000}
#define Z     {B01111110,B00000010,B00000100,B00001000,B00010000,B00100000,B01000000,B01111110}
#define lit_a {B00000000,B00000000,B00000000,B00111000,B01000100,B01000101,B01000101,B00111010}
#define lit_b {B00000000,B00100000,B00100000,B00100000,B00111100,B00100010,B00100010,B00111100}
#define lit_c {B00000000,B00000000,B00000000,B00111100,B01000000,B01000000,B01000000,B00111100}
#define lit_d {B00000000,B00000100,B00000100,B00000100,B00111100,B01000100,B01000100,B00111100}
#define lit_e {B00000000,B00000000,B00111000,B01000100,B01000100,B01111000,B01000000,B00111100}
#define lit_f {B00011000,B00100100,B00100000,B00100000,B01110000,B00100000,B00100000,B00100000}
#define lit_g {B00011100,B00100010,B00100010,B00011110,B00000010,B00000010,B00010010,B00001100}
#define lit_h {B01000000,B01000000,B01000000,B01000000,B01111000,B01000100,B01000100,B01000100}
#define lit_i {B00000000,B00010000,B00000000,B00010000,B00010000,B00010000,B00010000,B00010000}
#define lit_j {B00000000,B00010000,B00000000,B00010000,B00010000,B00010000,B01010000,B00110000}
#define lit_k {B00000000,B00000000,B01001000,B01010000,B01100000,B01100000,B01010000,B01001000}
#define lit_l {B01000000,B01000000,B01000000,B01000000,B01000000,B01000000,B01000000,B01000000}
#define lit_m {B00000000,B00000000,B00110100,B01001010,B01001010,B01001010,B01001010,B01001010}
#define lit_n {B00000000,B00000000,B01111000,B01000100,B01000100,B01000100,B01000100,B01000100}
#define lit_o {B00000000,B00000000,B00000000,B00011100,B00100010,B00100010,B00100010,B00011100}
#define lit_p {B00000000,B00000000,B00011100,B00100010,B00100010,B00111100,B00100000,B00100000}
#define lit_q {B00000000,B00000000,B00111000,B01000100,B01000100,B00111100,B00000100,B00000100}
#define lit_r {B00000000,B00000000,B00111000,B01000000,B01000000,B01000000,B01000000,B01000000}
#define lit_s {B00000000,B00111000,B01000100,B01000000,B00111000,B00000100,B01000100,B00111000}
#define lit_t {B00100000,B00100000,B00100000,B01111000,B00100000,B00100000,B00100010,B00011100}
#define lit_u {B00000000,B00000000,B00000000,B01000100,B01000100,B01000100,B01000100,B00111000}
#define lit_v {B00000000,B00000000,B01000100,B01000100,B01000100,B01000100,B00101000,B00010000}
#define lit_w {B00000000,B00000000,B00000000,B01000100,B01000100,B01010100,B01010100,B00101000}
#define lit_x {B00000000,B00000000,B00000000,B00000000,B00100100,B00011000,B00011000,B00100100}
#define lit_y {B00000000,B01000100,B01000100,B00111100,B00000100,B00000100,B00000100,B00111000}
#define lit_z {B00000000,B00000000,B00000000,B01111100,B00001000,B00010000,B00100000,B01111100}
#define space {B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000}
#define num_0 {B00111100,B01000110,B01001010,B01001010,B01001010,B01010010,B01100010,B00111100}
#define num_1 {B00001000,B00011000,B00001000,B00001000,B00001000,B00001000,B00001000,B00011100}
#define num_2 {B00111100,B01000010,B00000100,B00001000,B00010000,B00100000,B01000000,B01111110}
#define num_3 {B01111110,B00000010,B00000010,B00011100,B00000010,B00000010,B01000010,B00111100}
#define num_4 {B00000100,B00001100,B00010100,B00100100,B01000100,B01111110,B00000100,B00000100}
#define num_5 {B01111110,B01000000,B01000000,B00111100,B00000010,B00000010,B00000010,B01111100}
#define num_6 {B00111100,B01000000,B01000000,B01111100,B01000010,B01000010,B01000010,B00111100}
#define num_7 {B01111110,B00000010,B00000100,B00001000,B00010000,B00010000,B00010000,B00010000}
#define num_8 {B00111100,B01000010,B01000010,B00111100,B01000010,B01000010,B01000010,B00111100}
#define num_9 {B00111100,B01000010,B01000010,B01000010,B00111110,B00000010,B00000010,B00111100}
#define times {B00000000,B01000010,B00100100,B00011000,B00011000,B00100100,B01000010,B00000000}
// Signals for shift register, go over al cols, one each time
byte barrido[8] = { B00000001,B00000010,B00000100,B00001000,B00010000,B00100000,B01000000,B10000000 };
const int numPatterns = 15;//this is the number of patterns you want to display
// the patterns order
byte patterns[numPatterns][8]={space,M,A,D,E,space,B,Y,space,A,L,W,A,R,space};
void setup(){
  // this is a commed that makes pins 0-7 outputs(see more on the arduino site)
  DDRD=B11111111;
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
}
// int loop acts like a delay, it take 8 mSecands to scan all of the rows so int
// loops = 15 is a good time for it
void display_pattern(int loops)
{
   for(x=0;x
   { // loop over the patterns
      for (int z=0;z<8;z++)
      { //scrolls one bite at a time
         for(int t=0;t
         {// the delay we get with loops
            for(y=0;y<8;y++)
            {
               // loops over the array of bytes
               byte temp = patterns[x][y];
               byte temp_2=patterns[x+1][y];
               //writes digital outputs, Z is for how much bites it need to scroll
               PORTD = (temp<>7-z);
               delayMicroseconds(800);// the time every row is one
               PORTD=B00000000;// all pins are low, fixes the ghosting effect
               digitalWrite(latchPin, LOW);
               shiftOut(dataPin, clockPin, LSBFIRST, barrido[y]);
               //return the latch pin high to signal chip that it
               //no longer needs to listen for information
               digitalWrite(latchPin, HIGH);
            }
         }
      }
   }
}
void loop(){
// calls for the display_pattern function and says that int loop = 15
// (if you do more loop the pattern whould scrrol slower).
display_pattern(15);
}

Para hallar el valor de salida en relación al de entrada debemos aplicar la siguiente formula:

¿Y para uqe nos vale esto? Pues porque el “convertidor analógico digital” que trae Arduino solo acepta hasta 5 voltios, pero si por ejemplo en mi caso queremos utilizar el circuito para comprobar baterías de 8,4 voltios, y puede que también de 9,6 voltios necesitamos reducir el voltaje de entrada para no churruscar nuestra placa de prototipado. Entonces con el divisor de tensión el ADC de arduino ahora acepta hasta 10v con una resolución de 10bits lo que no da una precisión de 9,77 mV. Si quisiéramos baterías mas grandes deberíamos añadir resistencias al divisor de tensión para que en Vout cuando Vin es máximo solo hubiese 5 voltios. No vale poner una resistencia muy grande, necesitamos varias, ya que en mi ejemplo cada resistencia tiene una caída de potencial del 50%. Si po ejemplo quisiéramos medir baterías de hasta 20 voltios, necesitaríamos dividir por 4 la tensión, y lo conseguríamos conectando en vez de dos resistencias, cuatro. Y conectaríamos Vout entre la penúltima y la última resistencia. Como las 4 resistencias serán iguales, pues cada una tendrá una caída de potencial de 1/4 del voltaje de entrada, lo que nos daría como máximo 5 voltios.

Este es el circuito. Donde el simbolo del voltimetro es la placa arduino usando cualquiera de sus pines de entrada analogicos (A0~A5). La batería de 9 voltios es la que queremos probar. Las resistencias según pueden ser de entre 1K y 10K, yo uso un valor intermedio de 4,7K.


El código
Es muy sencillo, creo que no hace falta explicarlo.

int sensorPin = 3;
int sensorValue = 0;
float voltaje = 0.0;

void setup()
{
  Serial.begin(9600);
  Serial.println("Battery Tester");
} 

void loop()
{
  sensorValue = analogRead(sensorPin);
  Serial.println(sensorValue);
  voltaje = ((5*float(sensorValue))/1024);
  Serial.print("Divisor de Tension (Vout): ");
  Serial.println(voltaje,3);
  Serial.print("Voltaje estimado (Vin): ");
  Serial.println(voltaje*2,3);
  delay(1250);

}

Ademas le he añadido otra funcionalidad (como mola el software libre) y es que si la ejecutas con la opción make (no la de compilar si no “paketX make”) pues te crea una carpeta con el nombre de la practica y en ella todos los archivos (en blanco claro) que hay que entregar, así te ahorras el trabajo de crearte la estructura de la practica. Claro que solo funciona con archivos de texto (por ejemplo para los VHDl *.vhd o los sources de Pascal *.pas), si te genera un archivo *.pdf lo puedes borrar porque solo sirve para ver que tienes que entregar.

Es mi primer script serio en bash, y espero que no seáis muy duros con el, ya que hace dos dias, sabía bien poco sobre este lenguaje de scripting. Osea que tendrá sus fallos.
Esta escrito y testado bajo Debian GNU/LINUX squeeze. Que yo sepa solo necesita para funcionar, bash, p7zip y XMLStarlet.

El programa lo podéis bajar desde el archivo de alwar

Actualización v0.2

He actualizado el script, ya que antes separaba los nombres con un espacio y el programa para windows lo hace con un tabulador. Ahora el script también mete un tabulador. Estuve comparando una practica empaquetada con ambos programas, y a excepción del tabulador el archivo era idéntico. Solo cambia una cosa, y es que el programa para windows nombra a la practica con los nombres de los expedientes a la inversa de como los escribes, mientras que el script para linux lo pone en el orden que fueron escritos. Esto no creo que sea un problema ya que cuando examinen la practica no creo que sepan en que orden los introdujiste.

Para ello he utilizado un cañón de 450mm y un diámetro de 6,04mm. Con el silenciador puesto, nos sobran unos 3 cm de cañón que hay que cortar, pulir y redondear para que no queden bordes que puedan modificar la trayectoria de la bola.

Aqui una vista de los dos cañones juntos:

Y aqui los dos cañones, el cañon largo ya perfectamente montado.

Y aquí el cañon ya cortado:

Una vez limado el cañón queda mas metido, mas liso el borde, y podemos limar un poco del interior para hacer la salida cónica y que no entorpezca a la bola al salir. Conviene empezar con una lima de grano gordo, y luego pasar a una fina para un mejor acabado. Y si nos molesta mucho que se vea el cañón dorado, pues podemos pintar la punta.

Introducción
Esta vez, (todo por culpa de windows que por arte de birlibirloque se carga el MBR haciendo cualquier SO inarrancable ) intentado restaurar una copiar del MBR, por error, en vez de copiarla al inicio del disco, (donde esta mi MBR) la copie al principio de la partición 2 (hd0,1 ó sda2). Al principio el error, no parece tan grave, pero cuando ves que no puedes montar la partición de ninguna manera, te empiezas a mosquear ¬¬

Vamos al Grano

“Tranquilidad y buenos alimentos” como se suele decir, lo primero ante un fallo de estos, es no alterarse y no estropearlo mas, intentar arreglarlo precipitadamente nos puede llevar a intentar arreglarlo de alguna forma que solo lo estropeemos mas (o irreversible). Ante todo debemos empezar con un buen diagnostico (En este caso, observando la salida de mount+google hubieramos dado pronto con la solución, sin correr a coger el testdisk)
Una buena practica es hacer backups, así si no tienes datos irrecuperables, puedes directamente formatear y volver a empezar. Pero como yo no lo tenía, y tampoco sabía como arreglarlo, pues antes de estropearlo mas, nos hacemos un backup por ejemplo con clonezilla. Tiene una interfaz hecha con ncurses (intuyo) que es un poco liosa a mi parecer (o que la versión en castellano esta mal traducida) , pero si tenemos espacio en otra particion/disco en el mismo PC donde esta la ext3 en cuestión, pues podemos copiarla a un archivo como yo hice (25 archivos de 2 GB ), si no pues buscar otra forma de hacer backup. Esto es importante ya que en mi caso los datos no se había perdido, solo se había sobreescrito los 32 primeros KBytes de sda2, entonces hacer algo inapropiado sobre el disco podría empeorarlo.

Busqueda de los backup del superblock
Una vez hecho el backup (bueno, esto se puede hacer también antes del backup) con testdisk seleccionamos HD, tipo de tabla de particiones, le damos a “Advanced” seleccionamos la partición ext2/3 (supongo que con ext2 también vale, son fs identicos, solo que ext3 incluye journaling y ext2 no, y no me pregunteis que es que no lo se) y le damos a “Superblock”, esto buscara en la partición los “Superbloques” de backup que hay esparcidos por todo el disco, por si nos pasa esto xD.
Cuanto termine nos dará una tabla de números, que habrá que copiar para luego indicarle a fsck.ext3 donde puede haber un superbloque de repuesto.

Para saber mas de como funciona el sistema de ficheros ext2 puedes ver este PDF [111 Transparencias]
Apunta todos los “superblock” y el “blocksize” (con una vez que apuntes el blocksize es suficiente, ya que debería ser siempre el mismo) que nos hacen falta ahora despues.

Restaurar el superblock
Para restaurar el superblock, solo tienes que ejecutar algún live cd que tenga fsck (digo live cd, porque entiendo que si estas leyendo esto es que te has cargado el sistema de ficheros raiz, si no es así lo puedes hacer desde tu instalación normal de linux)
Una vez tengas una consola funcionando, ejecutamos fsck:
/sbin/fsck.ext3 -b [superblock] -B [blocksize] /dev/hda1
Donde [superblock] reemplazar por uno de los bloques que nos dio testdisk. Recomiendo uno alto, ya que si te ha pasado como en mi caso, es mas probable que se halla afectad un superblock del principio que del final. Donde [blocksize] el tamaño de cada bloque, normalmente 1024, 2048 o 4096.
Donde hda1 reemplazar por la particion a reparar.Ojo con esto, que por no fijarme bien en que unidad ponía me carge el sistema de archivos.
Fsck se pone a trabajar… nos empezara a sacar errores y nos preguntara que si queremos repararlos, le decimos que si a todo, y cuando termine el sistema de archivos en cuestión se podrá montar con normalidad.

Resumiendo
Para Recuperar el superblock necesitamos:
- TestDisk
- fsck (viene con e2fsprogs y con RIP liveCD)
Opcional
- Clonezilla (si queremos hacer backup)
- RIP liveCD (si no tenemos donde ejecutar testdisk ni fsck)

Procedimiento
- Halla los superbloques con testdisk (en Advanced)
- Restauralo con fsck: /sbin/fsck.ext3 -b [superblock] -B [blocksize] /dev/[partición]

Cosas a tener en cuenta
HACER BACKUP’S DE TODO

Como diagnosticar que le pasa a un disco
- Ver que dice mount
- Ver que dice fsck
- Ver que dice gpart (sin opciones, solo dispositivo) No tiene nada que ver con gparted.
- Ver que dice TestDisk, pero no escribir cambios, hasta que estemos seguros.
Tomar una decisión precipitada puede llevarnos a empeorarlo mas.
Usar mucho google, y si hace falta (como es mi caso) buscar información sobre como funciona el FileSystem y así poder averiguar que ha pasado.

Este nos abre una ventana y según movamos el ratón por ella o presionemos teclas irán saliendo mensaje en la consola.
Presionamos la tecla que queramos averiguar y no saldrá algo como esto:

KeyPress event, serial 33, synthetic NO, window 0x4000001,
   root 0x13b, subw 0x0, time 22797201, (168,-8), root:(173,41),
   state 0x0, keycode 105 (keysym 0xff57, End), same_screen YES,
   XLookupString gives 0 bytes:
   XmbLookupString gives 0 bytes:
   XFilterEvent returns: False

KeyRelease event, serial 33, synthetic NO, window 0x4000001,
   root 0x13b, subw 0x0, time 22797342, (168,-8), root:(173,41),
   state 0x0, keycode 105 (keysym 0xff57, End), same_screen YES,
   XLookupString gives 0 bytes:
   XFilterEvent returns: False

Nos fijamos donde pone keycode 105. Ese es el código que necesitamos asociar a un keysym
En esa página vienen muchas constantes simbólicas asociadas a un kernel 2.4. Los números en hexadecimal no nos valen para nada, quedaros solo con el nombre de la tecla.

Una vez halláis recopilado los keycodes y keysyms pocederemos a crear un archivo muy sencillo con la estructura:
KEYCODE #keycode = keysym

En mi caso quedó esto:
keycode 99 = Home
keycode 105 = End
keycode 97 = Prior
keycode 103 = Next


Lo guardáis donde queráis (preferiblemente en /home/user/.xmodmap) y lo probamos con:
xmodmap /home/user/.xmodmap
E inmediatamente podéis probar si funcionan los cambios sobre el teclado. Si no funciona, revisar el archivo o los keycodes/keysym. Yo al principio usba los keycodes dados por showkey -k y no me funcionaba correctamente (me daba codigos pertenecientes a otras teclas).

Si os funciona, pues añadirlo a algún script de inicio o donde corresponda a vuestro entorno de escritorio (para gnome en Sistema > Preferencias > Sesiones se pueden añadir comandos personalizado para ejecutar al inicio.)

Feliz Navidad!