Mundo choc Cac

Compilación de libSerial c++ para Debian wheezy.

resulta que deseo usar libSerial para un hardware el problema que encontré fue que no están el los repositorios de debian stable, entonces me di la tarea de compilarlo entonces lo baje de la pagina principal y resulta que cuando inicio la compilación resulta que no me funciona ya que me indicaba que faltaba que declarar algunas cosas, entonces leyendo veo que solo falta incluir algunos encabezado del SO. Ya finalizado la inclusión volví a compilar entonces viene el problema clásico de que no podía seguir ya que «SIP» no estaba funcionando(no estaba instalado) entonces, me recordé que me faltaba instalar el paquete de sip de python una vez instalado todo me funciono de maravilla.

Paso 1:
descargamos el paquete:

wget -c http://colocrossing.dl.sourceforge.net/project/libserial/libserial/0.6.0rc1/libserial-0.6.0rc1.tar.gz

Paso 2:
agregarmos esto en archivo de ../src/SerialPort.cpp
#include <cassert>
#include <termios.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/time.h>
#include <signal.h>

Paso 3:
en mi caso yo uso Gnu/Debian, si usas otra distribución debería averiguar si tienes los paquetes disponibles en tu repositorio.

aptitude -t wheezy-backports install python2.6-sip python-sip-dev

Paso 4:
./configure
make

entrar en modo root:
y luego tipeas: make install

Nota:
en mi caso yo quiero instalar en otra carpeta:
mkdir libserialCompilado0.6rc1
make install DESTDIR=/home/gman/libSerial/libserialCompilado0.6rc1

Deseaba compartir esta solución ya que me llevo un pequeño tiempo de mi vida.

by lmcc

un arbol binario es una estructura de datos, «en la cual cada nodo siempre tiene un hijo izquierdo y un hijo derecho. No pueden tener más de dos hijos (de ahí el nombre «binario»). Si algún hijo tiene como referencia a null, es decir que no almacena ningún dato, entonces este es llamado un nodo externo.» wikipedia.

En fin esta implementacion es un simple hecho en c++ con estructuras, en este caso tiene

void mostrarInOrden(NodoArbol *hijo);  con esta funcion mostramos el nodo raiz ya que eso usaremos para mostrarlo, en la proxima ejemplo les mostrare el uso con clases en la cual se ve la importancia del uso de clases.

#include <iostream>
using namespace std;

struct NodoArbol
{
int dato;
NodoArbol *izquierdo;
NodoArbol *derecho;
};

NodoArbol *raiz;
NodoArbol *auxiliar;

void inicializarArbol()
{
raiz=NULL;
auxiliar=NULL;
}


//al nodo enviado en hijo agregarle como hijo el valor enviado en valorNodo
void agregarNodoHijo(NodoArbol *hijo, int valorNodo)
{
//si tiene que ir en el hijo izquierdo
if(hijo->dato > valorNodo)
{
if(hijo->izquierdo==NULL)
{

hijo->izquierdo= new NodoArbol;
hijo->izquierdo->dato=valorNodo;
hijo->izquierdo->izquierdo=NULL;
hijo->izquierdo->derecho=NULL;
}
else
{
agregarNodoHijo(hijo->izquierdo, valorNodo);
}
}

//si tiene que ir en el hijo derecho
if (hijo->dato <=valorNodo)
{
if(hijo->derecho==NULL)
{

hijo->derecho = new NodoArbol;
hijo->derecho->dato=valorNodo;
hijo->derecho->izquierdo=NULL;
hijo->derecho->derecho=NULL;
}

else
{

agregarNodoHijo(hijo->derecho, valorNodo);
}
}


}


void agregarNodo(int valorNodo)
{

if (raiz==NULL)
{
raiz = new NodoArbol;
raiz->dato=valorNodo;
raiz->izquierdo=NULL;
raiz->derecho=NULL;
}

else
{
agregarNodoHijo(raiz,valorNodo);
}

}

//Lectura de Arbol
void mostrarInOrden(NodoArbol *hijo)
{
if (hijo!=NULL)
{
mostrarInOrden(hijo->izquierdo);
cout << hijo->dato << "\n";
mostrarInOrden(hijo->derecho);

}
}


