Montar directorios Remotos vía ssh

Suponiendo que tenemos un servidor ssh en la máquina remota y un usario al cual conectarnos procedemos a instalar el programa sshfs

sudo apt-get install sshfs

Creamos el Directorio local donde montaremos el directorio remoto

mkdir DRemoto

Y lo montamos de la siguiente forma:

sshfs user@mipcdesktop:/home/user/ DRemoto

el user debe tener permisos sobre el directorio que deseamos montar

para desmontarlo

sudo umount DRemoto

Hola Mundo con octave y c++

Requisitos:
Tener instalado octave, octave-headers y build-essential

En nuestro editor de texto predilecto (vim) escribimos lo siguiente


#include <octave/oct.h>
DEFUN_DLD(miHolaMundo, args, ,
"Sirve para imprimir un N Holas Mundo " )
{
unsigned int N = args(0).int_value(); //El argumento 0 lo convertimos a entero y
//se lo almacenamos en N

for(int i = 0; i<N;i++)
octave_stdout<<"Hola Mundo"<<endl;

return octave_value(0);
}

En la primera línea incluimos las cabeceras de octave y el la segunda definimos que nombre tendrá nuestra función. Guardamos el archivo con el mismo nombre de la función (miHolaMundo.cc) y compilamos

mkoctfile miHolaMundo.cc

Esto nos va a generar dos archivos:

miHolaMundo.o miHolaMundo.oct

donde miHolaMundo.oct es la función que acabamos de hacer.

Inicamos el octave y probamos:

octave:1> help miHolaMundo
Sirve para imprimir un Hola Mundo /home/s/proyectos/c/octave/miHolaMundo.oct

