viernes, 20 de noviembre de 2015

modificar configuración de web Server

Instalando una aplicación que utiliza Hibernate, aparecen errores de falta de memoria. La forma de solucionar eso en Glassfish esta en el siguiente enlace.

https://open.bekk.no/glassfish-production-tuning


NO FUNCIONO
--------------------------
La instalaci[on no funciona todav[ia, entonces se verifica la siguiente p[agina
http://www.anthoniraj.com/university-timetabling-system-unitime/

el archivo a modificar es :
-Djava.security.auth.login.config=${com.sun.aas.instanceRoot}/config/login.conf

 agregando
Timetabling {
org.unitime.timetable.authenticate.jaas.DbAuthenticateModule required;
};
 --------------------------
se trata de obtener informaci[on de debug agregando al archivo logging.properties
log4j.logger.org.unitime.timetable.authenticate.jaas=DEBUG

log4j.appender.unitimeLogFile=org.apache.log4j.DailyRollingFileAppender
log4j.appender.unitimeLogFile.File=${com.sun.aas.instanceRoot}/logs/unitime-debug.log
log4j.appender.unitimeLogFile.DatePattern='.'yyyy-MM-dd
log4j.appender.unitimeLogFile.Append=true
log4j.appender.unitimeLogFile.layout=org.apache.log4j.PatternLayout
log4j.appender.unitimeLogFile.layout.ConversionPattern=[%-d{MM/dd/yy HH:mm:ss}] %-6p %c{1} -> %m%n
log4j.logger.org.unitime=DEBUG, unitimeLogFile
log4j.logger.net.sf.cpsolver=DEBUG, unitimeLogFile

domingo, 4 de octubre de 2015

8km bomberos de Giron

El año pasado me enteré de la segunda edición del circuito campo traviesa de los bomberos de Girón. El circuito prometía grandes emociones. Pero por mala organización de mi parte llegué unos minutos luego de la partida y además no había revisado el trazado del circuito. Por estas razones simplemente completé la parte más obvia para mi y en lugar de correr los 8km tan solo corrí 5.5 km.

Para este año, la organización por mi parte fue mejor; y por fin corrí en la tercera edición.
Me gustó mucho por la irregularidad del terreno y por lo difícil del recorrido. Una linda prueba para los amantes del cross-country.
 

Perfil de elevación 8km bomberos de Girón
Perfil de elevación 8km bomberos de Girón

Aquí arriba les dejo el perfil de elevación del circuito y el ritmo que logré ponerle. Existe una subida de casi 200m para romper el corazón y la voluntad de cualquier corredor. Véase al ritmo al que se sube.
Bonita competencia, nos veremos para la 4 edición. 

viernes, 2 de octubre de 2015

avrdude stk500_recv(): programmer is not responding

Instalamos sketch/waspmote, seleccionamos la tarjeta adecuada:
- waspmoteAPIv017.
- seleccionamos el puerto USB correcto /dev/ttyUSB0,
- cambiamos los permisos del archivo

Pese a eso seguimos recibiendo el error:
avrdude: stk500_recv(): programmer is not responding

Bueno, primero verificar si avrdude esta instalado mediante:
avrdude -v -v -v -v
o instalar en ubuntu usando
sudo apt-get install avrdude

Una vez modificado el código que deseamos enviar al dispositivo, lo compilamos.
Si se presentan errores del tipo:
avrdude: Send: 0 [30] [20] 
avrdude: ser_recv(): programmer is not responding
avrdude: stk500_recv(): programmer is not responding


Unas búsquedas en Internet indican que se debe presionar el botón RESET antes de que se envien los paquetes avrdude: Send: 0 [30] [20] .
Pero al parecer mi problema era que el mote estaba apagado. Cuando el mote esta encendido se solucionó el problema y se trasfirió correctamente. 

Waspmote y conexión serial

Estoy jugando con un waspmote de la casa Libelium. El kit más básico viene con un adaptador USB para la antena y el Waspmote con su batería.
Siguiendo los tutoriales disponibles es posible cargar un programa de base para reportar las mediciones.

El problema al que me enfrenté: Si bien es posible utilizar XCTU-NG de la compañía Digi.com no es posible integrar facilmente con otras aplicaciones.
Libelium me ofrece la mega estación para olvidarme de estos problemas, solo que el presupuesto no me alcanza. Por esta razón se desarrolló una aplicación en JAVA que se conecta al puerto serial de la computadora. y así podemos recuperar los datos de los sensores y hacer lo que queramos.
Si se va a desarrollar en JAVA es necesario instalar las librerias nativas RXTX y añadir al path.

java -Djava.library.path=/usr/lib/jni/

La máquina Host utiliza el sistema operativo Linux Ubuntu.  Pero se obtienen errores del tipo SerOpenPort failed: permission denied intentar los siguientes pásos:

1. El usuario debe pertenecer al grupo dialup
$ id -Gn USUARIO
para saber a qué grupos el USUARIO pertenece. Y para cambiar
$ sudo usermod -a -G dialout USUARIO


n. Si por último estos pasos no funcionan, entonces cambiar los permisos de lectura del archivo especial de caractéres dónde se recuperan los datos.
~$ sudo chmod o+rw /dev/ttyUSB0

viernes, 10 de julio de 2015

Comer sockets

Del libro del Sr. Comer sobre Internetworking with TCP/IP se puede encontrar un ejemplo de la utilización de Sockets. También es válido para comunicación entre procesos IPC.
He aquí los dos archivos para el ejemplo:



 /*whoisclient.c -main */  
 #include <stdio.h>  
 #include <stdlib.h>  
 #include <string.h>  
 #include <sys/types.h>  
 #include <sys/socket.h>  
 #include <netinet/in.h>  
 #include <netdb.h>  
 /*_________________________________________________________________  
  * Program: whoisclient  
  *  
  *Purpose: UNIX application program thar becomes a client for the  
  *       Iternet "whois" services.  
  *  
  *Use:   whois hostname username  
  *  
  *__________________________________________________________________  
  */  
 main (argc,argv)  
 int argc;          /*standard UNIX argument declarations */  
 char *argv[];  
 {  
   int s;              /*socket descriptor           */  
   int len;               /*length of received data          */  
   struct sockaddr_in sa;     /*Internet socket addr, structure     */  
   struct hostent *hp;          /*result of host name lookup          */  
   struct servent *sp;          /*result of service lookup          */  
   char *myname;          /*pointer to name of this program     */  
   char *host;               /*pointer to mte host name          */  
   char *user;               /*ponter to mte user name          */  
   myname = argv[0];  
   char buf[BUFSIZ+1];  
   /*  
   * Check that there are two command line arguments  
   */  
 if(argc != 3){  
      fprintf(stderr,"Usage: %s host username\n", myname);  
      exit(1);  
 }   
 host = argv[1];  
 user = argv[2];  
 /*  
  * Look up the specified hostname  
  */  
 if((hp = gethostbyname(host)) == NULL) {  
      fprintf(stderr, "%s: %s: no such host?\n", myname, host);  
      exit(1);  
 }  
 /*  
  * Put host's addres and address type into socket structure  
  */  
 bcopy((char *)hp->h_addr, (char *)&sa.sin_addr, hp->h_length);  
 sa.sin_family = hp->h_addrtype;  
 /*  
  * Look up the socket number for the WHOIS service  
  */  
 if((sp = getservbyname("whois","tcp")) == NULL ){  
      fprintf(stderr,"%s: No whois service on this host\n", myname);  
      exit(1);  
 }  
 /*  
  * Put the whois socket number into the socket structure  
  */  
 sa.sin_port = sp->s_port;  
 /*  
  * Allocate an open socket  
  */  
 if ((s = socket(hp->h_addrtype, SOCK_STREAM,0)) < 0 ){  
      perror("socket");  
      exit(1);  
 }  
 /*  
  * Connect to the remote server ahora (struct sockaddr*)  antes &sa  
  */  
 if(connect(s, (struct sockaddr*)&sa , sizeof(sa)) < 0){  
      perror("connect");  
      exit(1);  
 }  
 /*  
  * Send the request  
  */  
 if(write(s, user, strlen(user)) != strlen(user)){  
      fprintf(stderr, "%s: write error\n", myname);  
      exit(1);  
 }  
 /*  
  * Read the reply and put to user's output  
  */  
 while( (len =read(s, buf, BUFSIZ)) > 0)  
      write(1, buf, len);  
 close(s);  
 exit(0);  
 }  


Y aquí el servidor.

 /* whoisserver.c - main */  
 #include <stdio.h>  
 #include <stdlib.h>  
 #include <string.h>  
 #include <sys/types.h>  
 #include <sys/socket.h>  
 #include <netinet/in.h>  
 #include <netdb.h>  
 #include <pwd.h>  
 /*______________________________________________________________  
  * Program:      whoisserver  
  *   
  * Purpose:   UNIX application program that acts as a server for   
  *          the "whois" service on the local machine. It listens  
  *          on well-known WHOIS port (43) and anwers queries from  
  *          client. This program requires super-user privilege to   
  *          run.  
  * Use:      whois hostname username  
  *  
  *______________________________________________________________________  
  */  
 #define BACKLOG   5                     /* # of requests we're willing to queve */  
 #define MAXHOSTNAME 32                    /* maximum host name length we tolerate */  
 main(argc, argv)  
      int argc;                    /* standard UNIX argument declarations */  
      char *argv[];  
 {  
      int s, t;                    /*socket descriptors               */  
      int i;                         /*general purpose integer          */  
      struct sockaddr_in sa, isa;          /*Internet socket structure          */  
      struct hostent *hp;               /*result of host name lookup          */  
      char *myname;                    /*pointer to name of this program     */  
       struct servent *sp;               /*result of service lookpup          */  
      char localhost[MAXHOSTNAME+1];      /*local host name as character string  */  
      myname = argv[0];  
      /*  
       * Look up the WHOIS service entry  
       */  
      if ((sp = getservbyname("whois", "tcp")) == NULL) {  
           fprintf(stderr, "%s: No whois service on this host\n", myname);  
           exit(1);  
      }  
      /*  
       * Fet our own host information  
       */  
      gethostname(localhost, MAXHOSTNAME);  
      if((hp = gethostbyname(localhost)) == NULL){  
           fprintf(stderr, "%s: cannot get local host info?\n", myname);  
           exit(1);  
      }  
      fprintf(stderr,"localhost: %s \n", localhost); /*BARROS */  
      /*  
       * Put the WHOIS socket number and our addres info  
       * into the socket structure  
       */  
      sa.sin_port = sp->s_port;  
      bcopy((char *)hp->h_addr, (char *)&sa.sin_addr, hp->h_length);  
      sa.sin_family = hp->h_addrtype;  
      /*   
       * Allocate an open socket for incoming connections  
       */  
      if((s = socket(hp->h_addrtype, SOCK_STREAM, 0)) < 0) {  
           perror("socket");  
           exit(1);       
      }  
      /*  
       * Bind the socket to the service port  
       * so we hear incoming connections  
       */  
      if(bind(s, (struct sockaddr*)&sa, sizeof sa) < 0) {  
           perror("bind");  
           exit(1);  
      }  
      /*  
       * Set maximum connections we will fall behind  
       */  
      listen(s, BACKLOG);  
      /*  
       * Go into an infinite loop waiting far new connections  
       */  
      while(1) {  
           i = sizeof isa;  
           fprintf(stderr,"i isa: %d , puerto %d , dirección %d\n", i, isa.sin_port, isa.sin_addr.s_addr); /*BARROS */  
           /*   
            * We hang in accept() while waiting for new customers  
            */  
           if((t = accept(s, (struct sockaddr*)&isa, &i)) < 0) {  
                perror("accept");  
                exit(1);  
           }  
           whois(t);               /* perform the actual WHOIS service */  
           close(t);  
      }  
 }  
      /*  
       * Get the WHOIS request from remote host and format a reply.  
       */  
      whois(sock)  
      int sock;  
 {  
      struct passwd *p;  
      char buf[BUFSIZ+1];  
      int i;  
      /*  
      * Get one line request  
       */  
      if((i =read(sock, buf, BUFSIZ)) <= 0)  
           return;  
      buf[i] = '\0';                    /* Null terminate */  
      /*  
        * Look up the requested user and format reply  
       */  
      if((p = getpwnam(buf)) == NULL)  
           strcpy(buf,"User not found\n");  
      else  
           sprintf(buf, "%s: %s\n", p->pw_name, p->pw_gecos);  
      /*  
        * Return reply  
       */  
      write(sock, buf, strlen(buf));  
      return;  
 }  

viernes, 19 de junio de 2015

De los datos libres

Las ideas no nos pertenecen, los dueños son los que en realidad las realizan. Recuerdo alguna vez que conversaba con un amigo sobre nuestras grandiosas ideas, ideas para cambiar el mundo e impactar de verdad en la historia y comodidad de la humanidad. Al finalizar la charla constatamos que no importa lo grandiosas que sea nuestras ideas, en realidad no habíamos hecho nada.

Viajado y viviendo en el extranjero uno se pregunta sobre por qué ellos sí y por qué nosotros no, sobre muchos temas.  Y es así que comenzamos a trabajar sobre servicios que explotan la información existente para mejorar la calidad de los servicios que la gente requiere.  Una idea que da vueltas hace mucho tiempo es la de poseer información sobre el paso de las unidades de transporte público por determinada parada.  Tecnología que existe hace mucho tiempo en otros lugares y que en mi ciudad es toda una pesadilla para dar un paso hacia adelante. Ver por ejemplo que existe un planificador de viaje como el presentado por www.tisseo.fr que nos permite especificar la hora de partida o de llegada, y nos muestra varias posibilidades permutando las líneas de transporte existentes; y comparar eso con mi ciudad en donde ni siquiera las rutas de los buses se pueden encontrar en Internet.

Es por eso que decidí tratar de utilizar mis conocimientos para proporcionar una solución a este problema.
Se trata de un sistema que permite enlazar un punto de partida y otro de llegada mediante varias de las líneas de transporte existente.

PASOS
1. Obtener datos (geometría) de las calles por donde pasan los buses.
2. Generar la geometría de las líneas de transporte. Una línea pasa por una secuencia de calles, en teoría podemos armar la ruta completa basados en las calles y sus intersecciones.
3. Generar el sistema recomendador  que se basa en la líneas existentes.
4. Refinar el problema mediante la agregación de restricciones adicionales como horarios de pasada, desvíos, y retardos.

AVANCE
1. Obtener la geometría.
Varias instituciones del gobierno han utilizado recursos para generar información cartográfica de la ciudad. El acceso a esta información es difícil y esta sujeto a gran cantidad de procesos burocráticos. Pero, sabemos que la información esta presentada utilizando un servidor ArcIMS. Este servidor permite publicar imágenes de mapas con un formato propietario, como si se tratará de un servicio Web Map Service (WMS) o Web Features Service (WFS).

Se debe enviar una petición post al host que alberga el servidor ArcIMS.
POST /servlet/com.esri.esrimap.Esrimap?ServiceName=nombreServicio&CustomService=Query&ClientVersion=4.0&Form=True&Encode=False

Se debe revisar el tipo de objeto ARCXML que se envía al servidor.
Por ejemplo una petición es:

"< arcxml version="1.1">
    < request>
        < get_features checkesc="true" envelope="false" featurelimit="25" geometry="false" outputmode="xml">
        < layer id="10">
        < spatialquery subfields="NOMENCLATU NOMBRE_APE">
           
               
           

        < /spatialquery>
        < /layer>< /get_features>
    < /request>"

Y una respuesta que llega sobre HTTP es:

"< arcxml version="1.1">

  < features>
    < feature>
      < fields nombre_ape="DIEZ DE AGOSTO" nomenclatu="LS-29">
    < /fields>< /feature>
  < featurecount count="1" hasmore="false">
  < /featurecount>< /features>< /response>"
Con estos mecanismos, se desarrolla un programa que se encarga de recoger las calles de la ciudad.

Postgres

psql
\connect nombrebd


ST_Distance(geometry g1, geometry g2);


SELECT ST_Distance(
    ST_Transform(ST_GeomFromText('POINT(-72.1235 42.3521)',4326),32717),
    ST_Transform(ST_GeomFromText('LINESTRING(-72.1260 42.45, -72.123 42.1546)', 4326),32717)
  );
st_distance
en metros 
 
 
# SELECT PostGIS_version();
            postgis_version            
---------------------------------------
 2.1 USE_GEOS=1 USE_PROJ=1 USE_STATS=1
(1 row)