int main()
{
inicializarArbol();

int datoLeido=0;

cout << "Ingrese un numero (0 para salir)\n";
cin >> datoLeido;

while(datoLeido != 0)
{
agregarNodo(datoLeido);

cin >> datoLeido;
}

cout << "\n in orden:\n";
mostrarInOrden(raiz);
cin.get();cin.get();
return 0;
}

Como puede notar usar el teclado en ncurses es sencillo, es muy parecido a borlan, casi en todo solo que extiende un poco mas.

#include <ncurses.h>
int main()
{
int x = 5;
int y = 5;
int ch; /* identificador del teclado */
initscr();
curs_set(0);
keypad(stdscr, TRUE);     /*para obtener la tecla presionado */
noecho(); /* no mostara mientras presionamos*/
while (1)
{
mvprintw(y, x, "@@@");
ch = getch();
if (ch == KEY_DOWN)
{
y++;
clear();
}
if (ch == KEY_UP)
{
y--;
clear();
}
if (ch == KEY_LEFT)
{
x--;
clear();
}
if (ch == KEY_RIGHT)
{
x++;
clear();
}
refresh();
}
endwin();
return 0;
}

Como puedes observar usar ncurses es facil. pudes jugar con los colores y ver que puedes hacer programas excelente y bonitos.

#include <ncurses.h>
int main()
{
initscr();
start_color(); /*Recuerde llamar esta funcion, para colorear*/
init_pair(1, COLOR_RED, COLOR_CYAN); /*esto es un par de colores, puedes cambiarlo, a tu gusto.*/
init_pair(2, COLOR_YELLOW, COLOR_GREEN);
attron(A_UNDERLINE | COLOR_PAIR(1)); /*activar el texto subrayar y color */
printw("subraya el texto en rojo con fondo cian\n");
attroff(A_UNDERLINE | COLOR_PAIR(1));
attron(A_BOLD | COLOR_PAIR(2));
printw("texto en negrita amarilla con fondo verde");
attroff(A_BOLD | COLOR_PAIR(2));
refresh();
getch();
endwin();
return 0;
}

Bueno tratando de pasar una buena noche.

Ncurses es una alternativa para conio para los que usen borlan, y desean pasar en una distro basado en linux.

instalar:  en modo sudo o su, depende de tu distro basado en debian.

aptitude install ncurses-dev libncurses5-dev

apt-get install ncurses-dev libncurses5-dev

#include <ncurses.h>
 int main()
 {
 initscr(); /*Iniciamos ncurses */
 curs_set(0); /*Hace que el cursor invisible */
 printw("hola mundo"); /* vamos mostra hola mundo */
 refresh(); /*mostramos hola mundo */
 getch(); /*Esperamos que el usuario presione una tecla */
 endwin(); /* fin de ncurses*/
 return 0;
 }

fue probado en codeblocks y funciona de maravilla.

contraseña: lmcc link: holamundoncurses

initscr () función es iniciar Ncurses ,  esta función va siempre cuando se utiliza la biblioteca Ncurses . Esta función inicializa el sistema de ncurses y asigna memoria para la ventana actual (llamada stdscr ) y algunas otras estructuras de datos .

printw (cadena) es la salida de una cadena en una ventana imaginaria, cuando llamamos printw () los datos se escribe realmente en una ventana imaginaria , que no se actualiza en la pantalla todavía. El trabajo de printw es actualizar algunas banderas y estructuras de datos y escribir los datos en una memoria intermedia correspondiente a stdscr . Con el fin de mostrar en la pantalla , tenemos que llamar a refresh () y decirle al sistema de ncurses para volcar el contenido en la pantalla.
endwin () terminará el modo Ncurses y libera la memoria utilizada.

como podemos notar que es simple usar ncurses, con esto podrías hacer interrupciones de teclado y otros dispositivos, pero sin duda la única limitante es la imaginación.

Empezando el mes de abril he observado que este tema se ve muy intrigante, para empezar debemos de conocer el librería de windows.h que sin duda nos ayudar en nuestro implementación, también en conocer sobre los principios básicos  de tpc/ip, bueno otra cosa seria usar socket de windows y linux.

el problema:

Como profesional en sistema de información, una empresa llamado ComunicacionesAlom le pide que realice un programa que puede enviar una estructura de datos a dos cliente, esta esta conectado en una red local.

servidor:
enviar una estructura de datos:

cliente:
leer la estructura de datos, mostrarlo y guardarlo.

La información que se trasmitirá en la red no es suma importancia por lo cual no necesitara encriptacion.