Additional help for built-in functions and operators is
available in the on-line version of the manual. Use the command
`doc ' to search the manual index.

Help and information about Octave is also available on the WWW
at http://www.octave.org and via the help@octave.org
mailing list.
octave:2>
octave:2> miHolaMundo(1)
Hola Mundo
ans = 0
octave:3> miHolaMundo(4)
Hola Mundo
Hola Mundo
Hola Mundo
Hola Mundo
ans = 0
octave:4>

El que sigue es parte del código para probar una Memoria RAM que esta dentro de un FPGA, lo recorte sólo para mostrar, como se usan Complejos y como se retorna a octave una o más variables. Esta función tiene como parametros de entrada un Vector Complejo, tamaño de la palabra y tamaño de la parte fraccional para convertir a punto fijo los valores del vector comlejo.



#include <octave/oct.h>
#include <iostream>
#include <fstream>
using namespace std;
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <oct-rand.h>
#include <oct-cmplx.h>

//inline void dec2bin(unsigned int a,unsigned int width_word,char * cadena);
inline int to_fixed(double data_in, unsigned int QW,unsigned int QF);
inline double f2d(int Dfixed,unsigned QF);

DEFUN_DLD (MemTest,args, ,
"Probar RAM FPGA via RS232\n")
{

ComplexColumnVector Data = args(0).complex_column_vector_value();
int len = Data.length();
ComplexColumnVector DataF=Data;
ComplexColumnVector DataR=Data;
unsigned int QW=args(1).int_value();
unsigned int QF=args(2).int_value();

for (int i = 0; i<len;i++) {
real(DataF(i))=f2d(to_fixed(real(Data(i)),QW,QF),QF);
imag(DataF(i))=f2d(to_fixed(imag(Data(i)),QW,QF),QF);
};

octave_value_list retval;

retval(0) = octave_value(DataF);
retval(1) = octave_value(DataR);
return retval;
}

inline int to_fixed(double data_in, unsigned int QW,unsigned int QF)
{
int x_0=0,j=1;
//we need to convert to double to QW and QF because oct.h only have pow(double,double)
if(data_in<0){ int x_0=pow(2.0,double(QW)); };
return int(x_0+pow(2.0,double(QF))*data_in);
}
inline double f2d(int Dfixed,unsigned QF)
{
return double(Dfixed)/(pow(2.0,double(QF)));
}

Compilamos con mkoctfile y probamos

octave:1> x=randn(4,1)+j*randn(4,1)
x =

-0.80972 + 3.54049i
-0.38686 - 0.35778i
-0.45699 + 0.05577i
-0.48280 + 1.01243i

octave:2> MemTest(x,13,10)
ans =

-0.80957 + 3.54004i
-0.38672 - 0.35742i
-0.45605 + 0.05566i
-0.48242 + 1.01172i

octave:3> [y z]=MemTest(x,13,10)
y =

-0.80957 + 3.54004i
-0.38672 - 0.35742i
-0.45605 + 0.05566i
-0.48242 + 1.01172i

z =

-0.80972 + 3.54049i
-0.38686 - 0.35778i
-0.45699 + 0.05577i
-0.48280 + 1.01243i


Como se puede ver, el primer resultado que nos regresa nuestra función es equivalente en punto fijo de 13 bits de los cuales 10 bits son para la parte fraccional y 1 para el signo.

Mi Escritorio Ubuntu en la Acer One

Por fin tengo este juguetito para divertirme un rato y este es mi ubuntu con el compiz


Acer One:
Intel(R) Atom(TM) N270 a 1.6 Ghz
RAM: 1Gb
HD: 120 Gb

En el fondo se ve el Firefox, el gimp y la terminal ejecutando el comando top

PICKit2 en Kubuntu Hardy

Requeriremos los siguientes programas:
1.- pk2cmd (http://home.pacbell.net/theposts/picmicro/pk2cmd-0.9.tar.gz)
2.- Kpk2cmd – GUI para pk2cmd (http://www.cannasoftware.com/downloads/kpk2cmd-Ubuntu-1.0.2.tar.gz)

Abrimos una terminal, en la cual navegaremos al directorio donde descargamos los programas y descomprimimos el archivo pk2cmd-0.9.tar.gz

~$ cd Desktop/PicKit2/
~/Desktop/PicKit2$ tar -xvzf pk2cmd-0.9.tar.gz

Se creará una carpeta llamada pk2cmd-0.9 a la cual entraremos y ejecutaremos make linux. Si no hubo errores entonces procederemos a ejecutar sudo make install



Figura 1. Terminal en el directorio ~/Desktop/PicKit2/pk2cmd-0.9


Figura 2. Ejecutando sudo make install

Enseguida regresamos al directorio anterior y descomprimimos kpk2cmd-Ubuntu-1.0.2.tar.gz

~/Desktop/PicKit2$ tar -xvzf kpk2cmd-Ubuntu-1.0.2.tar.gz

Para compilar este programa necesitaremos instalar los siguientes paquetes:

sudo apt-get install qt3-dev-tools
sudo apt-get install libqt3-headers libqt3-mt-dev qt3-qtconfig libqt3-compat-headers
sudo apt-get install kdebase-dev kde-devel

Terminada la instalación nos movemos al directorio kpk2cmd-1.0.2/ y ejecutamos

~/Desktop/PicKit2/kpk2cmd-1.0.2 $ make

Al finalizar de compilar se habrá creado dentro de la carpeta bin el ejecutable kpk2cmd el cual copiaremos al directorio /usr/bin

~/Desktop/PicKit2/kpk2cmd-1.0.2 $ sudo cp bin/kpk2cmd /usr/bin

Enseguida conectaremos el PICKit2 al PC. Si ejecutamos lsusb veremos a su salida algo parecido a lo que muestra la figura 3.


Figura 3. lusb nos muestra los dispositivos usb conectados actualmente.

En la misma termina escribimos el comando kpk2cmd y enseguida de presionar la tecla ENTER nos aparecera un GUI como el que se ve en la figura 4. No tiene auto detección por lo que tenemos que seleccionar el microcontrolador en (1).


Figura 4. kpk2cmd

Al presionar “Program Chip” (2) nos aparecerá un dialogo donde elegiremos nuestro .HEX (figura 5). En el caso que queramos leer el contenido del PIC (3), nos preguntará donde queremos guardarlo para su posterior lectura(figura 6)


Figura 5. Dialogo para elegir el programa para grabar en el PIC.


Figura 6. Dialogo para elegir la localización para guardar el HEX.



Figura 7. Contenido del archivo lectura.hex.



Figura 8. Por si no nos la creemos que es el contenido del PIC12F683.

Reparando una Tarjeta de Red PCMCIA

Los materiales necesarios para realizar esta operación son:
- Soldadura
- Cautín
- Pasta para soldar
- Multímetro
- Juego de desarmadores para relojero
- Tarjeta PCMCIA
- Y no tener pasta para comprar una nueva (sobre todo esta última)

Primero procederemos a abrir nuestra tarjeta, usando los desarmadores, de tal forma que dejemos la placa al descubierto, tal y como se muestra en la siguiente figura.

Tarjeta Desarmada

Aprovechando y cambiandole los leds

Ya que la tenemos despedazada procederemos a verificar cual puede ser el posible problema. El problema detectado en esta tarjeta es que todos los pines de RJ45 estaba desoldados de la placa.

Aquí se muestra cuales son los pines desoldados

Ya identificado el problema procedemos con cautela y sin miedo a meter el cautín. Como los pines de esta tarjeta están soldados de manera superficial, es bueno suponer que queda algo de soldadura reusable en las pistas, que por supuesto no alcanzamos a ver porque están un poco metidas.

Con un desarmador cogemos un poco de pasta para soldar y embarramos todos los pines.

Ya embarrados y con nuestro cautín bien caliente lo pasamos por todos y cada uno de los pines para calentarlos y provocar que la soldadura de la pista agarre de nuevo la patita.

Ya que le dimos la pasada, agarramos el multímetro para verificar la continuidad, en caso de que no hayan quedado soldados el multímetro mostrara circuito abierto.

Multímetro: Seleccionamos la opción para comprobar diodos y continuidad. Si al colocar las puntas de prueba entre dos puntos escuchamos un pitido entonces quiere decir que hay continuidad. Útil para verificar que los pines estén soldados.

En el caso que hallan quedado pines sin soldar, colocaremos un poco de soldadura (con un poco me refiero nada más a la puntita) en el cautín y se lo pasamos por los pines que no quedaron soldados. Verificamos de nuevo con el multímetro.

En el caso que queden sin soldar repetimos el paso anterior, de lo contrario ensamblamos de nuevo la tarjeta, y procedemos a probar.

Colocamos la tarjeta en posición y le enchufamos el cable, encendemos la laptop y procedemos a rezar.

Máquina de pruebas (mejor dicho víctima)

Si nuestros rezos fueron escuchados veremos que nuestra laptop de nuevo está en línea y dispuesta a descargarnos cuanta cosa se nos ocurra (Ver figura siguiente).

Hago un ping para corroborar que no estoy soñando

Termómetro

Ahora en aarmagnac.no-ip.org:1540 tengo un termometro realizado con un PIC 12f683 y un LM35 conectado al PC por medio del puerto serie. Cada 5 minutos se actualiza.

El programa del PIC lo hice para probar la programación en C de estos microcontroladores ya que siempre los había programado en ensamblador.

El programa de la PC está realizado en C++ el cual es ejecutado por medio del cron cada 5 minutos, generandome la página web que se puede ver en la página.

GHDL con las librerías UNISIM de Xilinx

¿Porqué usar ghdl?. En primer lugar surgió de la necesidad de poder realizar simulaciones de mi código de VHDL en linux debido a que el simulador del ISEWebPACK 9.1 y 9.2 de Xilinx no se digna en trabajar, siempre me manda el error 607 el cual si no es mi culpa, como lo puedo demostrar, pues fácilmente, abrí el ISE e inicié un nuevo proyecto pero en esta ocasión que fueran esquemáticos y no vhdl, hice una "and" y lo traté de simular y me arrojó el mismo error. Conclusión no es error mío es de la herramienta, ellos mismos está diciendo que no saben como construir una "and", jejejeje.

En segundo lugar, tenía que utilizar las librerías unisim:

Library UNISIM;
use UNISIM.vcomponents.all;

Voy a suponer que tenemos instalado en nuestro sistema alguna de las dos versiones anteriores del ISEWebPACK.

Desde la consola primero nos creamos una carpeta para ubicar nuestro código vhdl y dentro de ella crearemos una carpeta llamada unisim.

$ mkdir vhdl
$ mkdir vhdl/unisim

Ahora copiamos el contenido de la carpeta vhdl/src/unisims en el directorio del ISEWebPack, que en mi caso se encuentra en /opt/Xilinx92i/vhdl/src/unisims/, al directorio unisim que acabamos de crear.

$ cp /opt/Xilinx92i/vhdl/src/unisims/* vhdl/unisim/

Ahora nos movemos a la carpeta vhdl/unisim/

$ cd vhdl/unism

y compilamos estas librerías con

~/vhdl/unisim$ ghdl -a --work=unisim --ieee=synopsys -fexplicit unisim_VCOMP.vhd
~/vhdl/unisim$ ghdl -a --work=unisim --ieee=synopsys -fexplicit unisim_SMODEL.vhd
~/vhdl/unisim$ ghdl -a --work=unisim --ieee=synopsys -fexplicit unisim_VPKG.vhd

~/vhdl/unisim$ ghdl -a --work=unisim --ieee=synopsys -fexplicit --warn-no-vital-generic unisim_VITAL.vhd
unisim_VITAL.vhd:150533:18:warning: universal integer bound must be numeric literal or attribute
unisim_VITAL.vhd:176564:57: variable "write_a_write_b" is not visible here
unisim_VITAL.vhd:176565:57: variable "read_a_write_b" is not visible here
unisim_VITAL.vhd:176566:57: variable "write_a_read_b" is not visible here
unisim_VITAL.vhd:176567:57: variable "write_b_write_a" is not visible here
unisim_VITAL.vhd:176568:57: variable "read_b_write_a" is not visible here
unisim_VITAL.vhd:176569:57: variable "write_b_read_a" is not visible here
/usr/lib/ghdl/bin/ghdl: compilation error
Observamos que nos manda un error, pero no es de preocuparse es solo cuestion de abrir el archivo unisim_VITAL.vhd y comentar las líneas que nos indica (176564,176565,176566,176567,176568,176569).
Las líneas en cuestion son:
variable Write_A_Write_B : memory_collision_type := Write_A_Write_B;
variable Read_A_Write_B : memory_collision_type := Read_A_Write_B;
variable Write_A_Read_B : memory_collision_type := Write_A_Read_B;
variable Write_B_Write_A : memory_collision_type := Write_B_Write_A;
variable Read_B_Write_A : memory_collision_type := Read_B_Write_A;
variable Write_B_Read_A : memory_collision_type := Write_B_Read_A;

En este punto si volvieramos a tratar de compilar nos arrojaría el mismo error sólo que en líneas distintas.

unisim_VITAL.vhd:188630:57: variable "write_a_write_b" is not visible here
unisim_VITAL.vhd:188631:57: variable "read_a_write_b" is not visible here
unisim_VITAL.vhd:188632:57: variable "write_a_read_b" is not visible here
unisim_VITAL.vhd:188633:57: variable "write_b_write_a" is not visible here
unisim_VITAL.vhd:188634:57: variable "read_b_write_a" is not visible here
unisim_VITAL.vhd:188635:57: variable "write_b_read_a" is not visible here

Por lo tanto sería buena idea comentarlas también, ya sea que busquemos en el archivo por "variable Write_A_Write_B : memory_collision_type := Write_A_Write_B;" , comentar esta línea y las subsecuentes o movernos hasta la línea indicada que sería la 188630 y comentarlas.

Hecho lo anterior volvemos a compilar con:
ghdl -a --work=unisim --ieee=synopsys -fexplicit --warn-no-vital-generic unisim_VITAL.vhd

Ya compilado nos retachamos a la carpeta vhdl ($ cd ..) para empezar a realizar nuestras pruebas, en donde compilaremos nuestros proyectos con:

ghdl -a --ieee=synopsys -Punisim -fexplicit